Only turn on UMA WASM metric when synchronous.

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/asmjs/asm-js.h"
 #include "src/assembler-inl.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 54 matching lines @@
     base::OS::Free(memory,
                    RoundUp(kWasmMaxHeapOffset, base::OS::CommitPageSize()));
 
     data.GetIsolate()->AdjustAmountOfExternalAllocatedMemory(
         -buffer->byte_length()->Number());
   }
 
   GlobalHandles::Destroy(reinterpret_cast<Object**>(p));
 }
 
-static void RecordStats(Isolate* isolate, Code* code) {
-  isolate->counters()->wasm_generated_code_size()->Increment(code->body_size());
-  isolate->counters()->wasm_reloc_size()->Increment(
-      code->relocation_info()->length());
-}
-
-static void RecordStats(Isolate* isolate, Handle<FixedArray> functions) {
-  DisallowHeapAllocation no_gc;
-  for (int i = 0; i < functions->length(); ++i) {
-    RecordStats(isolate, Code::cast(functions->get(i)));
+static void RecordStats(Isolate* isolate, Code* code, bool is_sync) {
+  if (is_sync) {
+    // TODO(karlschimpf): Make this work when asynchronous.
+    // https://bugs.chromium.org/p/v8/issues/detail?id=6361
+    isolate->counters()->wasm_generated_code_size()->Increment(
+        code->body_size());
+    isolate->counters()->wasm_reloc_size()->Increment(
+        code->relocation_info()->length());
   }
 }
 
+static void RecordStats(Isolate* isolate, Handle<FixedArray> functions,
+                        bool is_sync) {
+  DisallowHeapAllocation no_gc;
+  for (int i = 0; i < functions->length(); ++i) {
+    RecordStats(isolate, Code::cast(functions->get(i)), is_sync);
+  }
+}
+
 void* TryAllocateBackingStore(Isolate* isolate, size_t size,
                               bool enable_guard_regions, bool& is_external) {
   is_external = false;
   // TODO(eholk): Right now enable_guard_regions has no effect on 32-bit
   // systems. It may be safer to fail instead, given that other code might do
   // things that would be unsafe if they expected guard pages where there
   // weren't any.
   if (enable_guard_regions && kGuardRegionsSupported) {
     // TODO(eholk): On Windows we want to make sure we don't commit the guard
     // pages yet.
@@ skipping 199 matching lines @@
          (FLAG_asm_wasm_lazy_compilation && module->is_asm_js());
 }
 
 // A helper for compiling an entire module.
 class CompilationHelper {
  public:
   // The compilation helper takes ownership of the {WasmModule}.
   // In {CompileToModuleObject}, it will transfer ownership to the generated
   // {WasmModuleWrapper}. If this method is not called, ownership may be
   // reclaimed by explicitely releasing the {module_} field.
-  CompilationHelper(Isolate* isolate, std::unique_ptr<WasmModule> module)
-      : isolate_(isolate), module_(std::move(module)) {}
+  CompilationHelper(Isolate* isolate, std::unique_ptr<WasmModule> module,
+                    bool is_sync)
+      : isolate_(isolate), module_(std::move(module)), is_sync_(is_sync) {}
 
   // The actual runnable task that performs compilations in the background.
   class CompilationTask : public CancelableTask {
    public:
     CompilationHelper* helper_;
     explicit CompilationTask(CompilationHelper* helper)
         : CancelableTask(helper->isolate_), helper_(helper) {}
 
     void RunInternal() override {
       while (helper_->FetchAndExecuteCompilationUnit()) {
       }
       helper_->module_->pending_tasks.get()->Signal();
     }
   };
 
   Isolate* isolate_;
   std::unique_ptr<WasmModule> module_;
+  bool is_sync_;
   std::vector<std::unique_ptr<compiler::WasmCompilationUnit>>
       compilation_units_;
   std::queue<std::unique_ptr<compiler::WasmCompilationUnit>> executed_units_;
   base::Mutex result_mutex_;
   base::AtomicNumber<size_t> next_unit_;
   size_t num_background_tasks_ = 0;
 
   // Run by each compilation task and by the main thread.
   bool FetchAndExecuteCompilationUnit() {
     DisallowHeapAllocation no_allocation;
@@ skipping 17 matching lines @@
 
   size_t InitializeParallelCompilation(
       const std::vector<WasmFunction>& functions, ModuleBytesEnv& module_env) {
     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];
+      constexpr bool is_sync = true;
       compilation_units_.push_back(
           std::unique_ptr<compiler::WasmCompilationUnit>(
-              new compiler::WasmCompilationUnit(isolate_, &module_env, func)));
+              new compiler::WasmCompilationUnit(isolate_, &module_env, func,
+                                                !is_sync)));
     }
     return funcs_to_compile;
   }
 
   void InitializeHandles() {
     for (auto& unit : compilation_units_) {
       unit->InitializeHandles();
     }
   }
 
@@ skipping 145 matching lines @@
         factory->NewFixedArray(function_table_count, TENURED);
     Handle<FixedArray> signature_tables =
         factory->NewFixedArray(function_table_count, TENURED);
     for (int i = 0; i < function_table_count; ++i) {
       temp_instance.function_tables[i] = factory->NewFixedArray(1, TENURED);
       temp_instance.signature_tables[i] = factory->NewFixedArray(1, TENURED);
       function_tables->set(i, *temp_instance.function_tables[i]);
       signature_tables->set(i, *temp_instance.signature_tables[i]);
     }
 
-    HistogramTimerScope wasm_compile_module_time_scope(
-        module_->is_wasm()
-            ? isolate_->counters()->wasm_compile_wasm_module_time()
-            : isolate_->counters()->wasm_compile_asm_module_time());
+    if (is_sync_) {
+      // TODO(karlschimpf): Make this work when asynchronous.
+      // https://bugs.chromium.org/p/v8/issues/detail?id=6361
+      HistogramTimerScope wasm_compile_module_time_scope(
+          module_->is_wasm()
+              ? isolate_->counters()->wasm_compile_wasm_module_time()
+              : isolate_->counters()->wasm_compile_asm_module_time());
+      return CompileToModuleObjectInternal(
+          thrower, wire_bytes, asm_js_script, asm_js_offset_table_bytes,
+          factory, &temp_instance, &function_tables, &signature_tables);
+    }
+    return CompileToModuleObjectInternal(
+        thrower, wire_bytes, asm_js_script, asm_js_offset_table_bytes, factory,
+        &temp_instance, &function_tables, &signature_tables);
+  }
 
