[complier] Enable parallel eager inner function compilation with compiler dispatcher.

src/compiler.cc

 // Copyright 2012 the V8 project 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 "src/compiler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-typer.h"
 #include "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
 #include "src/ast/scopes.h"
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/compilation-cache.h"
+#include "src/compiler-dispatcher/compiler-dispatcher.h"
 #include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"
 #include "src/compiler/pipeline.h"
 #include "src/crankshaft/hydrogen.h"
 #include "src/debug/debug.h"
 #include "src/debug/liveedit.h"
 #include "src/frames-inl.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/globals.h"
 #include "src/heap/heap.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 340 matching lines @@
   // Checks whether top level functions should be passed by the filter.
   if (shared->is_toplevel()) {
     Vector<const char> filter = CStrVector(FLAG_ignition_filter);
     return (filter.length() == 0) || (filter.length() == 1 && filter[0] == '*');
   }
 
   // Finally respect the filter.
   return shared->PassesFilter(FLAG_ignition_filter);
 }
 
+bool UseAsmWasm(CompilationInfo* info) {
+  return FLAG_validate_asm && info->scope()->asm_module() &&
+         !info->shared_info()->is_asm_wasm_broken() && !info->is_debug();
+}
+
 CompilationJob* GetUnoptimizedCompilationJob(CompilationInfo* info) {
   // Function should have been parsed and analyzed before creating a compilation
   // job.
   DCHECK_NOT_NULL(info->literal());
   DCHECK_NOT_NULL(info->scope());
 
   EnsureFeedbackMetadata(info);
   if (ShouldUseIgnition(info)) {
     return interpreter::Interpreter::NewCompilationJob(info);
   } else {
@@ skipping 33 matching lines @@
   // Update the shared function info with the scope info.
   InstallSharedScopeInfo(info, shared);
 
   // Install compilation result on the shared function info
   InstallSharedCompilationResult(info, shared);
 }
 
 CompilationJob::Status FinalizeUnoptimizedCompilationJob(CompilationJob* job) {
   CompilationJob::Status status = job->FinalizeJob();
   if (status == CompilationJob::SUCCEEDED) {
-    InstallUnoptimizedCode(job->info());
+    CompilationInfo* info = job->info();

[marja, 2017/01/10 09:58:54]

I'm confused; why is this kind of change needed in this CL?

[rmcilroy, 2017/01/12 12:31:55]

The reason is that the MarkToBeExecutedOnce used to be called in
CompileUnoptimizedInnerFunctionsRecursively after the function was compiled,
however now the function is only enqueued for compile there, so we can't mark
the code object. I've moved it here so that it's done when we finalize the
compilation job.

+    DCHECK(!info->code().is_null());
+    if (info->parse_info()->literal()->should_be_used_once_hint()) {
+      info->code()->MarkToBeExecutedOnce(info->isolate());
+    }
+    InstallUnoptimizedCode(info);
     job->RecordUnoptimizedCompilationStats();
   }
   return status;
 }
 
 bool Renumber(ParseInfo* parse_info) {
   if (!AstNumbering::Renumber(parse_info->isolate(), parse_info->zone(),
                               parse_info->literal(),
                               parse_info->eager_inner_function_literals())) {
     return false;
   }
   Handle<SharedFunctionInfo> shared_info = parse_info->shared_info();
   if (!shared_info.is_null()) {
     FunctionLiteral* lit = parse_info->literal();
     shared_info->set_ast_node_count(lit->ast_node_count());
     if (lit->dont_optimize_reason() != kNoReason) {
       shared_info->DisableOptimization(lit->dont_optimize_reason());
     }
     if (lit->flags() & AstProperties::kMustUseIgnitionTurbo) {
       shared_info->set_must_use_ignition_turbo(true);
     }
   }
   return true;
 }
 
 bool GenerateUnoptimizedCode(CompilationInfo* info) {
-  if (FLAG_validate_asm && info->scope()->asm_module() &&
-      !info->shared_info()->is_asm_wasm_broken() && !info->is_debug()) {
+  if (UseAsmWasm(info)) {
     EnsureFeedbackMetadata(info);
     MaybeHandle<FixedArray> wasm_data;
     wasm_data = AsmJs::CompileAsmViaWasm(info);
     if (!wasm_data.is_null()) {
       info->shared_info()->set_asm_wasm_data(*wasm_data.ToHandleChecked());
       info->SetCode(info->isolate()->builtins()->InstantiateAsmJs());
       InstallUnoptimizedCode(info);
       return true;
     }
   }
@@ skipping 22 matching lines @@
         script->FindSharedFunctionInfo(isolate, literal);
     if (maybe_existing.ToHandle(&shared)) {
       DCHECK(!shared->is_toplevel());
       // If we found an existing shared function info with compiled code,
       // we are done.
       if (shared->is_compiled()) continue;
     } else {
       shared =
           isolate->factory()->NewSharedFunctionInfoForLiteral(literal, script);
       shared->set_is_toplevel(false);
+      Scope* outer_scope = literal->scope()->GetOuterScopeWithContext();
+      if (outer_scope) {
+        shared->set_outer_scope_info(*outer_scope->scope_info());
+      }
     }
 
-    Zone zone(isolate->allocator(), ZONE_NAME);
-    ParseInfo parse_info(&zone, script);
-    parse_info.set_literal(literal);
-    parse_info.set_shared_info(shared);
-    parse_info.set_function_literal_id(shared->function_literal_id());
-    parse_info.set_language_mode(literal->scope()->language_mode());
-    parse_info.set_ast_value_factory(
+    std::unique_ptr<Zone> zone(new Zone(isolate->allocator(), ZONE_NAME));
+    std::unique_ptr<ParseInfo> parse_info(new ParseInfo(zone.get(), script));
+    std::unique_ptr<CompilationInfo> info(
+        new CompilationInfo(parse_info.get(), Handle<JSFunction>::null()));
+
+    parse_info->set_literal(literal);
+    parse_info->set_shared_info(shared);
+    parse_info->set_function_literal_id(shared->function_literal_id());
+    parse_info->set_language_mode(literal->scope()->language_mode());
+    parse_info->set_ast_value_factory(
         outer_info->parse_info()->ast_value_factory());
-    parse_info.set_ast_value_factory_owned(false);
+    parse_info->set_ast_value_factory_owned(false);
 
-    CompilationInfo info(&parse_info, Handle<JSFunction>::null());
-    if (outer_info->will_serialize()) info.PrepareForSerializing();
-    if (outer_info->is_debug()) info.MarkAsDebug();
+    if (outer_info->will_serialize()) info->PrepareForSerializing();
+    if (outer_info->is_debug()) info->MarkAsDebug();
 
-    if (!Renumber(&parse_info) ||
+    if (!Renumber(parse_info.get()) ||
         !CompileUnoptimizedInnerFunctionsRecursively(
-            parse_info.eager_inner_function_literals(), &info) ||
-        !GenerateUnoptimizedCode(&info)) {
+            parse_info->eager_inner_function_literals(), info.get())) {
       if (!isolate->has_pending_exception()) isolate->StackOverflow();
       return false;
     }
 
-    DCHECK(!info.code().is_null());
-    RecordFunctionCompilation(CodeEventListener::FUNCTION_TAG, &info);
-    if (literal->should_be_used_once_hint()) {
-      info.code()->MarkToBeExecutedOnce(isolate);
+    if (isolate->compiler_dispatcher()->IsEnabled() &&
+        !UseAsmWasm(info.get())) {
+      std::unique_ptr<CompilationJob> job(
+          Compiler::PrepareUnoptimizedCompilationJob(info.get()));
+      if (!job ||
+          !isolate->compiler_dispatcher()->Enqueue(
+              zone.release(), parse_info.release(), info.release(),
+              job.release())) {
+        if (!isolate->has_pending_exception()) isolate->StackOverflow();

[marja, 2017/01/10 09:58:54]

This logic ("if isolate doesn't have a pending exception but something fails, it
must be a stack overflow") is now getting scattered even more. Would it be
possible to refactor that out somehow (e.g., that the thing that potentially
fails would set the stack overflow)?

[rmcilroy, 2017/01/12 12:31:55]

I agree this is getting scattered everywhere. I've removed most of these and
just kept the one in the outer CompileUnoptimizedCode().

+        return false;
+      }
+    } else {
+      if (!GenerateUnoptimizedCode(info.get())) {
+        if (!isolate->has_pending_exception()) isolate->StackOverflow();
+        return false;
+      }
     }
   }
   return true;
 }
 
 bool CompileUnoptimizedCode(CompilationInfo* info) {
   Isolate* isolate = info->isolate();
   DCHECK(AllowCompilation::IsAllowed(isolate));
 
   if (!Compiler::Analyze(info->parse_info()) ||
       !CompileUnoptimizedInnerFunctionsRecursively(
           info->parse_info()->eager_inner_function_literals(), info) ||
       !GenerateUnoptimizedCode(info)) {
     if (!isolate->has_pending_exception()) isolate->StackOverflow();
     return false;
   }
 
+  if (isolate->compiler_dispatcher()->IsEnabled()) {
+    // TODO(rmcilroy): Remove this once the enqueued tasks can keep the parsed
+    // zone and handles alive and replace with a check in CompileLazy to finish
+    // the task itself.
+    isolate->compiler_dispatcher()->FinishAllNow();
+  }
+
   return true;
 }
 
 void EnsureSharedFunctionInfosArrayOnScript(ParseInfo* info) {
   DCHECK(info->is_toplevel());
   DCHECK(!info->script().is_null());
   if (info->script()->shared_function_infos()->length() > 0) {
     DCHECK_EQ(info->script()->shared_function_infos()->length(),
               info->max_function_literal_id() + 1);
     return;
@@ skipping 1202 matching lines @@
     DCHECK(shared->is_compiled());
     function->set_literals(cached.literals);
   } else if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8