Add support for user defined "pool" to GN.

tools/gn/functions.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/functions.h"
 
 #include <stddef.h>
 #include <iostream>
 #include <utility>
 
 #include "base/environment.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parse_tree.h"
+#include "tools/gn/pool.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/template.h"
 #include "tools/gn/token.h"
 #include "tools/gn/value.h"
 #include "tools/gn/value_extractors.h"
 #include "tools/gn/variables.h"
 
 namespace {
@@ skipping 643 matching lines @@
     *err = Err(function, "set_sources_assignment_filter takes one argument.");
   } else {
     std::unique_ptr<PatternList> f(new PatternList);
     f->SetFromValue(args[0], err);
     if (!err->has_error())
       scope->set_sources_assignment_filter(std::move(f));
   }
   return Value();
 }
 
+// pool ------------------------------------------------------------------------
+
+const char kPool[] = "pool";
+const char kPool_HelpShort[] =
+    "pool: Defines a pool object.";
+const char kPool_Help[] =
+    "pool: Defines a pool object.\n"
+    "\n"
+    "  Pool objects can be applied to tool to limit the parallelism of the\n"

[Dirk Pranke, 2016/05/25 02:04:52]

Nit: "applied to a tool".

[sdefresne, 2016/05/26 15:38:37]

Done.

+    "  build. This object has a single property \"depth\" corresponding to\n"
+    "  the number of tasks that may run simultaneously.\n"
+    "\n"
+    "  A pool is referenced by its label just like a target.\n"

[brettw, 2016/05/24 22:03:31]

The file containing the pool definition could theoretically be executed in the
context of more than one toolchain. This will give you multiple pool definitions
which is probably not what's desired.

I think we should note here that it's recommended to specify an explicit
toolchain on the pool definition and references to ensure that there is exactly
one pool definition with that name.

Then make the example look like:

  if (current_toolchain == default_toolchain) {
    pool("link_pool") {
      depth = 1"
    }
  }

  ...
       pool = ":link_pool($default_toolchain)"

[sdefresne, 2016/05/26 15:38:37]

Good point. Done.

+    "\n"
+    "Variables\n"
+    "\n"
+    "  depth*\n"
+    "  * = required\n"
+    "\n"
+    "Example\n"
+    "\n"
+    "  pool(\"link_pool\") {\n"
+    "    depth = 1\n"
+    "  }\n"
+    "\n"
+    "  toolchain(\"toolchain\") {\n"
+    "    tool(\"link\") {\n"
+    "      command = \"...\"\n"
+    "      pool = \":link_pool\")\n"
+    "    }\n"
+    "  }\n";
+
+const char kDepth[] = "depth";
+
+Value RunPool(const FunctionCallNode* function,
+              const std::vector<Value>& args,
+              Scope* scope,
+              Err* err) {
+  NonNestableBlock non_nestable(scope, function, "pool");
+  if (!non_nestable.Enter(err))
+    return Value();
+
+  if (!EnsureSingleStringArg(function, args, err) ||
+      !EnsureNotProcessingImport(function, scope, err))
+    return Value();
+
+  Label label(MakeLabelForScope(scope, function, args[0].string_value()));
+
+  if (g_scheduler->verbose_logging())
+    g_scheduler->Log("Defining pool", label.GetUserVisibleName(true));
+
+  // Get the pool depth. It is an error to define a pool without a depth,
+  // so check first for the presence of the value.
+  const Value* depth = scope->GetValue(kDepth, true);
+  if (!depth) {
+    *err = Err(function, "Can't define a pool without depth.");
+    return Value();
+  }
+
+  if (!depth->VerifyTypeIs(Value::INTEGER, err))
+    return Value();
+
+  if (depth->int_value() < 0) {
+    *err = Err(function, "depth must be positive or nul.");
+    return Value();
+  }
+
+  // Create the new pool.
+  std::unique_ptr<Pool> pool(new Pool(scope->settings(), label));
+  pool->set_depth(depth->int_value());
+
+  // Save the generated item.
+  Scope::ItemVector* collector = scope->GetItemCollector();
+  if (!collector) {
+    *err = Err(function, "Can't define a pool in this context.");
+    return Value();
+  }
+  collector->push_back(pool.release());
+
+  return Value();
+}
+
 // print -----------------------------------------------------------------------
 
 const char kPrint[] = "print";
 const char kPrint_HelpShort[] =
     "print: Prints to the console.";
 const char kPrint_Help[] =
     "print: Prints to the console.\n"
     "\n"
     "  Prints all arguments to the console separated by spaces. A newline is\n"
     "  automatically appended to the end.\n"
@@ skipping 128 matching lines @@
     INSERT_FUNCTION(DeclareArgs, false)
     INSERT_FUNCTION(Defined, false)
     INSERT_FUNCTION(ExecScript, false)
     INSERT_FUNCTION(ForEach, false)
     INSERT_FUNCTION(ForwardVariablesFrom, false)
     INSERT_FUNCTION(GetEnv, false)
     INSERT_FUNCTION(GetLabelInfo, false)
     INSERT_FUNCTION(GetPathInfo, false)
     INSERT_FUNCTION(GetTargetOutputs, false)
     INSERT_FUNCTION(Import, false)
+    INSERT_FUNCTION(Pool, false)
     INSERT_FUNCTION(Print, false)
     INSERT_FUNCTION(ProcessFileTemplate, false)
     INSERT_FUNCTION(ReadFile, false)
     INSERT_FUNCTION(RebasePath, false)
     INSERT_FUNCTION(SetDefaults, false)
     INSERT_FUNCTION(SetDefaultToolchain, false)
     INSERT_FUNCTION(SetSourcesAssignmentFilter, false)
     INSERT_FUNCTION(Template, false)
     INSERT_FUNCTION(Tool, false)
     INSERT_FUNCTION(Toolchain, false)
@@ skipping 82 matching lines @@
   }
 
   // Otherwise it's a no-block function.
   if (!VerifyNoBlockForFunctionCall(function, block, err))
     return Value();
   return found_function->second.no_block_runner(scope, function,
                                                 args.list_value(), err);
 }
 
 }  // namespace functions