Hook up link pools in GN.

tools/gn/function_toolchain.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 <algorithm>
+#include <limits>
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/tool.h"
 #include "tools/gn/toolchain.h"
 #include "tools/gn/value_extractors.h"
@@ skipping 179 matching lines @@
 const char kToolchain[] = "toolchain";
 const char kToolchain_HelpShort[] =
     "toolchain: Defines a toolchain.";
 const char kToolchain_Help[] =
     "toolchain: Defines a toolchain.\n"
     "\n"
     "  A toolchain is a set of commands and build flags used to compile the\n"
     "  source code. You can have more than one toolchain in use at once in\n"
     "  a build.\n"
     "\n"
-    "  A toolchain specifies the commands to run for various input file\n"
-    "  types via the \"tool\" call (see \"gn help tool\") and specifies\n"
-    "  arguments to be passed to the toolchain build via the\n"
-    "  \"toolchain_args\" call (see \"gn help toolchain_args\").\n"
+    "Functions and variables\n"
     "\n"
-    "  In addition, a toolchain can specify dependencies via the \"deps\"\n"
-    "  variable like a target. These dependencies will be resolved before any\n"
-    "  target in the toolchain is compiled. To avoid circular dependencies\n"
-    "  these must be targets defined in another toolchain.\n"
+    "  tool()\n"
+    "    The tool() function call specifies the commands commands to run for\n"
+    "    a given step. See \"gn help tool\".\n"
+    "\n"
+    "  toolchain_args()\n"
+    "    List of arguments to pass to the toolchain when invoking this\n"
+    "    toolchain. This applies only to non-default toolchains. See\n"
+    "    \"gn help toolchain_args\" for more.\n"
+    "\n"
+    "  deps\n"
+    "    Dependencies of this toolchain. These dependencies will be resolved\n"
+    "    before any target in the toolchain is compiled. To avoid circular\n"
+    "    dependencies these must be targets defined in another toolchain.\n"
+    "\n"
+    "    This is expressed as a list of targets, and generally these targets\n"
+    "    will always specify a toolchain:\n"
+    "      deps = [ \"//foo/bar:baz(//build/toolchain:bootstrap)\" ]\n"
+    "\n"
+    "    This concept is somewhat inefficient to express in Ninja (it\n"
+    "    requires a lot of duplicate of rules) so should only be used when\n"
+    "    absolutely necessary.\n"
+    "\n"
+    "  concurrent_links\n"
+    "    In integer expressing the number of links that Ninja will perform in\n"
+    "    parallel. GN will create a pool for shared library and executable\n"
+    "    link steps with this many processes. Since linking is memory- and\n"
+    "    I/O-intensive, projects with many large targets may want to limit\n"
+    "    the number of parallel steps to avoid overloading the computer.\n"
+    "    Since creating static libraries is generally not as intensive\n"
+    "    there is no limit to \"alink\" steps. Defaults to 4.\n"

[scottmg, 2014/08/26 22:41:49]

It ends up being 16 for gyp on a z620 fwiw. I don't know how much it matters.

+    "\n"
+    "    The value used will be the one from the default toolchain of the\n"
+    "    current build.\n"
     "\n"
     "Invoking targets in toolchains:\n"
     "\n"
     "  By default, when a target depends on another, there is an implicit\n"
     "  toolchain label that is inherited, so the dependee has the same one\n"
     "  as the dependent.\n"
     "\n"
     "  You can override this and refer to any other toolchain by explicitly\n"
     "  labeling the toolchain to use. For example:\n"
     "    datadeps = [ \"//plugins:mine(//toolchains:plugin_toolchain)\" ]\n"
     "  The string \"//build/toolchains:plugin_toolchain\" is a label that\n"
     "  identifies the toolchain declaration for compiling the sources.\n"
     "\n"
     "  To load a file in an alternate toolchain, GN does the following:\n"
     "\n"
     "   1. Loads the file with the toolchain definition in it (as determined\n"
     "      by the toolchain label).\n"
     "   2. Re-runs the master build configuration file, applying the\n"
     "      arguments specified by the toolchain_args section of the toolchain\n"
     "      definition (see \"gn help toolchain_args\").\n"
     "   3. Loads the destination build file in the context of the\n"
     "      configuration file in the previous step.\n"
     "\n"
     "Example:\n"
     "  toolchain(\"plugin_toolchain\") {\n"
