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 1356 matching lines @@
     }
     // 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);
+    Zone* const zone = stack_zone.GetZone();
+    const bool trace_compiler =
+        FLAG_trace_compiler ||
+        (FLAG_trace_optimizing_compiler && optimized);
+
+    if (trace_compiler) {
+      const intptr_t token_size = function.end_token_pos().Pos() -
+                                  function.token_pos().Pos();
+      THR_Print("Parsing %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);
+    }
+    ParsedFunction* parsed_function = new(zone) ParsedFunction(
+        thread, Function::ZoneHandle(zone, function.raw()));
+    pipeline->ParseFunction(parsed_function);
+    // For now we just walk thru the AST nodes and in DEBUG mode we print
+    // them otherwise just skip through them, this will be need to be
+    // wired to generate the IR format.
+#if defined(DEBUG)
+    AstPrinter ast_printer(true);
+#else
+    AstPrinter ast_printer(false);

[hausner, 2016/09/23 21:57:20]

What's the purpose of invoking the ast printer visitor when nothing is printed?

[siva, 2016/09/23 22:05:36]

I wanted to keep it to measure if traversing the AST nodes had any effect on the
overall time.

+#endif  // defined(DEBUG).
+    ast_printer.PrintFunctionNodes(*parsed_function);
+    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();
+    // Unoptimized compilation or precompilation may encounter compile-time
+    // errors, but regular optimized compilation should not.
+    ASSERT(!optimized);
+    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, thread->zone(), 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, "ParseFunction", 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.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 58 matching lines @@
     // Don't allow message interrupts while executing constant
     // expressions.  They can cause bogus recursive compilation.
     NoOOBMessageScope no_msg_scope(thread);
 
     // Don't allow reload requests to come in.
     NoReloadScope no_reload_scope(thread->isolate(), thread);
 
     if (FLAG_trace_compiler) {
       THR_Print("compiling expression: ");
       if (FLAG_support_ast_printer) {
-        AstPrinter::PrintNode(fragment);
+        AstPrinter ast_printer;
+        ast_printer.PrintNode(fragment);
       }
     }
 
     // Create a dummy function object for the code generator.
     // The function needs to be associated with a named Class: the interface
     // Function fits the bill.
     const char* kEvalConst = "eval_const";
     const Function& func = Function::ZoneHandle(Function::New(
         String::Handle(Symbols::New(thread, kEvalConst)),
         RawFunction::kRegularFunction,
@@ skipping 437 matching lines @@
 }
 
 
 RawError* Compiler::CompileFunction(Thread* thread,
                                     const Function& function) {
   UNREACHABLE();
   return Error::null();
 }
 
 
+RawError* Compiler::ParseFunction(Thread* thread,
+                                  const Function& function) {
+  UNREACHABLE();
+  return Error::null();
+}
+
+
 RawError* Compiler::EnsureUnoptimizedCode(Thread* thread,
                                           const Function& function) {
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileOptimizedFunction(Thread* thread,
                                              const Function& function,
                                              intptr_t osr_id) {
@@ skipping 13 matching lines @@
   UNREACHABLE();
 }
 
 
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
   UNREACHABLE();
   return Error::null();
 }
 
 
+RawError* Compiler::ParseAllFunctions(const Class& cls) {
+  UNREACHABLE();
+  return Error::null();
+}
+
+
 RawObject* Compiler::EvaluateStaticInitializer(const Field& field) {
   ASSERT(field.HasPrecompiledInitializer());
   const Function& initializer =
       Function::Handle(field.PrecompiledInitializer());
   return DartEntry::InvokeFunction(initializer, Object::empty_array());
 }
 
 
 RawObject* Compiler::ExecuteOnce(SequenceNode* fragment) {
   UNREACHABLE();
@@ skipping 37 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart