Clean up issues raised on previous CL.

Fixes issues raised in CL https://codereview.chromium.org/2887193002.
That is:

1) Remove using mutex in Isolate::InitializeCounters().

2) Use counters_shared_.get() instead of counters_ (and hence, also
   remove field counters_).

BUG=v8:6361

Review-Url: https://codereview.chromium.org/2919953003
Cr-Commit-Position: refs/heads/master@{#45743}

src/isolate.cc

@@ -2288,7 +2288,6 @@ Isolate::Isolate(bool enable_serializer)
       bootstrapper_(NULL),
       runtime_profiler_(NULL),
       compilation_cache_(NULL),
-      counters_(NULL),
       logger_(NULL),
       stats_table_(NULL),
       load_stub_cache_(NULL),
@@ -2552,8 +2551,6 @@ Isolate::~Isolate() {
   delete logger_;
   logger_ = NULL;
 
-  counters_ = NULL;
-
   delete handle_scope_implementer_;
   handle_scope_implementer_ = NULL;
 
@@ -2637,14 +2634,9 @@ bool Isolate::PropagatePendingExceptionToExternalTryCatch() {
   return true;
 }
 
-static base::LazyMutex initialize_counters_mutex = LAZY_MUTEX_INITIALIZER;
-
 bool Isolate::InitializeCounters() {
-  if (counters_ != nullptr) return false;
-  base::LockGuard<base::Mutex> guard(initialize_counters_mutex.Pointer());
-  if (counters_ != nullptr) return false;
+  if (counters_shared_) return false;
   counters_shared_ = std::make_shared<Counters>(this);
-  counters_ = counters_shared_.get();
   return true;
 }
 
@@ -2864,7 +2856,8 @@ bool Isolate::Init(Deserializer* des) {
 StatsTable* Isolate::stats_table() {
   if (stats_table_ != nullptr) return stats_table_;
   InitializeCounters();
-  return stats_table_ = counters_->stats_table();
+  stats_table_ = counters_shared_->stats_table();
+  return stats_table_;
 }
 
 

src/isolate.h

@@ -525,7 +525,7 @@ class Isolate {
     DCHECK(base::Relaxed_Load(&isolate_key_created_) == 1);
     Isolate* isolate = reinterpret_cast<Isolate*>(
         base::Thread::GetExistingThreadLocal(isolate_key_));
-    DCHECK(isolate != NULL);
+    DCHECK_NOT_NULL(isolate);
     return isolate;
   }
 
@@ -869,8 +869,8 @@ class Isolate {
   Counters* counters() {
     // Call InitializeLoggingAndCounters() if logging is needed before
     // the isolate is fully initialized.
-    DCHECK(counters_ != NULL);
-    return counters_;
+    DCHECK_NOT_NULL(counters_shared_.get());
+    return counters_shared_.get();
   }
   std::shared_ptr<Counters> counters_shared() { return counters_shared_; }
   RuntimeProfiler* runtime_profiler() { return runtime_profiler_; }
@@ -878,7 +878,7 @@ class Isolate {
   Logger* logger() {
     // Call InitializeLoggingAndCounters() if logging is needed before
     // the isolate is fully initialized.
-    DCHECK(logger_ != NULL);
+    DCHECK_NOT_NULL(logger_);
     return logger_;
   }
   StackGuard* stack_guard() { return &stack_guard_; }
@@ -1435,7 +1435,6 @@ class Isolate {
   RuntimeProfiler* runtime_profiler_;
   CompilationCache* compilation_cache_;
   std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
   base::RecursiveMutex break_access_;
   Logger* logger_;
   StackGuard stack_guard_;

src/wasm/wasm-module.cc

@@ -333,9 +333,7 @@ class CompilationHelper {
         module_(std::move(module)),
         counters_shared_(isolate->counters_shared()),
         is_sync_(is_sync),
-        executed_units_(isolate->random_number_generator()) {
-    counters_ = counters_shared_.get();
-  }
+        executed_units_(isolate->random_number_generator()) {}
 
   // The actual runnable task that performs compilations in the background.
   class CompilationTask : public CancelableTask {
@@ -354,7 +352,6 @@ class CompilationHelper {
   Isolate* isolate_;
   std::unique_ptr<WasmModule> module_;
   std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
   bool is_sync_;
   std::vector<std::unique_ptr<compiler::WasmCompilationUnit>>
       compilation_units_;
@@ -691,7 +688,7 @@ class CompilationHelper {
          i < temp_instance->function_code.size(); ++i) {
       Code* code = *temp_instance->function_code[i];
       code_table->set(static_cast<int>(i), code);
-      RecordStats(code, counters_);
+      RecordStats(code, counters_shared_.get());
     }
 
     // Create heap objects for script, module bytes and asm.js offset table to
@@ -759,7 +756,7 @@ class CompilationHelper {
       int export_index =
           static_cast<int>(module->functions.size() + func_index);
       code_table->set(export_index, *wrapper_code);
-      RecordStats(*wrapper_code, counters_);
+      RecordStats(*wrapper_code, counters_shared_.get());
       func_index++;
     }
 
@@ -1157,9 +1154,7 @@ class InstantiationHelper {
         ffi_(ffi.is_null() ? Handle<JSReceiver>::null()
                            : ffi.ToHandleChecked()),
         memory_(memory.is_null() ? Handle<JSArrayBuffer>::null()
-                                 : memory.ToHandleChecked()) {
-    counters_ = counters_shared_.get();
-  }
+                                 : memory.ToHandleChecked()) {}
 
   // Build an instance, in all of its glory.
   MaybeHandle<WasmInstanceObject> Build() {
@@ -1249,7 +1244,7 @@ class InstantiationHelper {
               UNREACHABLE();
           }
         }
-        RecordStats(code_table, counters_);
+        RecordStats(code_table, counters_shared_.get());
       } else {
         // There was no owner, so we can reuse the original.
         compiled_module_ = original;
@@ -1532,7 +1527,7 @@ class InstantiationHelper {
       Handle<WasmExportedFunction> startup_fct = WasmExportedFunction::New(
           isolate_, instance, MaybeHandle<String>(), start_index,
           static_cast<int>(sig->parameter_count()), wrapper_code);
-      RecordStats(*startup_code, counters_);
+      RecordStats(*startup_code, counters_shared_.get());
       // Call the JS function.
       Handle<Object> undefined = factory->undefined_value();
       MaybeHandle<Object> retval =
@@ -1567,7 +1562,6 @@ class InstantiationHelper {
   Isolate* isolate_;
   WasmModule* const module_;
   std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
   ErrorThrower* thrower_;
   Handle<WasmModuleObject> module_object_;
   Handle<JSReceiver> ffi_;        // TODO(titzer): Use MaybeHandle
@@ -1777,7 +1771,7 @@ class InstantiationHelper {
             return -1;
           }
           code_table->set(num_imported_functions, *import_wrapper);
-          RecordStats(*import_wrapper, counters_);
+          RecordStats(*import_wrapper, counters_shared_.get());
           num_imported_functions++;
           break;
         }
@@ -2754,7 +2748,6 @@ class AsyncCompileJob {
     context_ = Handle<Context>(*context);
     module_promise_ = Handle<JSPromise>(*promise);
     deferred_handles_.push_back(deferred.Detach());
-    counters_ = counters_shared_.get();
   }
 
   void Start() {
@@ -2768,7 +2761,6 @@ class AsyncCompileJob {
  private:
   Isolate* isolate_;
   std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
   std::unique_ptr<byte[]> bytes_copy_;
   ModuleWireBytes wire_bytes_;
   Handle<Context> context_;
@@ -3133,7 +3125,7 @@ class AsyncCompileJob {
       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(code, job_->counters_);
+        RecordStats(code, job_->counters_shared_.get());
       }
 
       // Create heap objects for script and module bytes to be stored in the
@@ -3210,7 +3202,7 @@ class AsyncCompileJob {
         int export_index =
             static_cast<int>(module->functions.size() + func_index);
         job_->code_table_->set(export_index, *wrapper_code);
-        RecordStats(*wrapper_code, job_->counters_);
+        RecordStats(*wrapper_code, job_->counters_shared_.get());
         func_index++;
       }
 
@@ -3432,7 +3424,6 @@ Handle<Code> LazyCompilationOrchestrator::CompileLazy(
     int func_index;
   };
   std::shared_ptr<Counters> counters_shared = isolate->counters_shared();
-  Counters* counters = counters_shared.get();
   std::vector<NonCompiledFunction> non_compiled_functions;
   int func_to_return_idx = exported_func_index;
   wasm::Decoder decoder(nullptr, nullptr);
@@ -3477,7 +3468,7 @@ Handle<Code> LazyCompilationOrchestrator::CompileLazy(
 
   // TODO(clemensh): compile all functions in non_compiled_functions in
   // background, wait for func_to_return_idx.
-  CompileFunction(isolate, instance, func_to_return_idx, counters);
+  CompileFunction(isolate, instance, func_to_return_idx, counters_shared.get());
 
   if (is_js_to_wasm || patch_caller) {
     DisallowHeapAllocation no_gc;