-    ModuleBytesEnv module_env(module_.get(), &temp_instance, wire_bytes);
+ private:
+  MaybeHandle<WasmModuleObject> CompileToModuleObjectInternal(
+      ErrorThrower* thrower, const ModuleWireBytes& wire_bytes,
+      Handle<Script> asm_js_script,
+      Vector<const byte> asm_js_offset_table_bytes, Factory* factory,
+      WasmInstance* temp_instance, Handle<FixedArray>* function_tables,
+      Handle<FixedArray>* signature_tables) {
+    ModuleBytesEnv module_env(module_.get(), temp_instance, wire_bytes);
 
     // The {code_table} array contains import wrappers and functions (which
     // are both included in {functions.size()}, and export wrappers.
     int code_table_size = static_cast<int>(module_->functions.size() +
                                            module_->num_exported_functions);
     Handle<FixedArray> code_table =
         factory->NewFixedArray(static_cast<int>(code_table_size), TENURED);
 
     // Check whether lazy compilation is enabled for this module.
     bool lazy_compile = compile_lazy(module_.get());
 
     // If lazy compile: Initialize the code table with the lazy compile builtin.
     // Otherwise: Initialize with the illegal builtin. All call sites will be
     // patched at instantiation.
     Handle<Code> init_builtin = lazy_compile
                                     ? isolate_->builtins()->WasmCompileLazy()
                                     : isolate_->builtins()->Illegal();
     for (int i = 0, e = static_cast<int>(module_->functions.size()); i < e;
          ++i) {
       code_table->set(i, *init_builtin);
-      temp_instance.function_code[i] = init_builtin;
+      temp_instance->function_code[i] = init_builtin;
     }
 
-    (module_->is_wasm() ? isolate_->counters()->wasm_functions_per_wasm_module()
-                        : isolate_->counters()->wasm_functions_per_asm_module())
-        ->AddSample(static_cast<int>(module_->functions.size()));
+    if (is_sync_)
+      // TODO(karlschimpf): Make this work when asynchronous.
+      // https://bugs.chromium.org/p/v8/issues/detail?id=6361
+      (module_->is_wasm()
+           ? isolate_->counters()->wasm_functions_per_wasm_module()
+           : isolate_->counters()->wasm_functions_per_asm_module())
+          ->AddSample(static_cast<int>(module_->functions.size()));
 
     if (!lazy_compile) {
       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);
+        std::vector<Handle<Code>> results(temp_instance->function_code);
         CompileInParallel(&module_env, results, thrower);
-        temp_instance.function_code.swap(results);
+        temp_instance->function_code.swap(results);
       } else {
-        CompileSequentially(&module_env, temp_instance.function_code, thrower);
+        CompileSequentially(&module_env, temp_instance->function_code, thrower);
       }
       if (thrower->error()) return {};
     }
 
     // At this point, compilation has completed. Update the code table.
     for (size_t i = FLAG_skip_compiling_wasm_funcs;
-         i < temp_instance.function_code.size(); ++i) {
-      Code* code = *temp_instance.function_code[i];
+         i < temp_instance->function_code.size(); ++i) {
+      Code* code = *temp_instance->function_code[i];
       code_table->set(static_cast<int>(i), code);
-      RecordStats(isolate_, code);
+      RecordStats(isolate_, code, is_sync_);
     }
 
     // Create heap objects for script, module bytes and asm.js offset table to
     // be stored in the shared module data.
     Handle<Script> script;
     Handle<ByteArray> asm_js_offset_table;
     if (asm_js_script.is_null()) {
       script = CreateWasmScript(isolate_, wire_bytes);
     } else {
       script = asm_js_script;
@@ skipping 25 matching lines @@
     Handle<WasmSharedModuleData> shared = WasmSharedModuleData::New(
         isolate_, module_wrapper, Handle<SeqOneByteString>::cast(module_bytes),
         script, asm_js_offset_table);
     if (lazy_compile) WasmSharedModuleData::PrepareForLazyCompilation(shared);
 
     // Create the compiled module object, and populate with compiled functions
     // and information needed at instantiation time. This object needs to be
     // serializable. Instantiation may occur off a deserialized version of this
     // object.
     Handle<WasmCompiledModule> compiled_module = WasmCompiledModule::New(
-        isolate_, shared, code_table, function_tables, signature_tables);
+        isolate_, shared, code_table, *function_tables, *signature_tables);
 
     // If we created a wasm script, finish it now and make it public to the
     // debugger.
     if (asm_js_script.is_null()) {
       script->set_wasm_compiled_module(*compiled_module);
       isolate_->debug()->OnAfterCompile(script);
     }
 
     // Compile JS->WASM wrappers for exported functions.
     JSToWasmWrapperCache js_to_wasm_cache;
     int func_index = 0;
     for (auto exp : module->export_table) {
       if (exp.kind != kExternalFunction) continue;
       Handle<Code> wasm_code = EnsureExportedLazyDeoptData(
           isolate_, Handle<WasmInstanceObject>::null(), code_table, exp.index);
       Handle<Code> wrapper_code =
           js_to_wasm_cache.CloneOrCompileJSToWasmWrapper(isolate_, module,
                                                          wasm_code, exp.index);
       int export_index =
           static_cast<int>(module->functions.size() + func_index);
       code_table->set(export_index, *wrapper_code);
-      RecordStats(isolate_, *wrapper_code);
+      RecordStats(isolate_, *wrapper_code, is_sync_);
       func_index++;
     }
 
     return WasmModuleObject::New(isolate_, compiled_module);
   }
 };
 
 static void MemoryInstanceFinalizer(Isolate* isolate,
                                     WasmInstanceObject* instance) {
   DisallowHeapAllocation no_gc;
@@ skipping 469 matching lines @@
             case Code::JS_TO_WASM_FUNCTION:
             case Code::WASM_FUNCTION: {
               Handle<Code> code = factory->CopyCode(orig_code);
               code_table->set(i, *code);
               break;
             }
             default:
               UNREACHABLE();
           }
         }
