[wasm] Minor optimization 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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 228 matching lines @@
     DisallowHandleDereference no_deref;
     DisallowCodeDependencyChange no_dependency_change;
 
     // - 1 because AtomicIncrement returns the value after the atomic increment.
     size_t index = next_unit_.Increment(1) - 1;
     if (index >= compilation_units_.size()) {
       return false;
     }
 
     compiler::WasmCompilationUnit* unit = compilation_units_.at(index);
-    if (unit != nullptr) {
-      unit->ExecuteCompilation();
-      base::LockGuard<base::Mutex> guard(&result_mutex_);
-      executed_units_.push(unit);
-    }
+    unit->ExecuteCompilation();
+    base::LockGuard<base::Mutex> guard(&result_mutex_);
+    executed_units_.push(unit);
     return true;
   }
 
   void InitializeParallelCompilation(const std::vector<WasmFunction>& functions,
                                      ModuleBytesEnv& module_env,
                                      ErrorThrower* thrower) {
-    compilation_units_.reserve(functions.size());
-    for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size();
-         ++i) {
+    uint32_t start = module_env.module_env.module->num_imported_functions +
+                     FLAG_skip_compiling_wasm_funcs;
+    uint32_t num_funcs = static_cast<uint32_t>(functions.size());
+    uint32_t funcs_to_compile = start > num_funcs ? 0 : num_funcs - start;
+    compilation_units_.reserve(funcs_to_compile);
+    for (uint32_t i = start; i < num_funcs; ++i) {
       const WasmFunction* func = &functions[i];
-      compilation_units_.push_back(
-          func->imported ? nullptr
-                         : new compiler::WasmCompilationUnit(
-                               thrower, isolate_, &module_env, func, i));
+      compilation_units_.push_back(new compiler::WasmCompilationUnit(
+          thrower, isolate_, &module_env, func, i));
     }
   }
 
   uint32_t* StartCompilationTasks() {
     const size_t num_tasks =
         Min(static_cast<size_t>(FLAG_wasm_num_compilation_tasks),
             V8::GetCurrentPlatform()->NumberOfAvailableBackgroundThreads());
     uint32_t* task_ids = new uint32_t[num_tasks];
     for (size_t i = 0; i < num_tasks; ++i) {
       CompilationTask* task = new CompilationTask(this);
@@ skipping 164 matching lines @@
     // patched at instantiation.
     Handle<Code> illegal_builtin = isolate_->builtins()->Illegal();
     for (uint32_t i = 0; i < module_->functions.size(); ++i) {
       code_table->set(static_cast<int>(i), *illegal_builtin);
       temp_instance.function_code[i] = illegal_builtin;
     }
 
     isolate_->counters()->wasm_functions_per_module()->AddSample(
         static_cast<int>(module_->functions.size()));
     CompilationHelper helper(isolate_, module_);
-    if (!FLAG_trace_wasm_decoder && FLAG_wasm_num_compilation_tasks != 0) {
+    size_t funcs_to_compile =
+        module_->functions.size() - module_->num_imported_functions;
+    if (!FLAG_trace_wasm_decoder && FLAG_wasm_num_compilation_tasks != 0 &&
+        funcs_to_compile > 1) {
       // Avoid a race condition by collecting results into a second vector.
       std::vector<Handle<Code>> results(temp_instance.function_code);
       helper.CompileInParallel(&module_env, results, thrower);
       temp_instance.function_code.swap(results);
     } else {
       helper.CompileSequentially(&module_env, temp_instance.function_code,
                                  thrower);
     }
     if (thrower->error()) return {};
 
@@ skipping 2245 matching lines @@
   Handle<String> module_property_name =
       isolate->factory()->InternalizeUtf8String("module");
   Handle<String> instance_property_name =
       isolate->factory()->InternalizeUtf8String("instance");
   JSObject::AddProperty(ret, module_property_name, module, NONE);
   JSObject::AddProperty(ret, instance_property_name,
                         instance_object.ToHandleChecked(), NONE);
 
   ResolvePromise(isolate, promise, ret);
 }