1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use hir
::def_id
::DefId
;
12 use rustc_data_structures
::fnv
::FnvHashMap
;
13 use session
::config
::OutputType
;
14 use std
::cell
::{Ref, RefCell}
;
18 use super::dep_node
::{DepNode, WorkProductId}
;
19 use super::query
::DepGraphQuery
;
21 use super::thread
::{DepGraphThreadData, DepMessage}
;
25 data
: Rc
<DepGraphData
>
29 /// We send messages to the thread to let it build up the dep-graph
30 /// from the current run.
31 thread
: DepGraphThreadData
,
33 /// When we load, there may be `.o` files, cached mir, or other such
34 /// things available to us. If we find that they are not dirty, we
35 /// load the path to the file storing those work-products here into
36 /// this map. We can later look for and extract that data.
37 previous_work_products
: RefCell
<FnvHashMap
<Arc
<WorkProductId
>, WorkProduct
>>,
39 /// Work-products that we generate in this run.
40 work_products
: RefCell
<FnvHashMap
<Arc
<WorkProductId
>, WorkProduct
>>,
44 pub fn new(enabled
: bool
) -> DepGraph
{
46 data
: Rc
::new(DepGraphData
{
47 thread
: DepGraphThreadData
::new(enabled
),
48 previous_work_products
: RefCell
::new(FnvHashMap()),
49 work_products
: RefCell
::new(FnvHashMap()),
54 pub fn query(&self) -> DepGraphQuery
<DefId
> {
55 self.data
.thread
.query()
58 pub fn in_ignore
<'graph
>(&'graph
self) -> Option
<raii
::IgnoreTask
<'graph
>> {
59 raii
::IgnoreTask
::new(&self.data
.thread
)
62 pub fn in_task
<'graph
>(&'graph
self, key
: DepNode
<DefId
>) -> Option
<raii
::DepTask
<'graph
>> {
63 raii
::DepTask
::new(&self.data
.thread
, key
)
66 pub fn with_ignore
<OP
,R
>(&self, op
: OP
) -> R
67 where OP
: FnOnce() -> R
69 let _task
= self.in_ignore();
73 pub fn with_task
<OP
,R
>(&self, key
: DepNode
<DefId
>, op
: OP
) -> R
74 where OP
: FnOnce() -> R
76 let _task
= self.in_task(key
);
80 pub fn read(&self, v
: DepNode
<DefId
>) {
81 if self.data
.thread
.is_enqueue_enabled() {
82 self.data
.thread
.enqueue(DepMessage
::Read(v
));
86 pub fn write(&self, v
: DepNode
<DefId
>) {
87 if self.data
.thread
.is_enqueue_enabled() {
88 self.data
.thread
.enqueue(DepMessage
::Write(v
));
92 /// Indicates that a previous work product exists for `v`. This is
93 /// invoked during initial start-up based on what nodes are clean
94 /// (and what files exist in the incr. directory).
95 pub fn insert_previous_work_product(&self, v
: &Arc
<WorkProductId
>, data
: WorkProduct
) {
96 debug
!("insert_previous_work_product({:?}, {:?})", v
, data
);
97 self.data
.previous_work_products
.borrow_mut()
98 .insert(v
.clone(), data
);
101 /// Indicates that we created the given work-product in this run
102 /// for `v`. This record will be preserved and loaded in the next
104 pub fn insert_work_product(&self, v
: &Arc
<WorkProductId
>, data
: WorkProduct
) {
105 debug
!("insert_work_product({:?}, {:?})", v
, data
);
106 self.data
.work_products
.borrow_mut()
107 .insert(v
.clone(), data
);
110 /// Check whether a previous work product exists for `v` and, if
111 /// so, return the path that leads to it. Used to skip doing work.
112 pub fn previous_work_product(&self, v
: &Arc
<WorkProductId
>) -> Option
<WorkProduct
> {
113 self.data
.previous_work_products
.borrow()
118 /// Access the map of work-products created during this run. Only
119 /// used during saving of the dep-graph.
120 pub fn work_products(&self) -> Ref
<FnvHashMap
<Arc
<WorkProductId
>, WorkProduct
>> {
121 self.data
.work_products
.borrow()
125 /// A "work product" is an intermediate result that we save into the
126 /// incremental directory for later re-use. The primary example are
127 /// the object files that we save for each partition at code
130 /// Each work product is associated with a dep-node, representing the
131 /// process that produced the work-product. If that dep-node is found
132 /// to be dirty when we load up, then we will delete the work-product
133 /// at load time. If the work-product is found to be clean, then we
134 /// will keep a record in the `previous_work_products` list.
136 /// In addition, work products have an associated hash. This hash is
137 /// an extra hash that can be used to decide if the work-product from
138 /// a previous compilation can be re-used (in addition to the dirty
141 /// As the primary example, consider the object files we generate for
142 /// each partition. In the first run, we create partitions based on
143 /// the symbols that need to be compiled. For each partition P, we
144 /// hash the symbols in P and create a `WorkProduct` record associated
145 /// with `DepNode::TransPartition(P)`; the hash is the set of symbols
148 /// The next time we compile, if the `DepNode::TransPartition(P)` is
149 /// judged to be clean (which means none of the things we read to
150 /// generate the partition were found to be dirty), it will be loaded
151 /// into previous work products. We will then regenerate the set of
152 /// symbols in the partition P and hash them (note that new symbols
153 /// may be added -- for example, new monomorphizations -- even if
154 /// nothing in P changed!). We will compare that hash against the
155 /// previous hash. If it matches up, we can reuse the object file.
156 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
157 pub struct WorkProduct
{
158 /// Extra hash used to decide if work-product is still suitable;
159 /// note that this is *not* a hash of the work-product itself.
160 /// See documentation on `WorkProduct` type for an example.
163 /// Saved files associated with this CGU
164 pub saved_files
: Vec
<(OutputType
, String
)>,