-        RecordStats(isolate_, code_table);
+        RecordStats(isolate_, code_table, is_sync_);
       } else {
         // There was no owner, so we can reuse the original.
         compiled_module_ = original;
         old_code_table =
             factory->CopyFixedArray(compiled_module_->code_table());
         code_table = compiled_module_->code_table();
         TRACE("Reusing existing instance %d\n",
               compiled_module_->instance_id());
       }
       compiled_module_->set_native_context(isolate_->native_context());
@@ skipping 256 matching lines @@
       int start_index = module_->start_function_index;
       Handle<Code> startup_code = EnsureExportedLazyDeoptData(
           isolate_, instance, code_table, start_index);
       FunctionSig* sig = module_->functions[start_index].sig;
       Handle<Code> wrapper_code =
           js_to_wasm_cache_.CloneOrCompileJSToWasmWrapper(
               isolate_, module_, startup_code, start_index);
       Handle<WasmExportedFunction> startup_fct = WasmExportedFunction::New(
           isolate_, instance, MaybeHandle<String>(), start_index,
           static_cast<int>(sig->parameter_count()), wrapper_code);
-      RecordStats(isolate_, *startup_code);
+      RecordStats(isolate_, *startup_code, is_sync_);
       // Call the JS function.
       Handle<Object> undefined = factory->undefined_value();
       MaybeHandle<Object> retval =
           Execution::Call(isolate_, startup_fct, undefined, 0, nullptr);
 
       if (retval.is_null()) {
         DCHECK(isolate_->has_pending_exception());
         isolate_->OptionalRescheduleException(false);
         // It's unfortunate that the new instance is already linked in the
         // chain. However, we need to set up everything before executing the
@@ skipping 13 matching lines @@
   // Represents the initialized state of a table.
   struct TableInstance {
     Handle<WasmTableObject> table_object;    // WebAssembly.Table instance
     Handle<FixedArray> js_wrappers;          // JSFunctions exported
     Handle<FixedArray> function_table;       // internal code array
     Handle<FixedArray> signature_table;      // internal sig array
   };
 
   Isolate* isolate_;
   WasmModule* const module_;
+  constexpr static bool is_sync_ = true;
   ErrorThrower* thrower_;
   Handle<WasmModuleObject> module_object_;
   Handle<JSReceiver> ffi_;        // TODO(titzer): Use MaybeHandle
   Handle<JSArrayBuffer> memory_;  // TODO(titzer): Use MaybeHandle
   Handle<JSArrayBuffer> globals_;
   Handle<WasmCompiledModule> compiled_module_;
   std::vector<TableInstance> table_instances_;
   std::vector<Handle<JSFunction>> js_wrappers_;
   JSToWasmWrapperCache js_to_wasm_cache_;
 
@@ skipping 151 matching lines @@
               isolate_, index, module_->functions[import.index].sig,
               Handle<JSReceiver>::cast(value), module_name, import_name,
               module_->get_origin());
           if (import_wrapper.is_null()) {
             ReportLinkError(
                 "imported function does not match the expected type", index,
                 module_name, import_name);
             return -1;
           }
           code_table->set(num_imported_functions, *import_wrapper);
