[wasm] Split the wasm compilation into two phases for parallel compilation.

src/wasm/wasm-module.cc

 // Copyright 2015 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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
@@ skipping 491 matching lines @@
 
   //-------------------------------------------------------------------------
   // Compile all functions in the module.
   //-------------------------------------------------------------------------
   {
     isolate->counters()->wasm_functions_per_module()->AddSample(
         static_cast<int>(functions.size()));
 
     std::vector<compiler::WasmCompilationUnit*> compilation_units(
         functions.size());
+    std::queue<compiler::WasmCompilationUnit*> executed_units;
+    std::vector<Handle<Code>> results(functions.size());
+
     if (FLAG_wasm_parallel_compilation) {
       // Create a placeholder code object for all functions.
       // TODO(ahaas): Maybe we could skip this for external functions.
       for (uint32_t i = 0; i < functions.size(); i++) {
         linker.GetFunctionCode(i);
       }
 
       for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size();
            i++) {
         if (!functions[i].external) {
           compilation_units[i] = compiler::CreateWasmCompilationUnit(
-              &thrower, isolate, &module_env, &functions[i]);
+              &thrower, isolate, &module_env, &functions[i], i);
         }
       }
 
-      for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size();
-           i++) {
-        if (!functions[i].external) {
-          compiler::ExecuteCompilation(compilation_units[i]);
+      index = FLAG_skip_compiling_wasm_funcs;
+      while (true) {
+        while (!executed_units.empty()) {
+          compiler::WasmCompilationUnit* unit = executed_units.front();
+          executed_units.pop();
+          int i = compiler::GetIndexOfWasmCompilationUnit(unit);
+          results[i] = compiler::FinishCompilation(unit);
+        }
+        if (index < functions.size()) {
+          if (!functions[index].external) {
+            compiler::ExecuteCompilation(compilation_units[index]);
+            executed_units.push(compilation_units[index]);
+            index++;
+          }
+        } else {
+          break;
         }
       }
     }
 
     // First pass: compile each function and initialize the code table.
     for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size();
          i++) {
       const WasmFunction& func = functions[i];
       if (thrower.error()) break;
       DCHECK_EQ(i, func.func_index);
 
       WasmName str = GetName(func.name_offset, func.name_length);
       WasmName str_null = {nullptr, 0};
       Handle<String> name = factory->InternalizeUtf8String(str);
       Handle<Code> code = Handle<Code>::null();
       Handle<JSFunction> function = Handle<JSFunction>::null();
       if (func.external) {
         // Lookup external function in FFI object.
         MaybeHandle<JSFunction> function =
             LookupFunction(thrower, factory, ffi, i, str, str_null);
         if (function.is_null()) return MaybeHandle<JSObject>();
         code = compiler::CompileWasmToJSWrapper(isolate, &module_env,
                                                 function.ToHandleChecked(),
                                                 func.sig, str, str_null);
       } else {
         if (FLAG_wasm_parallel_compilation) {
-          code = compiler::FinishCompilation(compilation_units[i]);
+          code = results[i];
         } else {
           // Compile the function.
           code = compiler::CompileWasmFunction(&thrower, isolate, &module_env,
                                                &func);
         }
         if (code.is_null()) {
           thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
                         str.start());
           return MaybeHandle<JSObject>();
         }
@@ skipping 232 matching lines @@
       wasm->GetInternalField(kWasmFunctionNamesArray), wasm->GetIsolate());
   if (func_names_arr_obj->IsUndefined())
     return func_names_arr_obj;  // Return undefined.
   return GetWasmFunctionNameFromTable(
       Handle<ByteArray>::cast(func_names_arr_obj), func_index);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8