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

runtime/vm/compiler.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 "vm/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 1355 matching lines @@
     ASSERT(!optimized);
     // Do not attempt to optimize functions that can cause errors.
     function.set_is_optimizable(false);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
+static RawError* ParseFunctionHelper(CompilationPipeline* pipeline,
+                                     const Function& function,
+                                     bool optimized,
+                                     intptr_t osr_id) {
+  ASSERT(!FLAG_precompiled_mode);
+  ASSERT(!optimized || function.was_compiled());
+  LongJumpScope jump;
+  if (setjmp(*jump.Set()) == 0) {
+    Thread* const thread = Thread::Current();
+    StackZone stack_zone(thread);
+    const bool trace_compiler =
+        FLAG_trace_compiler ||
+        (FLAG_trace_optimizing_compiler && optimized);
+    Timer per_compile_timer(trace_compiler, "Compilation time");
+    per_compile_timer.Start();
+
+    if (trace_compiler) {
+      const intptr_t token_size = function.end_token_pos().Pos() -
+                                  function.token_pos().Pos();
+      THR_Print("Compiling %s%sfunction %s: '%s' @ token %s, size %" Pd "\n",
+                (osr_id == Compiler::kNoOSRDeoptId ? "" : "osr "),
+                (optimized ? "optimized " : ""),
+                (Compiler::IsBackgroundCompilation() ? "(background)" : ""),
+                function.ToFullyQualifiedCString(),
+                function.token_pos().ToCString(),
+                token_size);
+    }
+    INC_STAT(thread, num_functions_compiled, 1);

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

I know this is just a temporary thing, but it might make sense not to increase
these counters here, because the functions do not really get compiled. Not
incrementing here allows us to see how many functions are in fact really
compiled as a side effect of loading code and parsing sources. (E.g. for
evaluating compile-time constants.)

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

Done.

+    if (optimized) {
+      INC_STAT(thread, num_functions_optimized, 1);
+    }
+    return Error::null();
+  } else {
+    Thread* const thread = Thread::Current();
+    StackZone stack_zone(thread);
+    Error& error = Error::Handle();
+    // We got an error during compilation or it is a bailout from background
+    // compilation (e.g., during parsing with EnsureIsFinalized).
+    error = thread->sticky_error();
+    thread->clear_sticky_error();
+    if (error.raw() == Object::background_compilation_error().raw()) {
+      // Exit compilation, retry it later.
+      if (FLAG_trace_bailout) {
+        THR_Print("Aborted background compilation: %s\n",
+            function.ToFullyQualifiedCString());
+      }
+      return Error::null();
+    }
+    // Unoptimized compilation or precompilation may encounter compile-time
+    // errors, but regular optimized compilation should not.
+    ASSERT(!optimized);
+    // Do not attempt to optimize functions that can cause errors.
+    function.set_is_optimizable(false);
+    return error.raw();
+  }
+  UNREACHABLE();
+  return Error::null();
+}
+
+
 RawError* Compiler::CompileFunction(Thread* thread,
                                     const Function& function) {
 #ifdef DART_PRECOMPILER
   if (FLAG_precompiled_mode) {
     return Precompiler::CompileFunction(thread, function);
   }
 #endif
   Isolate* isolate = thread->isolate();
 NOT_IN_PRODUCT(
   VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
@@ skipping 10 matching lines @@
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
 
   return CompileFunctionHelper(pipeline,
                                function,
                                /* optimized = */ false,
                                kNoOSRDeoptId);
 }
 
 
+RawError* Compiler::ParseFunction(Thread* thread,
+                                  const Function& function) {
+  Isolate* isolate = thread->isolate();
+NOT_IN_PRODUCT(
+  VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
+  TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "CompileFunction", function);
+)  // !PRODUCT
+
+  if (!isolate->compilation_allowed()) {
+    FATAL3("Precompilation missed function %s (%s, %s)\n",
+           function.ToLibNamePrefixedQualifiedCString(),
+           function.token_pos().ToCString(),
+           Function::KindToCString(function.kind()));
+  }
+
+  CompilationPipeline* pipeline =
+      CompilationPipeline::New(thread->zone(), function);
+
+  return ParseFunctionHelper(pipeline,
+                             function,
+                             /* optimized = */ false,
+                             kNoOSRDeoptId);
+}
+
+
 RawError* Compiler::EnsureUnoptimizedCode(Thread* thread,
                                           const Function& function) {
   if (function.unoptimized_code() != Object::null()) {
     return Error::null();
   }
   Code& original_code = Code::ZoneHandle(thread->zone());
   if (function.HasCode()) {
     original_code = function.CurrentCode();
   }
   CompilationPipeline* pipeline =
@@ skipping 131 matching lines @@
         return error.raw();
       }
       func.ClearICDataArray();
       func.ClearCode();
     }
   }
   return error.raw();
 }
 
 
+RawError* Compiler::ParseAllFunctions(const Class& cls) {
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Error& error = Error::Handle(zone);
+  Array& functions = Array::Handle(zone, cls.functions());
+  Function& func = Function::Handle(zone);
+  // Class dynamic lives in the vm isolate. Its array fields cannot be set to
+  // an empty array.
+  if (functions.IsNull()) {
+    ASSERT(cls.IsDynamicClass());
+    return error.raw();
+  }
+  // Compile all the regular functions.
+  for (int i = 0; i < functions.Length(); i++) {
+    func ^= functions.At(i);
+    ASSERT(!func.IsNull());
+    if (!func.HasCode() &&
+        !func.is_abstract() &&
+        !func.IsRedirectingFactory()) {
+      if ((cls.is_mixin_app_alias() || cls.IsMixinApplication()) &&
+          func.HasOptionalParameters()) {
+        // Skipping optional parameters in mixin application.
+        continue;
+      }
+      error = ParseFunction(thread, func);
+      if (!error.IsNull()) {
+        return error.raw();
+      }
+      func.ClearICDataArray();
+      func.ClearCode();
+    }
+  }
+  return error.raw();
+}
+
+
 RawObject* Compiler::EvaluateStaticInitializer(const Field& field) {
 #ifdef DART_PRECOMPILER
   if (FLAG_precompiled_mode) {
     return Precompiler::EvaluateStaticInitializer(field);
   }
 #endif
   ASSERT(field.is_static());
   // The VM sets the field's value to transiton_sentinel prior to
   // evaluating the initializer value.
   ASSERT(field.StaticValue() == Object::transition_sentinel().raw());
@@ skipping 612 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart