GN: Makes GN output deterministic

tools/gn/ninja_writer.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/ninja_writer.h"
 
 #include "tools/gn/builder.h"
 #include "tools/gn/loader.h"
 #include "tools/gn/location.h"
 #include "tools/gn/ninja_build_writer.h"
 #include "tools/gn/ninja_toolchain_writer.h"
 #include "tools/gn/settings.h"
+#include "tools/gn/target.h"
 
 NinjaWriter::NinjaWriter(const BuildSettings* build_settings,
                          Builder* builder)
     : build_settings_(build_settings),
       builder_(builder) {
 }
 
 NinjaWriter::~NinjaWriter() {
 }
 
 // static
 bool NinjaWriter::RunAndWriteFiles(const BuildSettings* build_settings,
                                    Builder* builder,
                                    Err* err) {
   NinjaWriter writer(build_settings, builder);
 
   std::vector<const Settings*> all_settings;
   std::vector<const Target*> default_targets;
   if (!writer.WriteToolchains(&all_settings, &default_targets, err))
     return false;
+
+  // Sort targets so that they are in a deterministic order.

[M-A Ruel, 2015/12/07 15:09:50]

I'd prefer WriteToolchains() to return a sorted list instead.

[Zachary Forman, 2015/12/08 09:40:43]

This is a good idea. It'll improve speed (as the work was currently duplicated).

+  std::sort(
+      default_targets.begin(), default_targets.end(),
+      [](const Target* a, const Target* b) { return a->label() < b->label(); });
+
   return writer.WriteRootBuildfiles(all_settings, default_targets, err);
 }
 
 // static
 bool NinjaWriter::RunAndWriteToolchainFiles(
     const BuildSettings* build_settings,
     Builder* builder,
     std::vector<const Settings*>* all_settings,
     Err* err) {
   NinjaWriter writer(build_settings, builder);
   std::vector<const Target*> default_targets;
   return writer.WriteToolchains(all_settings, &default_targets, err);
 }
 
 bool NinjaWriter::WriteToolchains(std::vector<const Settings*>* all_settings,
                                   std::vector<const Target*>* default_targets,
                                   Err* err) {
   // Categorize all targets by toolchain.
   typedef std::map<Label, std::vector<const Target*> > CategorizedMap;

[M-A Ruel, 2015/12/07 15:09:50]

You could use a set<> for Target* here, so they would be sorted on the fly. Then
the following iterations can stay const.

wdyt?

[Zachary Forman, 2015/12/08 09:40:42]

A std::set<Target*> would be sorted by pointer order, which is still
nondeterministic.

We could add a custom comparator to the set, which would probably make that
approach better, /but/ subsequent functions expect a std::vector.

I've reshuffled it slightly so that we have consts more often, however.

[M-A Ruel, 2015/12/08 13:49:29]

I had meant with a std:less<> that short based on the target name, but it's not
a big deal.

   CategorizedMap categorized;
 
   std::vector<const BuilderRecord*> all_records = builder_->GetAllRecords();
   for (const auto& all_record : all_records) {
     if (all_record->type() == BuilderRecord::ITEM_TARGET &&
         all_record->should_generate()) {
       categorized[all_record->label().GetToolchainLabel()].push_back(
           all_record->item()->AsTarget());
       }
   }
   if (categorized.empty()) {
     Err(Location(), "No targets.",
         "I could not find any targets to write, so I'm doing nothing.")
         .PrintToStdout();
     return false;
   }
 
   Label default_label = builder_->loader()->GetDefaultToolchain();
 
   // Write out the toolchain buildfiles, and also accumulate the set of
   // all settings and find the list of targets in the default toolchain.
-  for (CategorizedMap::const_iterator i = categorized.begin();
-       i != categorized.end(); ++i) {
+  for (CategorizedMap::iterator i = categorized.begin(); i != categorized.end();

[M-A Ruel, 2015/12/07 15:09:50]

If you use a set above, you can switch to an enumeration using "const auto&"

[Zachary Forman, 2015/12/08 09:40:42]

Have done.

+       ++i) {
     const Settings* settings =
         builder_->loader()->GetToolchainSettings(i->first);
     const Toolchain* toolchain = builder_->GetToolchain(i->first);
 
     all_settings->push_back(settings);
+
     if (!NinjaToolchainWriter::RunAndWriteFile(settings, toolchain,
                                                i->second)) {
       Err(Location(),
           "Couldn't open toolchain buildfile(s) for writing").PrintToStdout();
       return false;
     }
   }
 
   *default_targets = categorized[default_label];
   return true;
 }
 
 bool NinjaWriter::WriteRootBuildfiles(
     const std::vector<const Settings*>& all_settings,
     const std::vector<const Target*>& default_targets,
     Err* err) {
   // All Settings objects should have the same default toolchain, and there
   // should always be at least one settings object in the build.
   CHECK(!all_settings.empty());
   const Toolchain* default_toolchain =
       builder_->GetToolchain(all_settings[0]->default_toolchain_label());
 
   // Write the root buildfile.
   return NinjaBuildWriter::RunAndWriteFile(build_settings_, all_settings,
                                            default_toolchain, default_targets,
                                            err);
 }