version 1.1.0v1.1.0

1 files changed, 61 insertions, 2 deletions

diff --git a/src/state.h b/src/state.h
index 026acf3..918fe09 100644
--- a/src/state.h
+++ b/src/state.h
@@ -16,6 +16,8 @@
 #define NINJA_STATE_H_
 
 #include <map>
+#include <deque>
+#include <set>
 #include <string>
 #include <vector>
 using namespace std;
@@ -27,8 +29,59 @@ struct Edge;
 struct Node;
 struct Rule;
 
+/// A pool for delayed edges.
+/// Pools are scoped to a State. Edges within a State will share Pools. A Pool
+/// will keep a count of the total 'weight' of the currently scheduled edges. If
+/// a Plan attempts to schedule an Edge which would cause the total weight to
+/// exceed the depth of the Pool, the Pool will enque the Edge instead of
+/// allowing the Plan to schedule it. The Pool will relinquish queued Edges when
+/// the total scheduled weight diminishes enough (i.e. when a scheduled edge
+/// completes).
+struct Pool {
+  explicit Pool(const string& name, int depth)
+    : name_(name), current_use_(0), depth_(depth) { }
+
+  // A depth of 0 is infinite
+  bool is_valid() const { return depth_ >= 0; }
+  int depth() const { return depth_; }
+  const string& name() const { return name_; }
+
+  /// true if the Pool might delay this edge
+  bool ShouldDelayEdge() const { return depth_ != 0; }
+
+  /// informs this Pool that the given edge is committed to be run.
+  /// Pool will count this edge as using resources from this pool.
+  void EdgeScheduled(const Edge& edge);
+
+  /// informs this Pool that the given edge is no longer runnable, and should
+  /// relinquish its resources back to the pool
+  void EdgeFinished(const Edge& edge);
+
+  /// adds the given edge to this Pool to be delayed.
+  void DelayEdge(Edge* edge);
+
+  /// Pool will add zero or more edges to the ready_queue
+  void RetrieveReadyEdges(set<Edge*>* ready_queue);
+
+  /// Dump the Pool and its edges (useful for debugging).
+  void Dump() const;
+
+private:
+  int UnitsWaiting() { return delayed_.size(); }
+
+  string name_;
+
+  /// |current_use_| is the total of the weights of the edges which are
+  /// currently scheduled in the Plan (i.e. the edges in Plan::ready_).
+  int current_use_;
+  int depth_;
+
+  deque<Edge*> delayed_;
+};
+
 /// Global state (file status, loaded rules) for a single run.
 struct State {
+  static Pool kDefaultPool;
   static const Rule kPhonyRule;
 
   State();
@@ -36,7 +89,10 @@ struct State {
   void AddRule(const Rule* rule);
   const Rule* LookupRule(const string& rule_name);
 
-  Edge* AddEdge(const Rule* rule);
+  void AddPool(Pool* pool);
+  Pool* LookupPool(const string& pool_name);
+
+  Edge* AddEdge(const Rule* rule, Pool* pool);
 
   Node* GetNode(StringPiece path);
   Node* LookupNode(StringPiece path);
@@ -50,7 +106,7 @@ struct State {
   /// state where we haven't yet examined the disk for dirty state.
   void Reset();
 
-  /// Dump the nodes (useful for debugging).
+  /// Dump the nodes and Pools (useful for debugging).
   void Dump();
 
   /// @return the root node(s) of the graph. (Root nodes have no output edges).
@@ -65,6 +121,9 @@ struct State {
   /// All the rules used in the graph.
   map<string, const Rule*> rules_;
 
+  /// All the pools used in the graph.
+  map<string, Pool*> pools_;
+
   /// All the edges of the graph.
   vector<Edge*> edges_;