[wasm] Remove sampling on top tier finished

Remove code size and compilation time sampling for the "top tier
finished" event. With dynamic tiering, this event will never be reached.

R=ahaas@chromium.org

Bug: v8:12899
Change-Id: I1b0d053e31fe8cd1f8ba3b23bfff4c5879569b45
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3647691Reviewed-by: Camillo Bruni <cbruni@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Commit-Queue: Clemens Backes <clemensb@chromium.org>
Cr-Commit-Position: refs/heads/main@{#80867}

include/v8-metrics.h

@@ -125,7 +125,9 @@ struct WasmModuleInstantiated {
   int64_t wall_clock_duration_in_us = -1;
 };
 
-struct WasmModuleTieredUp {
+struct V8_DEPRECATE_SOON(
+    "With dynamic tiering, there is no point any more where the module is "
+    "fully tiered up") WasmModuleTieredUp {
   bool lazy = false;
   size_t code_size_in_bytes = 0;
   int64_t wall_clock_duration_in_us = -1;
@@ -188,6 +190,10 @@ class V8_EXPORT Recorder {
   ADD_MAIN_THREAD_EVENT(WasmModuleDecoded)
   ADD_MAIN_THREAD_EVENT(WasmModuleCompiled)
   ADD_MAIN_THREAD_EVENT(WasmModuleInstantiated)
+
+  V8_DEPRECATE_SOON(
+      "With dynamic tiering, there is no point any more where the module is "
+      "fully tiered up")
   ADD_MAIN_THREAD_EVENT(WasmModuleTieredUp)
 #undef ADD_MAIN_THREAD_EVENT
 

src/logging/counters-definitions.h

@@ -71,9 +71,6 @@ namespace internal {
   /* code size per module after baseline compilation */                        \
   HR(wasm_module_code_size_mb_after_baseline,                                  \
      V8.WasmModuleCodeSizeBaselineMiB, 0, 1024, 64)                            \
-  /* code size per module after top-tier compilation */                        \
-  HR(wasm_module_code_size_mb_after_top_tier, V8.WasmModuleCodeSizeTopTierMiB, \
-     0, 1024, 64)                                                              \
   /* percent of freed code size per module, collected on GC */                 \
   HR(wasm_module_freed_code_size_percent, V8.WasmModuleCodeSizePercentFreed,   \
      0, 100, 32)                                                               \

src/wasm/module-compiler.cc

@@ -1821,18 +1821,6 @@ class CompilationTimeCallback : public CompilationEventCallback {
               native_module->baseline_compilation_cpu_duration())};
       metrics_recorder_->DelayMainThreadEvent(event, context_id_);
     }
-    if (compilation_event == CompilationEvent::kFinishedTopTierCompilation) {
-      TimedHistogram* histogram = async_counters_->wasm_tier_up_module_time();
-      histogram->AddSample(static_cast<int>(duration.InMicroseconds()));
-
-      v8::metrics::WasmModuleTieredUp event{
-          FLAG_wasm_lazy_compilation,           // lazy
-          native_module->turbofan_code_size(),  // code_size_in_bytes
-          duration.InMicroseconds(),            // wall_clock_duration_in_us
-          static_cast<int64_t>(                 // cpu_time_duration_in_us
-              native_module->tier_up_cpu_duration())};
-      metrics_recorder_->DelayMainThreadEvent(event, context_id_);
-    }
     if (compilation_event == CompilationEvent::kFailedCompilation) {
       v8::metrics::WasmModuleCompiled event{
           (compile_mode_ != kSynchronous),         // async
@@ -2699,25 +2687,6 @@ class AsyncCompileJob::CompileFailed : public CompileStep {
   }
 };
 
-namespace {
-class SampleTopTierCodeSizeCallback : public CompilationEventCallback {
- public:
-  explicit SampleTopTierCodeSizeCallback(
-      std::weak_ptr<NativeModule> native_module)
-      : native_module_(std::move(native_module)) {}
-
-  void call(CompilationEvent event) override {
-    if (event != CompilationEvent::kFinishedTopTierCompilation) return;
-    if (std::shared_ptr<NativeModule> native_module = native_module_.lock()) {
-      GetWasmEngine()->SampleTopTierCodeSizeInAllIsolates(native_module);
-    }
-  }
-
- private:
-  std::weak_ptr<NativeModule> native_module_;
-};
-}  // namespace
-
 //==========================================================================
 // Step 3b (sync): Compilation finished.
 //==========================================================================
@@ -2736,10 +2705,6 @@ class AsyncCompileJob::CompileFinished : public CompileStep {
       // Sample the generated code size when baseline compilation finished.
       job->native_module_->SampleCodeSize(job->isolate_->counters(),
                                           NativeModule::kAfterBaseline);
-      // Also, set a callback to sample the code size after top-tier compilation
-      // finished. This callback will *not* keep the NativeModule alive.
-      job->native_module_->compilation_state()->AddCallback(
-          std::make_unique<SampleTopTierCodeSizeCallback>(job->native_module_));
     }
     // Then finalize and publish the generated module.
     job->FinishCompile(cached_native_module_ != nullptr);

src/wasm/wasm-code-manager.cc

@@ -2308,9 +2308,6 @@ void NativeModule::SampleCodeSize(
     case kAfterBaseline:
       histogram = counters->wasm_module_code_size_mb_after_baseline();
       break;
-    case kAfterTopTier:
-      histogram = counters->wasm_module_code_size_mb_after_top_tier();
-      break;
     case kSampling: {
       histogram = counters->wasm_module_code_size_mb();
       // If this is a wasm module of >= 2MB, also sample the freed code size,

src/wasm/wasm-code-manager.h

@@ -805,7 +805,7 @@ class V8_EXPORT_PRIVATE NativeModule final {
   WasmCode::RuntimeStubId GetRuntimeStubId(Address runtime_stub_target) const;
 
   // Sample the current code size of this modules to the given counters.
-  enum CodeSamplingTime : int8_t { kAfterBaseline, kAfterTopTier, kSampling };
+  enum CodeSamplingTime : int8_t { kAfterBaseline, kSampling };
   void SampleCodeSize(Counters*, CodeSamplingTime) const;
 
   V8_WARN_UNUSED_RESULT std::unique_ptr<WasmCode> AddCompiledCode(

src/wasm/wasm-engine.cc

@@ -1316,40 +1316,6 @@ void WasmEngine::FreeNativeModule(NativeModule* native_module) {
   native_modules_.erase(module);
 }
 
-namespace {
-class SampleTopTierCodeSizeTask : public CancelableTask {
- public:
-  SampleTopTierCodeSizeTask(Isolate* isolate,
-                            std::weak_ptr<NativeModule> native_module)
-      : CancelableTask(isolate),
-        isolate_(isolate),
-        native_module_(std::move(native_module)) {}
-
-  void RunInternal() override {
-    if (std::shared_ptr<NativeModule> native_module = native_module_.lock()) {
-      native_module->SampleCodeSize(isolate_->counters(),
-                                    NativeModule::kAfterTopTier);
-    }
-  }
-
- private:
-  Isolate* const isolate_;
-  const std::weak_ptr<NativeModule> native_module_;
-};
-}  // namespace
-
-void WasmEngine::SampleTopTierCodeSizeInAllIsolates(
-    const std::shared_ptr<NativeModule>& native_module) {
-  base::MutexGuard lock(&mutex_);
-  DCHECK_EQ(1, native_modules_.count(native_module.get()));
-  for (Isolate* isolate : native_modules_[native_module.get()]->isolates) {
-    DCHECK_EQ(1, isolates_.count(isolate));
-    IsolateInfo* info = isolates_[isolate].get();
-    info->foreground_task_runner->PostTask(
-        std::make_unique<SampleTopTierCodeSizeTask>(isolate, native_module));
-  }
-}
-
 void WasmEngine::ReportLiveCodeForGC(Isolate* isolate,
                                      base::Vector<WasmCode*> live_code) {
   TRACE_EVENT0("v8.wasm", "wasm.ReportLiveCodeForGC");

test/cctest/wasm/test-wasm-metrics.cc

@@ -234,7 +234,6 @@ class MetricsRecorder : public v8::metrics::Recorder {
   std::vector<v8::metrics::WasmModuleDecoded> module_decoded_;
   std::vector<v8::metrics::WasmModuleCompiled> module_compiled_;
   std::vector<v8::metrics::WasmModuleInstantiated> module_instantiated_;
-  std::vector<v8::metrics::WasmModuleTieredUp> module_tiered_up_;
 
   void AddMainThreadEvent(const v8::metrics::WasmModuleDecoded& event,
                           v8::metrics::Recorder::ContextId id) override {
@@ -251,11 +250,6 @@ class MetricsRecorder : public v8::metrics::Recorder {
     CHECK(!id.IsEmpty());
     module_instantiated_.emplace_back(event);
   }
-  void AddMainThreadEvent(const v8::metrics::WasmModuleTieredUp& event,
-                          v8::metrics::Recorder::ContextId id) override {
-    CHECK(!id.IsEmpty());
-    module_tiered_up_.emplace_back(event);
-  }
 };
 
 COMPILE_TEST(TestEventMetrics) {
@@ -342,24 +336,6 @@ COMPILE_TEST(TestEventMetrics) {
   CHECK(!recorder->module_instantiated_.back().async);
   CHECK_EQ(0, recorder->module_instantiated_.back().imported_function_count);
   CHECK_LE(0, recorder->module_instantiated_.back().wall_clock_duration_in_us);
-
-  CHECK_EQ(1, recorder->module_tiered_up_.size());
-  CHECK(!recorder->module_tiered_up_.back().lazy);
-  CHECK_LT(0, recorder->module_tiered_up_.back().code_size_in_bytes);
-  CHECK_GE(native_module->turbofan_code_size(),
-           recorder->module_tiered_up_.back().code_size_in_bytes);
-  CHECK_GE(native_module->generated_code_size(),
-           recorder->module_tiered_up_.back().code_size_in_bytes);
-  CHECK_GE(native_module->committed_code_space(),
-           recorder->module_tiered_up_.back().code_size_in_bytes);
-  CHECK_LE(0, recorder->module_tiered_up_.back().wall_clock_duration_in_us);
-  CHECK_EQ(native_module->tier_up_cpu_duration(),
-           recorder->module_tiered_up_.back().cpu_duration_in_us);
-  CHECK_IMPLIES(
-      v8::base::ThreadTicks::IsSupported() && i::FLAG_wasm_tier_up &&
-          i::FLAG_liftoff &&
-          recorder->module_compiled_.back().liftoff_bailout_count == 0,
-      recorder->module_tiered_up_.back().cpu_duration_in_us > 0);
 }
 
 }  // namespace wasm