Add --parse-all option in order to benchmark and measure the scanner/parser performance.

runtime/bin/main.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 60 matching lines @@
 
 // Value of the --packages flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_packages_file = NULL;
 
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
 static bool compile_all = false;
+static bool parse_all = false;
 
 
 // Global flag that is used to indicate that we want to use blobs/mmap instead
 // of assembly/shared libraries for precompilation.
 static bool use_blobs = false;
 
 
 // Global flag that is used to indicate that we want to compile everything in
 // the same way as precompilation before main, then continue running in the
 // same process.
@@ skipping 226 matching lines @@
                                     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   compile_all = true;
   return true;
 }
 
 
+static bool ProcessParseAllOption(const char* arg,
+                                  CommandLineOptions* vm_options) {
+  ASSERT(arg != NULL);
+  if (*arg != '\0') {
+    return false;
+  }
+  parse_all = true;
+  return true;
+}
+
+
 static bool ProcessUseBlobsOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   use_blobs = true;
   return true;
 }
 
@@ skipping 166 matching lines @@
   { "-h", ProcessHelpOption },
   { "--help", ProcessHelpOption },
   { "--packages=", ProcessPackagesOption },
   { "--package-root=", ProcessPackageRootOption },
   { "-v", ProcessVerboseOption },
   { "--verbose", ProcessVerboseOption },
   { "--version", ProcessVersionOption },
 
   // VM specific options to the standalone dart program.
   { "--compile_all", ProcessCompileAllOption },
+  { "--parse_all", ProcessParseAllOption },
   { "--enable-vm-service", ProcessEnableVmServiceOption },
   { "--disable-service-origin-check", ProcessDisableServiceOriginCheckOption },
   { "--observe", ProcessObserveOption },
   { "--snapshot=", ProcessSnapshotFilenameOption },
   { "--snapshot-kind=", ProcessSnapshotKindOption },
   { "--run-app-snapshot=", ProcessRunAppSnapshotOption },
   { "--use-blobs", ProcessUseBlobsOption },
   { "--trace-loading", ProcessTraceLoadingOption },
   { "--hot-reload-test-mode", ProcessHotReloadTestModeOption },
   { "--hot-reload-rollback-test-mode", ProcessHotReloadRollbackTestModeOption },
@@ skipping 265 matching lines @@
   if (Dart_IsServiceIsolate(isolate)) {
     // If this is the service isolate, load embedder specific bits and return.
     bool skip_library_load = run_app_snapshot;
     if (!VmService::Setup(vm_service_server_ip,
                           vm_service_server_port,
                           skip_library_load,
                           vm_service_dev_mode)) {
       *error = strdup(VmService::GetErrorMessage());
       return NULL;
     }
+#if 0

[hausner, 2016/09/09 16:31:07]

Maybe remove this entirely in a separate change?

[siva, 2016/09/23 00:04:03]

Removed the #if 0 ... #endif as I added a --parse-all option and let the
compile-all option remain the way it was.

     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
+#endif
     Dart_ExitScope();
     Dart_ExitIsolate();
     return isolate;
   }
 
   // Prepare builtin and other core libraries for use to resolve URIs.
   // Set up various closures, e.g: printing, timers etc.
   // Set up 'package root' for URI resolution.
   result = DartUtils::PrepareForScriptLoading(false, trace_loading);
   CHECK_RESULT(result);
@@ skipping 644 matching lines @@
                 "VM service loading failed: %s\n",
                 VmService::GetErrorMessage());
         fflush(stderr);
         exit(kErrorExitCode);
       }
     }
 
     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
+      Dart_ExitScope();

[hausner, 2016/09/09 17:30:51]

This will actually break tests that execute the code after compiling everything.
I think it's useful to be able to run a program and ask that all code be
compiled.

[siva, 2016/09/23 00:04:03]

Removed this as compile_all is unchanged.

+      // Shutdown the isolate.
+      Dart_ShutdownIsolate();
+      return false;
+    }
+
+    if (parse_all) {
+      result = Dart_ParseAll();
+      CHECK_RESULT(result);
+      Dart_ExitScope();
+      // Shutdown the isolate.
+      Dart_ShutdownIsolate();
+      return false;
     }
 
     if (is_noopt || (gen_snapshot_kind == kAppAOT)) {
       Dart_QualifiedFunctionName standalone_entry_points[] = {
         { "dart:_builtin", "::", "_getMainClosure" },
         { "dart:_builtin", "::", "_getPrintClosure" },
         { "dart:_builtin", "::", "_getUriBaseClosure" },
         { "dart:_builtin", "::", "_resolveInWorkingDirectory" },
         { "dart:_builtin", "::", "_setWorkingDirectory" },
         { "dart:_builtin", "::", "_setPackageRoot" },
@@ skipping 341 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }