[wasm] separate snapshot-able stages

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/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 401 matching lines @@
       index++;
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower& thrower) {
-  // Create a placeholder code object for all functions.
-  // TODO(ahaas): Maybe we could skip this for external functions.

[titzer, 2016/05/26 15:12:25]

Why did you delete this code? It's necessary to create the placeholder objects
before beginning parallel compilation.

[Mircea Trofin, 2016/05/26 15:53:18]

The CL has the refactoring one as a dependency. There, I moved this in a
separate initialization call, just that
I forgot to delete it from here.

-  for (uint32_t i = 0; i < functions.size(); i++) {
-    module_env.linker->GetFunctionCode(i);
-  }
-
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); i++) {
     compilation_units[i] = new compiler::WasmCompilationUnit(
         &thrower, isolate, &module_env, &functions[i], i);
   }
 }
 
 uint32_t* StartCompilationTasks(
     Isolate* isolate,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     std::queue<compiler::WasmCompilationUnit*>& executed_units,
@@ skipping 41 matching lines @@
       }
       unit = executed_units.front();
       executed_units.pop();
     }
     int j = unit->index();
     results[j] = unit->FinishCompilation();
     delete unit;
   }
 }
 
-bool FinishCompilation(Isolate* isolate, const WasmModule* module,
-                       const Handle<JSReceiver> ffi,
-                       const std::vector<Handle<Code>>& results,
-                       const WasmModuleInstance& instance,
-                       const Handle<FixedArray>& code_table,
-                       ErrorThrower& thrower, Factory* factory,
-                       ModuleEnv& module_env, CodeStats& code_stats,
-                       PropertyDescriptor& desc) {
-  if (thrower.error()) return false;
+void CompileSequentially(Isolate* isolate, WasmModuleInstance* instance,

[titzer, 2016/05/26 15:12:25]

I like the old name better.

[Mircea Trofin, 2016/05/26 15:53:18]

It doesn't finish anything anymore now. It does the whole compilation,
sequentially.

Before, this member did 2 things:
- compile everything sequentially if we didn't enable parallel compilation
- record the sizes of whatever was compiled, regardless how that happened.

It now has one responsibility: compile sequentially. We record sizes separately.

+                         ErrorThrower* thrower, ModuleEnv* module_env) {
+  DCHECK(!thrower->error());
+  const WasmModule* module = instance->module();
+
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs;
        i < module->functions.size(); i++) {
     const WasmFunction& func = module->functions[i];
 
     DCHECK_EQ(i, func.func_index);
     WasmName str = module->GetName(func.name_offset, func.name_length);
     Handle<Code> code = Handle<Code>::null();
-    if (FLAG_wasm_num_compilation_tasks != 0) {

[titzer, 2016/05/26 15:12:25]

wat

[Mircea Trofin, 2016/05/26 15:53:17]

Typo?

-      code = results[i];
-    } else {
-      // Compile the function.
-      code = compiler::WasmCompilationUnit::CompileWasmFunction(
-          &thrower, isolate, &module_env, &func);
+    // Compile the function.
+    code = compiler::WasmCompilationUnit::CompileWasmFunction(
+        thrower, isolate, module_env, &func);
+    if (code.is_null()) {
+      thrower->Error("Compilation of #%d:%.*s failed.", i, str.length(),
+                     str.start());
+      break;
     }
-    if (code.is_null()) {
-      thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
-                    str.start());
-      return false;
-    }
-    if (!code.is_null()) {
       // Install the code into the linker table.
-      module_env.linker->Finish(i, code);
-      code_table->set(i, *code);
-      code_stats.Record(*code);
-    }
+    instance->function_code()[i] = code;
   }
-  return true;
 }
 }  // namespace
 
 void WasmModuleInstance::LoadDataSegments() {
   for (const WasmDataSegment& segment : module()->data_segments) {
     if (!segment.init) continue;
     if (!segment.source_size) continue;
     CHECK_LT(segment.dest_addr, mem_size());
     CHECK_LE(segment.source_size, mem_size());
     CHECK_LE(segment.dest_addr + segment.source_size, mem_size());
@@ skipping 79 matching lines @@
     CodeDesc desc = {buffer, 8, 8, 0, 0, nullptr};
     Handle<Code> code = isolate_->factory()->NewCode(
         desc, Code::KindField::encode(Code::WASM_FUNCTION),
         Handle<Object>::null());
     code->set_constant_pool_offset(static_cast<int>(index) +
                                    kPlaceholderMarker);
     function_code()[index] = code;
   }
 }
 