-          RecordStats(isolate_, *import_wrapper);
+          RecordStats(isolate_, *import_wrapper, is_sync_);
           num_imported_functions++;
           break;
         }
         case kExternalTable: {
           if (!WasmJs::IsWasmTableObject(isolate_, value)) {
             ReportLinkError("table import requires a WebAssembly.Table", index,
                             module_name, import_name);
             return -1;
           }
           WasmIndirectFunctionTable& table =
@@ skipping 850 matching lines @@
 
   ModuleResult result = DecodeWasmModule(isolate, bytes.start(), bytes.end(),
                                          false, kAsmJsOrigin);
   if (result.failed()) {
     thrower->CompileFailed("Wasm decoding failed", result);
     return {};
   }
 
   // Transfer ownership to the {WasmModuleWrapper} generated in
   // {CompileToModuleObject}.
-  CompilationHelper helper(isolate, std::move(result.val));
+  constexpr bool is_sync = true;
+  CompilationHelper helper(isolate, std::move(result.val), is_sync);
   return helper.CompileToModuleObject(thrower, bytes, asm_js_script,
                                       asm_js_offset_table_bytes);
 }
 
 MaybeHandle<WasmModuleObject> wasm::SyncCompile(Isolate* isolate,
                                                 ErrorThrower* thrower,
                                                 const ModuleWireBytes& bytes) {
   if (!IsWasmCodegenAllowed(isolate, isolate->native_context())) {
     thrower->CompileError("Wasm code generation disallowed in this context");
     return {};
   }
 
   ModuleResult result =
       DecodeWasmModule(isolate, bytes.start(), bytes.end(), false, kWasmOrigin);
   if (result.failed()) {
     thrower->CompileFailed("Wasm decoding failed", result);
     return {};
   }
 
   // Transfer ownership to the {WasmModuleWrapper} generated in
   // {CompileToModuleObject}.
-  CompilationHelper helper(isolate, std::move(result.val));
+  constexpr bool is_sync = true;
+  CompilationHelper helper(isolate, std::move(result.val), is_sync);
   return helper.CompileToModuleObject(thrower, bytes, Handle<Script>(),
                                       Vector<const byte>());
 }
 
 MaybeHandle<WasmInstanceObject> wasm::SyncInstantiate(
     Isolate* isolate, ErrorThrower* thrower,
     Handle<WasmModuleObject> module_object, MaybeHandle<JSReceiver> imports,
     MaybeHandle<JSArrayBuffer> memory) {
   InstantiationHelper helper(isolate, thrower, module_object, imports, memory);
   return helper.Build();
@@ skipping 163 matching lines @@
   // Step 1: (async) Decode the module.
   //==========================================================================
   class DecodeModule : public CompileTask<ASYNC> {
     void Run() override {
       ModuleResult result;
       {
         DisallowHandleAllocation no_handle;
         DisallowHeapAllocation no_allocation;
         // Decode the module bytes.
         TRACE_COMPILE("(1) Decoding module...\n");
+        constexpr bool is_sync = true;
         result = DecodeWasmModule(job_->isolate_, job_->wire_bytes_.start(),
-                                  job_->wire_bytes_.end(), false, kWasmOrigin);
+                                  job_->wire_bytes_.end(), false, kWasmOrigin,
+                                  !is_sync);
       }
       if (result.failed()) {
         // Decoding failure; reject the promise and clean up.
         job_->DoSync<DecodeFail>(std::move(result));
       } else {
         // Decode passed.
         job_->DoSync<PrepareAndStartCompile>(std::move(result.val));
       }
     }
   };
