1 // Copyright 2011 Google Inc. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #ifndef NINJA_STATE_H_
16 #define NINJA_STATE_H_
17 
18 #include <map>
19 #include <set>
20 #include <string>
21 #include <vector>
22 
23 #include "eval_env.h"
24 #include "hash_map.h"
25 #include "util.h"
26 
27 struct Edge;
28 struct Node;
29 struct Rule;
30 
31 /// A pool for delayed edges.
32 /// Pools are scoped to a State. Edges within a State will share Pools. A Pool
33 /// will keep a count of the total 'weight' of the currently scheduled edges. If
34 /// a Plan attempts to schedule an Edge which would cause the total weight to
35 /// exceed the depth of the Pool, the Pool will enqueue the Edge instead of
36 /// allowing the Plan to schedule it. The Pool will relinquish queued Edges when
37 /// the total scheduled weight diminishes enough (i.e. when a scheduled edge
38 /// completes).
39 struct Pool {
PoolPool40   Pool(const std::string& name, int depth)
41     : name_(name), current_use_(0), depth_(depth), delayed_(&WeightedEdgeCmp) {}
42 
43   // A depth of 0 is infinite
is_validPool44   bool is_valid() const { return depth_ >= 0; }
depthPool45   int depth() const { return depth_; }
namePool46   const std::string& name() const { return name_; }
current_usePool47   int current_use() const { return current_use_; }
48 
49   /// true if the Pool might delay this edge
ShouldDelayEdgePool50   bool ShouldDelayEdge() const { return depth_ != 0; }
51 
52   /// informs this Pool that the given edge is committed to be run.
53   /// Pool will count this edge as using resources from this pool.
54   void EdgeScheduled(const Edge& edge);
55 
56   /// informs this Pool that the given edge is no longer runnable, and should
57   /// relinquish its resources back to the pool
58   void EdgeFinished(const Edge& edge);
59 
60   /// adds the given edge to this Pool to be delayed.
61   void DelayEdge(Edge* edge);
62 
63   /// Pool will add zero or more edges to the ready_queue
64   void RetrieveReadyEdges(std::set<Edge*>* ready_queue);
65 
66   /// Dump the Pool and its edges (useful for debugging).
67   void Dump() const;
68 
69  private:
70   std::string name_;
71 
72   /// |current_use_| is the total of the weights of the edges which are
73   /// currently scheduled in the Plan (i.e. the edges in Plan::ready_).
74   int current_use_;
75   int depth_;
76 
77   static bool WeightedEdgeCmp(const Edge* a, const Edge* b);
78 
79   typedef std::set<Edge*,bool(*)(const Edge*, const Edge*)> DelayedEdges;
80   DelayedEdges delayed_;
81 };
82 
83 /// Global state (file status) for a single run.
84 struct State {
85   static Pool kDefaultPool;
86   static Pool kConsolePool;
87   static const Rule kPhonyRule;
88 
89   State();
90 
91   void AddPool(Pool* pool);
92   Pool* LookupPool(const std::string& pool_name);
93 
94   Edge* AddEdge(const Rule* rule);
95 
96   Node* GetNode(StringPiece path, uint64_t slash_bits);
97   Node* LookupNode(StringPiece path) const;
98   Node* SpellcheckNode(const std::string& path);
99 
100   void AddIn(Edge* edge, StringPiece path, uint64_t slash_bits);
101   bool AddOut(Edge* edge, StringPiece path, uint64_t slash_bits);
102   bool AddDefault(StringPiece path, std::string* error);
103 
104   /// Reset state.  Keeps all nodes and edges, but restores them to the
105   /// state where we haven't yet examined the disk for dirty state.
106   void Reset();
107 
108   /// Dump the nodes and Pools (useful for debugging).
109   void Dump();
110 
111   /// @return the root node(s) of the graph. (Root nodes have no output edges).
112   /// @param error where to write the error message if somethings went wrong.
113   std::vector<Node*> RootNodes(std::string* error) const;
114   std::vector<Node*> DefaultNodes(std::string* error) const;
115 
116   /// Mapping of path -> Node.
117   typedef ExternalStringHashMap<Node*>::Type Paths;
118   Paths paths_;
119 
120   /// All the pools used in the graph.
121   std::map<std::string, Pool*> pools_;
122 
123   /// All the edges of the graph.
124   std::vector<Edge*> edges_;
125 
126   BindingEnv bindings_;
127   std::vector<Node*> defaults_;
128 };
129 
130 #endif  // NINJA_STATE_H_
131