From f33ab49127c328dae7c358746a2d1348eb8af130 Mon Sep 17 00:00:00 2001 From: Michael Starzinger Date: Fri, 13 Jul 2018 12:40:14 +0200 Subject: [PATCH] [wasm] Remove support for compilation task throttling. This removes support to track the memory footprint of fully executed but not yet finalized compilation units. It was used to throttle creation of new tasks when the latent memory pressure of this unfinished jobs rose above a certain threshold. Now that units no longer incur a significant latent memory pressure, this is no longer needed. R=clemensh@chromium.org BUG=v8:7921 Change-Id: I3f4a563ebcb85b7aeac50f469a8a495eecf8aa3d Reviewed-on: https://chromium-review.googlesource.com/1136291 Reviewed-by: Clemens Hammacher Commit-Queue: Michael Starzinger Cr-Commit-Position: refs/heads/master@{#54435} --- src/compiler/wasm-compiler.cc | 4 --- src/wasm/baseline/liftoff-compiler.cc | 4 --- src/wasm/function-compiler.h | 2 -- src/wasm/module-compiler.cc | 37 +++------------------------ 4 files changed, 4 insertions(+), 43 deletions(-) diff --git a/src/compiler/wasm-compiler.cc b/src/compiler/wasm-compiler.cc index a3d75d00eb..7c30f18a8e 100644 --- a/src/compiler/wasm-compiler.cc +++ b/src/compiler/wasm-compiler.cc @@ -5232,10 +5232,6 @@ void TurbofanWasmCompilationUnit::ExecuteCompilation() { } if (ok_) wasm_code_ = info.wasm_code(); } - - // Record the memory cost this unit places on the system until - // it is finalized. - wasm_unit_->memory_cost_ = sizeof(TurbofanWasmCompilationUnit); } wasm::WasmCode* TurbofanWasmCompilationUnit::FinishCompilation( diff --git a/src/wasm/baseline/liftoff-compiler.cc b/src/wasm/baseline/liftoff-compiler.cc index b7883876a0..c3d430d730 100644 --- a/src/wasm/baseline/liftoff-compiler.cc +++ b/src/wasm/baseline/liftoff-compiler.cc @@ -1886,10 +1886,6 @@ bool LiftoffCompilationUnit::ExecuteCompilation() { wasm::WasmCode::kLiftoff); wasm_unit_->native_module_->PublishCode(code_); - // Record the memory cost this unit places on the system until - // it is finalized. - wasm_unit_->memory_cost_ = sizeof(*this); - return true; } diff --git a/src/wasm/function-compiler.h b/src/wasm/function-compiler.h index 65fc35709f..0e742e15c0 100644 --- a/src/wasm/function-compiler.h +++ b/src/wasm/function-compiler.h @@ -76,7 +76,6 @@ class WasmCompilationUnit final { Isolate* isolate, ModuleEnv* env, const wasm::WasmFunction* function, CompilationMode = GetDefaultCompilationMode()); - size_t memory_cost() const { return memory_cost_; } wasm::NativeModule* native_module() const { return native_module_; } CompilationMode mode() const { return mode_; } @@ -90,7 +89,6 @@ class WasmCompilationUnit final { wasm::WasmName func_name_; Counters* counters_; int func_index_; - size_t memory_cost_ = 0; wasm::NativeModule* native_module_; // TODO(wasm): Put {lower_simd_} inside the {ModuleEnv}. bool lower_simd_; diff --git a/src/wasm/module-compiler.cc b/src/wasm/module-compiler.cc index 97eccf3c36..ed1d073af0 100644 --- a/src/wasm/module-compiler.cc +++ b/src/wasm/module-compiler.cc @@ -95,8 +95,6 @@ class CompilationState { bool SetFinisherIsRunning(bool value); void ScheduleFinisherTask(); - bool StopBackgroundCompilationTaskForThrottling(); - void Abort(); Isolate* isolate() const { return isolate_; } @@ -127,7 +125,6 @@ class CompilationState { WasmEngine* const wasm_engine_; // TODO(clemensh): Remove ModuleEnv, generate it when needed. ModuleEnv module_env_; - const size_t max_memory_; const CompileMode compile_mode_; bool baseline_compilation_finished_ = false; @@ -148,8 +145,6 @@ class CompilationState { std::vector> baseline_finish_units_; std::vector> tiering_finish_units_; - size_t allocated_memory_ = 0; - // End of fields protected by {mutex_}. ////////////////////////////////////////////////////////////////////////////// @@ -464,12 +459,6 @@ ModuleEnv CreateDefaultModuleEnv(const WasmModule* module, return ModuleEnv(module, use_trap_handler, kRuntimeExceptionSupport); } -size_t GetMaxUsableMemorySize(Isolate* isolate) { - return isolate->heap()->memory_allocator()->code_range()->valid() - ? isolate->heap()->memory_allocator()->code_range()->size() - : isolate->heap()->code_space()->Capacity(); -} - // The CompilationUnitBuilder builds compilation units and stores them in an // internal buffer. The buffer is moved into the working queue of the // CompilationState when {Commit} is called. @@ -863,16 +852,14 @@ class BackgroundCompileTask : public CancelableTask { void RunInternal() override { TRACE_COMPILE("(3b) Compiling...\n"); - // The number of currently running background tasks is reduced either in - // {StopBackgroundCompilationTaskForThrottling} or in + // The number of currently running background tasks is reduced in // {OnBackgroundTaskStopped}. - while (!compilation_state_->StopBackgroundCompilationTaskForThrottling()) { - if (compilation_state_->failed() || - !FetchAndExecuteCompilationUnit(compilation_state_)) { - compilation_state_->OnBackgroundTaskStopped(); + while (!compilation_state_->failed()) { + if (!FetchAndExecuteCompilationUnit(compilation_state_)) { break; } } + compilation_state_->OnBackgroundTaskStopped(); } private: @@ -2769,14 +2756,12 @@ CompilationState::CompilationState(internal::Isolate* isolate, : isolate_(isolate), wasm_engine_(isolate->wasm_engine()), module_env_(env), - max_memory_(GetMaxUsableMemorySize(isolate) / 2), compile_mode_(FLAG_wasm_tier_up && env.module->origin == kWasmOrigin ? CompileMode::kTiering : CompileMode::kRegular), max_background_tasks_(std::max( 1, std::min(FLAG_wasm_num_compilation_tasks, V8::GetCurrentPlatform()->NumberOfWorkerThreads()))) { - DCHECK_LT(0, max_memory_); v8::Isolate* v8_isolate = reinterpret_cast(isolate_); v8::Platform* platform = V8::GetCurrentPlatform(); foreground_task_runner_ = platform->GetForegroundTaskRunner(v8_isolate); @@ -2858,7 +2843,6 @@ std::unique_ptr CompilationState::GetNextExecutedUnit() { if (units.empty()) return {}; std::unique_ptr ret = std::move(units.back()); units.pop_back(); - allocated_memory_ -= ret->memory_cost(); return ret; } @@ -2907,7 +2891,6 @@ void CompilationState::OnFinishedUnit() { void CompilationState::ScheduleUnitForFinishing( std::unique_ptr unit, WasmCompilationUnit::CompilationMode mode) { - size_t cost = unit->memory_cost(); base::LockGuard guard(&mutex_); if (compile_mode_ == CompileMode::kTiering && mode == WasmCompilationUnit::CompilationMode::kTurbofan) { @@ -2915,7 +2898,6 @@ void CompilationState::ScheduleUnitForFinishing( } else { baseline_finish_units_.push_back(std::move(unit)); } - allocated_memory_ += cost; if (!finisher_is_running_ && !failed_) { ScheduleFinisherTask(); @@ -2942,8 +2924,6 @@ void CompilationState::RestartBackgroundTasks(size_t max) { // No need to restart tasks if compilation already failed. if (failed_) return; - bool should_increase_workload = allocated_memory_ <= max_memory_ / 2; - if (!should_increase_workload) return; DCHECK_LE(num_background_tasks_, max_background_tasks_); if (num_background_tasks_ == max_background_tasks_) return; size_t num_compilation_units = @@ -2979,15 +2959,6 @@ void CompilationState::ScheduleFinisherTask() { base::make_unique(this, &foreground_task_manager_)); } -bool CompilationState::StopBackgroundCompilationTaskForThrottling() { - base::LockGuard guard(&mutex_); - DCHECK_LE(1, num_background_tasks_); - bool can_accept_work = allocated_memory_ < max_memory_; - if (can_accept_work) return false; - --num_background_tasks_; - return true; -} - void CompilationState::Abort() { { base::LockGuard guard(&mutex_);