+void WasmModuleInstance::ProcessFunctionsPostLinking() {

[titzer, 2016/05/26 15:12:25]

Please name this function for what it does. SetDeoptimizationData(), e.g.

[Mircea Trofin, 2016/05/26 15:53:18]

Agreed.

[Mircea Trofin, 2016/05/27 01:17:33]

Actually... Perhaps SetStackTracingHelpers may be better? Because that's what
we're trying to 
achieve (if I remember correctly). The fact that we use deopt for that is the
implementation detail of what we're trying to achieve.

+  for (size_t i = FLAG_skip_compiling_wasm_funcs; i < function_code().size();
+       ++i) {
+    Handle<Code> code = function_code()[i];
+    DCHECK(code->deoptimization_data() == nullptr ||
+           code->deoptimization_data()->length() == 0);
+    Handle<FixedArray> deopt_data =
+        isolate_->factory()->NewFixedArray(2, TENURED);
+    if (!js_object().is_null()) {
+      deopt_data->set(0, *js_object());
+    }
+    deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
+    deopt_data->set_length(2);
+    code->set_deoptimization_data(*deopt_data);
+  }
+}
+
 // Instantiates a wasm module as a JSObject.
 //  * allocates a backing store of {mem_size} bytes.
 //  * installs a named property "memory" for that buffer if exported
 //  * installs named properties on the object for exported functions
 //  * compiles wasm code to machine code
 MaybeHandle<JSObject> WasmModule::Instantiate(
     Isolate* isolate, Handle<JSReceiver> ffi,
     Handle<JSArrayBuffer> memory) const {
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
-  PropertyDescriptor desc;
-  desc.set_writable(false);
-
   // If FLAG_print_wasm_code_size is set, this aggregates the sum of all code
   // objects created for this module.
   // TODO(titzer): switch this to TRACE_EVENT
   CodeStats code_stats;
 
   //-------------------------------------------------------------------------
   // Allocate the instance and its JS counterpart.
   //-------------------------------------------------------------------------
   WasmModuleInstance instance(this, isolate);
   instance.set_native_context(isolate->native_context());
@@ skipping 45 matching lines @@
   // Compile all functions in the module.
   //-------------------------------------------------------------------------
   {
     isolate->counters()->wasm_functions_per_module()->AddSample(
         static_cast<int>(functions.size()));
 
     // Data structures for the parallel compilation.
     std::vector<compiler::WasmCompilationUnit*> compilation_units(
         functions.size());
     std::queue<compiler::WasmCompilationUnit*> executed_units;
-    std::vector<Handle<Code>> results(functions.size());
 
     if (FLAG_wasm_num_compilation_tasks != 0) {
       //-----------------------------------------------------------------------
       // For parallel compilation:
       // 1) The main thread allocates a compilation unit for each wasm function
       //    and stores them in the vector {compilation_units}.
       // 2) The main thread spawns {WasmCompilationTask} instances which run on
       //    the background threads.
       // 3.a) The background threads and the main thread pick one compilation
       //      unit at a time and execute the parallel phase of the compilation
@@ skipping 30 matching lines @@
       //      unit at a time and execute the parallel phase of the compilation
       //      unit. After finishing the execution of the parallel phase, the
       //      result is enqueued in {executed_units}.
       while (FetchAndExecuteCompilationUnit(isolate, &compilation_units,
                                             &executed_units, &result_mutex,
                                             &next_unit)) {
         // 3.b) If {executed_units} contains a compilation unit, the main thread
         //      dequeues it and finishes the compilation unit. Compilation units
         //      are finished concurrently to the background threads to save
         //      memory.
-        FinishCompilationUnits(executed_units, results, result_mutex);
+        FinishCompilationUnits(executed_units, instance.function_code(),
+                               result_mutex);
       }
       // 4) After the parallel phase of all compilation units has started, the
       //    main thread waits for all {WasmCompilationTask} instances to finish.
       WaitForCompilationTasks(isolate, task_ids.get(), pending_tasks);
       // Finish the compilation of the remaining compilation units.
-      FinishCompilationUnits(executed_units, results, result_mutex);
+      FinishCompilationUnits(executed_units, instance.function_code(),
+                             result_mutex);
+    } else {
+      // 5) The main thread finishes the compilation.
+      CompileSequentially(isolate, &instance, &thrower, &module_env);
     }
-    // 5) The main thread finishes the compilation.
-    if (!FinishCompilation(isolate, this, ffi, results, instance, code_table,
-                           thrower, factory, module_env, code_stats, desc)) {
+    if (thrower.error()) {
       return Handle<JSObject>::null();
     }
 
+    // At this point, compilation has completed. Update the code table
+    // and record sizes.
+    for (size_t i = FLAG_skip_compiling_wasm_funcs;
+         i < instance.function_code().size(); ++i) {
+      Code* code = *instance.function_code()[i];
+      code_table->set(static_cast<int>(i), code);
+      code_stats.Record(code);
+    }
+
     // Patch all direct call sites.
     linker.Link(instance.function_table(), this->function_table);
     instance.js_object()->SetInternalField(kWasmModuleFunctionTable,
                                            Smi::FromInt(0));
 
+    instance.ProcessFunctionsPostLinking();
+
     //-------------------------------------------------------------------------
     // Create and populate the exports object.
     //-------------------------------------------------------------------------
     if (export_table.size() > 0 || mem_export) {
       Handle<JSObject> exports_object;
       if (origin == kWasmOrigin) {
         // Create the "exports" object.
         Handle<JSFunction> object_function = Handle<JSFunction>(
             isolate->native_context()->object_function(), isolate);
         exports_object = factory->NewJSObject(object_function, TENURED);
         Handle<String> exports_name = factory->InternalizeUtf8String("exports");
         JSObject::AddProperty(instance.js_object(), exports_name,
                               exports_object, READ_ONLY);
       } else {
         // Just export the functions directly on the object returned.
         exports_object = instance.js_object();
       }
 
+      PropertyDescriptor desc;
+      desc.set_writable(false);
+
       // Compile wrappers and add them to the exports object.
       for (const WasmExport& exp : export_table) {
         if (thrower.error()) break;
         WasmName str = GetName(exp.name_offset, exp.name_length);
         Handle<String> name = factory->InternalizeUtf8String(str);
         Handle<Code> code = linker.GetFunctionCode(exp.func_index);
         Handle<JSFunction> function = compiler::CompileJSToWasmWrapper(
             isolate, &module_env, name, code, instance.js_object(),
             exp.func_index);
         code_stats.Record(function->code());
@@ skipping 166 matching lines @@
                                         uint32_t func_index) {
   Object* func_names_arr_obj = wasm->GetInternalField(kWasmFunctionNamesArray);
   if (func_names_arr_obj->IsUndefined()) return Handle<String>::null();
   return GetWasmFunctionNameFromTable(
       handle(ByteArray::cast(func_names_arr_obj)), func_index);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8