@@ skipping 72 matching lines @@
         job_->code_table_->set(static_cast<int>(i), *illegal_builtin);
         job_->temp_instance_->function_code[i] = illegal_builtin;
       }
 
       job_->isolate_->counters()->wasm_functions_per_wasm_module()->AddSample(
           static_cast<int>(module_->functions.size()));
 
       // Transfer ownership of the {WasmModule} to the {CompilationHelper}, but
       // keep a pointer.
       WasmModule* module = module_.get();
+      constexpr bool is_sync = true;
       job_->helper_.reset(
-          new CompilationHelper(job_->isolate_, std::move(module_)));
+          new CompilationHelper(job_->isolate_, std::move(module_), !is_sync));
 
       DCHECK_LE(module->num_imported_functions, module->functions.size());
       size_t num_functions =
           module->functions.size() - module->num_imported_functions;
       if (num_functions == 0) {
         job_->ReopenHandlesInDeferredScope();
         // Degenerate case of an empty module.
         job_->DoSync<FinishCompile>();
         return;
       }
@@ skipping 120 matching lines @@
   };
 
   //==========================================================================
   // Step 5b (sync): Finish heap-allocated data structures.
   //==========================================================================
   class FinishCompile : public SyncCompileTask {
     void RunImpl() override {
       TRACE_COMPILE("(5b) Finish compile...\n");
       HandleScope scope(job_->isolate_);
       // At this point, compilation has completed. Update the code table.
+      constexpr bool is_sync = true;
       for (size_t i = FLAG_skip_compiling_wasm_funcs;
            i < job_->temp_instance_->function_code.size(); ++i) {
         Code* code = Code::cast(job_->code_table_->get(static_cast<int>(i)));
-        RecordStats(job_->isolate_, code);
+        RecordStats(job_->isolate_, code, !is_sync);
       }
 
       // Create heap objects for script and module bytes to be stored in the
       // shared module data. Asm.js is not compiled asynchronously.
       Handle<Script> script =
           CreateWasmScript(job_->isolate_, job_->wire_bytes_);
       Handle<ByteArray> asm_js_offset_table;
       // TODO(wasm): Improve efficiency of storing module wire bytes.
       //   1. Only store relevant sections, not function bodies
       //   2. Don't make a second copy of the bytes here; reuse the copy made
@@ skipping 45 matching lines @@
   //==========================================================================
   // Step 6 (sync): Compile JS->WASM wrappers.
   //==========================================================================
   class CompileWrappers : public SyncCompileTask {
     void RunImpl() override {
       TRACE_COMPILE("(6) Compile wrappers...\n");
       // Compile JS->WASM wrappers for exported functions.
       HandleScope scope(job_->isolate_);
       JSToWasmWrapperCache js_to_wasm_cache;
       int func_index = 0;
+      constexpr bool is_sync = true;
       WasmModule* module = job_->compiled_module_->module();
       for (auto exp : module->export_table) {
         if (exp.kind != kExternalFunction) continue;
         Handle<Code> wasm_code(Code::cast(job_->code_table_->get(exp.index)),
                                job_->isolate_);
         Handle<Code> wrapper_code =
             js_to_wasm_cache.CloneOrCompileJSToWasmWrapper(
                 job_->isolate_, module, wasm_code, exp.index);
         int export_index =
             static_cast<int>(module->functions.size() + func_index);
         job_->code_table_->set(export_index, *wrapper_code);
-        RecordStats(job_->isolate_, *wrapper_code);
+        RecordStats(job_->isolate_, *wrapper_code, !is_sync);
         func_index++;
       }
 
       job_->DoSync<FinishModule>();
     }
   };
 
   //==========================================================================
   // Step 7 (sync): Finish the module and resolve the promise.
   //==========================================================================
@@ skipping 286 matching lines @@
                                      callee_compiled->instruction_start());
     }
     DCHECK_EQ(non_compiled_functions.size(), idx);
   }
 
   Code* ret =
       Code::cast(compiled_module->code_table()->get(func_to_return_idx));
   DCHECK_EQ(Code::WASM_FUNCTION, ret->kind());
   return handle(ret, isolate);
 }