Fix use of history timers in background threads.

src/wasm/module-compiler.h

 // Copyright 2017 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.
 
 #ifndef V8_WASM_MODULE_COMPILER_H_
 #define V8_WASM_MODULE_COMPILER_H_
 
 #include <functional>
 
 #include "src/base/atomic-utils.h"
@@ skipping 51 matching lines @@
 
     base::RandomNumberGenerator* random_number_generator_ = nullptr;
     std::vector<std::unique_ptr<compiler::WasmCompilationUnit>> schedule_;
     const size_t max_memory_;
     bool throttle_ = false;
     base::AtomicNumber<size_t> allocated_memory_{0};
   };
 
   Isolate* isolate_;
   std::unique_ptr<WasmModule> module_;
-  std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
+  const std::shared_ptr<Counters> counters_shared_;
   bool is_sync_;
   std::vector<std::unique_ptr<compiler::WasmCompilationUnit>>
       compilation_units_;
   CodeGenerationSchedule executed_units_;
   base::Mutex result_mutex_;
   base::AtomicNumber<size_t> next_unit_;
   const size_t num_background_tasks_;
   // This flag should only be set while holding result_mutex_.
   bool finisher_is_running_ = false;
   CancelableTaskManager background_task_manager_;
 
+  Counters* counters() const { return counters_shared_.get(); }

[Mircea Trofin, 2017/06/22 18:42:24]

for consistency, should this have the "shared" word in it? Either that, or we
can drop the "shared" from the field.

[kschimpf, 2017/06/22 20:38:31]

This is an artifact that we used to have both fields "counters_" and
"counters_shared_".

Fixing.

+
   // Run by each compilation task and by the main thread. The
   // no_finisher_callback is called within the result_mutex_ lock when no
   // finishing task is running, i.e. when the finisher_is_running_ flag is not
   // set.
   bool FetchAndExecuteCompilationUnit(
       std::function<void()> no_finisher_callback = [] {});
 
   void CompileAndSchedule(size_t index);
   bool GetNextUncompiledFunctionId(size_t* index);
   void OnBackgroundTaskStopped();
@@ skipping 76 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_;
-  std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
+  const std::shared_ptr<Counters> counters_shared_;
   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_;
   WeakCallbackInfo<void>::Callback instance_finalizer_callback_;
 
+  Counters* counters() const { return counters_shared_.get(); }
+
 // Helper routines to print out errors with imports.
 #define ERROR_THROWER_WITH_MESSAGE(TYPE)                                      \
   void Report##TYPE(const char* error, uint32_t index,                        \
                     Handle<String> module_name, Handle<String> import_name) { \
     thrower_->TYPE("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",  \
                    index, module_name->length(),                              \
                    module_name->ToCString().get(), import_name->length(),     \
                    import_name->ToCString().get(), error);                    \
   }                                                                           \
                                                                               \
@@ skipping 85 matching lines @@
   class DecodeFail;
   class PrepareAndStartCompile;
   class ExecuteAndFinishCompilationUnits;
   class WaitForBackgroundTasks;
   class FinishCompilationUnits;
   class FinishCompile;
   class CompileWrappers;
   class FinishModule;
 
   Isolate* isolate_;
-  std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
+  const std::shared_ptr<Counters> counters_shared_;
   std::unique_ptr<byte[]> bytes_copy_;
   ModuleWireBytes wire_bytes_;
   Handle<Context> context_;
   Handle<JSPromise> module_promise_;
   std::unique_ptr<ModuleCompiler> compiler_;
   std::unique_ptr<ModuleBytesEnv> module_bytes_env_;
 
   std::vector<DeferredHandles*> deferred_handles_;
   Handle<WasmModuleObject> module_object_;
   Handle<FixedArray> function_tables_;
   Handle<FixedArray> signature_tables_;
   Handle<WasmCompiledModule> compiled_module_;
   Handle<FixedArray> code_table_;
   std::unique_ptr<WasmInstance> temp_instance_ = nullptr;
   size_t outstanding_units_ = 0;
   std::unique_ptr<CompileStep> step_;
   CancelableTaskManager background_task_manager_;
 #if DEBUG
   // Counts the number of pending foreground tasks.
   int32_t num_pending_foreground_tasks_ = 0;
 #endif
 
+  Counters* counters() const { return counters_shared_.get(); }
+
   void ReopenHandlesInDeferredScope();
 
   void AsyncCompileFailed(ErrorThrower& thrower);
 
   void AsyncCompileSucceeded(Handle<Object> result);
 
   template <typename Task, typename... Args>
   void DoSync(Args&&... args);
 
   void StartForegroundTask();
 
   void StartBackgroundTask();
 
   template <typename Task, typename... Args>
   void DoAsync(Args&&... args);
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_COMPILER_H_