+    "    concurrent_links = 8\n"
+    "\n"
     "    tool(\"cc\") {\n"
     "      command = \"gcc $in\"\n"
+    "      ...\n"
     "    }\n"
     "\n"
     "    toolchain_args() {\n"
     "      is_plugin = true\n"
     "      is_32bit = true\n"
     "      is_64bit = false\n"
     "    }\n"
     "  }\n";
 
 Value RunToolchain(Scope* scope,
@@ skipping 29 matching lines @@
   // Read deps (if any).
   const Value* deps_value = block_scope.GetValue(variables::kDeps, true);
   if (deps_value) {
     ExtractListOfLabels(
         *deps_value, block_scope.GetSourceDir(),
         ToolchainLabelForScope(&block_scope), &toolchain->deps(), err);
     if (err->has_error())
       return Value();
   }
 
+  // Read concurrent_links (if any).
+  const Value* concurrent_links_value =
+      block_scope.GetValue("concurrent_links", true);
+  if (concurrent_links_value) {
+    if (!concurrent_links_value->VerifyTypeIs(Value::INTEGER, err))
+      return Value();
+    if (concurrent_links_value->int_value() < 0 ||
+        concurrent_links_value->int_value() > std::numeric_limits<int>::max()) {
+      *err = Err(*concurrent_links_value, "Value out of range.");
+      return Value();
+    }
+    toolchain->set_concurrent_links(
+        static_cast<int>(concurrent_links_value->int_value()));
+  }
+
   if (!block_scope.CheckForUnusedVars(err))
     return Value();
 
   // Save this toolchain.
   toolchain->ToolchainSetupComplete();
   Scope::ItemVector* collector = scope->GetItemCollector();
   if (!collector) {
     *err = Err(function, "Can't define a toolchain in this context.");
     return Value();
   }
@@ skipping 151 matching lines @@
     "        Prefix to use for the output name. Defaults to empty. This\n"
     "        prefix will be prepended to the name of the target (or the\n"
     "        output_name if one is manually specified for it) if the prefix\n"
     "        is not already there. The result will show up in the\n"
     "        {{output_name}} substitution pattern.\n"
     "\n"
     "        This is typically used to prepend \"lib\" to libraries on\n"
     "        Posix systems:\n"
     "          output_prefix = \"lib\"\n"
     "\n"
-    // TODO(brettw) document "pool" when it works.
-    //"    pool  [string, optional]\n"
-    //"\n"
     "    restat  [boolean]\n"
     "        Valid for: all tools (optional, defaults to false)\n"
     "\n"
     "        Requests that Ninja check the file timestamp after this tool has\n"
     "        run to determine if anything changed. Set this if your tool has\n"
     "        the ability to skip writing output if the output file has not\n"
     "        changed.\n"
     "\n"
     "        Normally, Ninja will assume that when a tool runs the output\n"
     "        be new and downstream dependents must be rebuild. When this is\n"
@@ skipping 261 matching lines @@
       !ReadString(&block_scope, "lib_switch", tool.get(),
                   &Tool::set_lib_switch, err) ||
       !ReadString(&block_scope, "lib_dir_switch", tool.get(),
                   &Tool::set_lib_dir_switch, err) ||
       !ReadPattern(&block_scope, "link_output", subst_validator, tool.get(),
                    &Tool::set_link_output, err) ||
       !ReadPattern(&block_scope, "depend_output", subst_validator, tool.get(),
                    &Tool::set_depend_output, err) ||
       !ReadString(&block_scope, "output_prefix", tool.get(),
                   &Tool::set_output_prefix, err) ||
-      !ReadString(&block_scope, "pool", tool.get(), &Tool::set_pool, err) ||
       !ReadBool(&block_scope, "restat", tool.get(), &Tool::set_restat, err) ||
       !ReadPattern(&block_scope, "rspfile", subst_validator, tool.get(),
                    &Tool::set_rspfile, err) ||
       !ReadPattern(&block_scope, "rspfile_content", subst_validator, tool.get(),
                    &Tool::set_rspfile_content, err)) {
     return Value();
   }
 
   if (tool_type != Toolchain::TYPE_COPY && tool_type != Toolchain::TYPE_STAMP) {
     // All tools except the copy and stamp tools should have outputs. The copy
@@ skipping 114 matching lines @@
     return Value();
 
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   toolchain->args() = values;
 
   return Value();
 }
 
 }  // namespace functions