Fix use of history timers in background threads.

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 3890 matching lines @@
   DCHECK(name_len > 0 && name_len < name_vector.length());
 
   char* index_name = zone->NewArray<char>(name_len);
   memcpy(index_name, name_vector.start(), name_len);
   return Vector<const char>(index_name, name_len);
 }
 }  // namespace
 
 WasmCompilationUnit::WasmCompilationUnit(Isolate* isolate,
                                          wasm::ModuleBytesEnv* module_env,
-                                         const wasm::WasmFunction* function,
-                                         bool is_sync)
+                                         const wasm::WasmFunction* function)
     : WasmCompilationUnit(
           isolate, &module_env->module_env,
           wasm::FunctionBody{
               function->sig, module_env->wire_bytes.start(),
               module_env->wire_bytes.start() + function->code_start_offset,
               module_env->wire_bytes.start() + function->code_end_offset},
-          module_env->wire_bytes.GetNameOrNull(function), function->func_index,
-          is_sync) {}
+          module_env->wire_bytes.GetNameOrNull(function),
+          function->func_index) {}
 
 WasmCompilationUnit::WasmCompilationUnit(Isolate* isolate,
                                          wasm::ModuleEnv* module_env,
                                          wasm::FunctionBody body,
-                                         wasm::WasmName name, int index,
-                                         bool is_sync)
+                                         wasm::WasmName name, int index)
     : isolate_(isolate),
       module_env_(module_env),
       func_body_(body),
       func_name_(name),
-      is_sync_(is_sync),
       graph_zone_(new Zone(isolate->allocator(), ZONE_NAME)),
       jsgraph_(new (graph_zone()) JSGraph(
           isolate, new (graph_zone()) Graph(graph_zone()),
           new (graph_zone()) CommonOperatorBuilder(graph_zone()), nullptr,
           nullptr,
           new (graph_zone()) MachineOperatorBuilder(
               graph_zone(), MachineType::PointerRepresentation(),
               InstructionSelector::SupportedMachineOperatorFlags(),
               InstructionSelector::AlignmentRequirements()))),
       compilation_zone_(isolate->allocator(), ZONE_NAME),
       info_(GetDebugName(&compilation_zone_, name, index), isolate,
             &compilation_zone_, Code::ComputeFlags(Code::WASM_FUNCTION)),
       func_index_(index),
       protected_instructions_(&compilation_zone_) {}
 
 void WasmCompilationUnit::InitializeHandles() {
   // Create and cache this node in the main thread, which contains a handle to
   // the code object of the c-entry stub.
   jsgraph_->CEntryStubConstant(1);
   DCHECK(!handles_initialized_);
 #if DEBUG
   handles_initialized_ = true;
 #endif  // DEBUG
 }
 
 void WasmCompilationUnit::ExecuteCompilation() {
   DCHECK(handles_initialized_);
-  if (is_sync_) {
-    // TODO(karlschimpf): Make this work when asynchronous.
-    // https://bugs.chromium.org/p/v8/issues/detail?id=6361
-    HistogramTimerScope wasm_compile_function_time_scope(
-        isolate_->counters()->wasm_compile_function_time());
-    ExecuteCompilationInternal();
-    return;
-  }
-  ExecuteCompilationInternal();
-}
-
-void WasmCompilationUnit::ExecuteCompilationInternal() {
+  HistogramTimerScope wasm_compile_function_time_scope(
+      isolate_->counters()->wasm_compile_function_time());

[jochen (gone - plz use gerrit), 2017/06/12 09:18:34]

no isolate_ deref on background threads

[kschimpf, 2017/06/12 16:47:04]

It turns out that this step is not run in the background. Hence, this is safe.

   if (FLAG_trace_wasm_compiler) {
     if (func_name_.start() != nullptr) {
       PrintF("Compiling wasm function %d:'%.*s'\n\n", func_index(),
              func_name_.length(), func_name_.start());
     } else {
       PrintF("Compiling wasm function %d:<unnamed>\n\n", func_index());
     }
   }
 
   double decode_ms = 0;
@@ skipping 18 matching lines @@
       &compilation_zone_, func_body_.sig);
   if (jsgraph_->machine()->Is32()) {
     descriptor =
         module_env_->GetI32WasmCallDescriptor(&compilation_zone_, descriptor);
   }
   job_.reset(Pipeline::NewWasmCompilationJob(
       &info_, jsgraph_, descriptor, source_positions, &protected_instructions_,
       !module_env_->module->is_wasm()));
   ok_ = job_->ExecuteJob() == CompilationJob::SUCCEEDED;
   // TODO(bradnelson): Improve histogram handling of size_t.
-  if (is_sync_)
-    // TODO(karlschimpf): Make this work when asynchronous.
-    // https://bugs.chromium.org/p/v8/issues/detail?id=6361
-    isolate_->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
-        static_cast<int>(jsgraph_->graph()->zone()->allocation_size()));
+  isolate_->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
+      static_cast<int>(jsgraph_->graph()->zone()->allocation_size()));
 
   if (FLAG_trace_wasm_decode_time) {
     double pipeline_ms = pipeline_timer.Elapsed().InMillisecondsF();
     PrintF(
         "wasm-compilation phase 1 ok: %u bytes, %0.3f ms decode, %zu nodes, "
         "%0.3f ms pipeline\n",
         static_cast<unsigned>(func_body_.end - func_body_.start), decode_ms,
         node_count, pipeline_ms);
   }
 }
@@ skipping 49 matching lines @@
     wasm::ModuleBytesEnv* module_env, const wasm::WasmFunction* function) {
   WasmCompilationUnit unit(isolate, module_env, function);
   unit.InitializeHandles();
   unit.ExecuteCompilation();
   return unit.FinishCompilation(thrower);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8