text: // Copyright 2014 Google Inc. All Rights Reserved.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  //     http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  // Tests manifest parser performance.  Expects to be run in ninja's root
  // directory.
  
  #include <numeric>
  
  #include <errno.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  
  #ifdef _WIN32
  #include <direct.h>
  #include "getopt.h"
  #else
  #include <getopt.h>
  #include <unistd.h>
  #endif
  
  #include "disk_interface.h"
  #include "graph.h"
  #include "manifest_parser.h"
  #include "metrics.h"
  #include "state.h"
  #include "util.h"
  
  bool WriteFakeManifests(const string& dir, string* err) {
    RealDiskInterface disk_interface;
    TimeStamp mtime = disk_interface.Stat(dir + "/build.ninja", err);
    if (mtime != 0)  // 0 means that the file doesn't exist yet.
      return mtime != -1;
  
    string command = "python misc/write_fake_manifests.py " + dir;
    printf("Creating manifest data...");
    fflush(stdout);
    int exit_code = system(command.c_str());
    printf("done.\n");
    if (exit_code != 0)
      *err = "Failed to run " + command;
    return exit_code == 0;
  }
  
  int LoadManifests(bool measure_command_evaluation) {
    string err;
    RealDiskInterface disk_interface;
    State state;
    ManifestParser parser(&state, &disk_interface, kDupeEdgeActionWarn);
    if (!parser.Load("build.ninja", &err)) {
      fprintf(stderr, "Failed to read test data: %s\n", err.c_str());
      exit(1);
    }
    // Doing an empty build involves reading the manifest and evaluating all
    // commands required for the requested targets. So include command
    // evaluation in the perftest by default.
    int optimization_guard = 0;
    if (measure_command_evaluation)
      for (size_t i = 0; i < state.edges_.size(); ++i)
        optimization_guard += state.edges_[i]->EvaluateCommand().size();
    return optimization_guard;
  }
  
  int main(int argc, char* argv[]) {
    bool measure_command_evaluation = true;
    int opt;
    while ((opt = getopt(argc, argv, const_cast<char*>("fh"))) != -1) {
      switch (opt) {
      case 'f':
        measure_command_evaluation = false;
        break;
      case 'h':
      default:
        printf(
            "usage: manifest_parser_perftest\n"
            "\n"
            "options:\n"
            "  -f     only measure manifest load time, not command evaluation "
            "time\n");
        return 1;
      }
    }
  
    const char kManifestDir[] = "build/manifest_perftest";
  
    string err;
    if (!WriteFakeManifests(kManifestDir, &err)) {
      fprintf(stderr, "Failed to write test data: %s\n", err.c_str());
      return 1;
    }
  
    if (chdir(kManifestDir) < 0)
      Fatal("chdir: %s", strerror(errno));
  
    const int kNumRepetitions = 5;
    vector<int> times;
    for (int i = 0; i < kNumRepetitions; ++i) {
      int64_t start = GetTimeMillis();
      int optimization_guard = LoadManifests(measure_command_evaluation);
      int delta = (int)(GetTimeMillis() - start);
      printf("%dms (hash: %x)\n", delta, optimization_guard);
      times.push_back(delta);
    }
  
    int min = *min_element(times.begin(), times.end());
    int max = *max_element(times.begin(), times.end());
    float total = accumulate(times.begin(), times.end(), 0.0f);
    printf("min %dms  max %dms  avg %.1fms\n", min, max, total / times.size());
  }
  