default-platform.cc 8.85 KB
Newer Older
1
// Copyright 2013 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5
#include "src/libplatform/default-platform.h"
6

7
#include <algorithm>
8 9
#include <queue>

10
#include "include/libplatform/libplatform.h"
11
#include "src/base/debug/stack_trace.h"
12
#include "src/base/logging.h"
13
#include "src/base/page-allocator.h"
14
#include "src/base/platform/platform.h"
15
#include "src/base/platform/time.h"
16
#include "src/base/sys-info.h"
17
#include "src/libplatform/default-foreground-task-runner.h"
18
#include "src/libplatform/default-worker-threads-task-runner.h"
19

20
namespace v8 {
21
namespace platform {
22

23 24 25 26 27 28 29 30 31 32 33
namespace {

void PrintStackTrace() {
  v8::base::debug::StackTrace trace;
  trace.Print();
  // Avoid dumping duplicate stack trace on abort signal.
  v8::base::debug::DisableSignalStackDump();
}

}  // namespace

34
std::unique_ptr<v8::Platform> NewDefaultPlatform(
35
    int thread_pool_size, IdleTaskSupport idle_task_support,
36
    InProcessStackDumping in_process_stack_dumping,
37
    std::unique_ptr<v8::TracingController> tracing_controller) {
38 39 40
  if (in_process_stack_dumping == InProcessStackDumping::kEnabled) {
    v8::base::debug::EnableInProcessStackDumping();
  }
41 42
  std::unique_ptr<DefaultPlatform> platform(
      new DefaultPlatform(idle_task_support, std::move(tracing_controller)));
43
  platform->SetThreadPoolSize(thread_pool_size);
44
  platform->EnsureBackgroundTaskRunnerInitialized();
45 46 47 48 49 50 51 52 53 54 55
  return std::move(platform);
}

v8::Platform* CreateDefaultPlatform(
    int thread_pool_size, IdleTaskSupport idle_task_support,
    InProcessStackDumping in_process_stack_dumping,
    v8::TracingController* tracing_controller) {
  return NewDefaultPlatform(
             thread_pool_size, idle_task_support, in_process_stack_dumping,
             std::unique_ptr<v8::TracingController>(tracing_controller))
      .release();
56 57
}

58 59
bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate,
                     MessageLoopBehavior behavior) {
60 61
  return static_cast<DefaultPlatform*>(platform)->PumpMessageLoop(isolate,
                                                                  behavior);
62
}
63

64
void EnsureEventLoopInitialized(v8::Platform* platform, v8::Isolate* isolate) {
65 66
}

67 68
void RunIdleTasks(v8::Platform* platform, v8::Isolate* isolate,
                  double idle_time_in_seconds) {
69 70
  static_cast<DefaultPlatform*>(platform)->RunIdleTasks(isolate,
                                                        idle_time_in_seconds);
71 72
}

73 74 75
void SetTracingController(
    v8::Platform* platform,
    v8::platform::tracing::TracingController* tracing_controller) {
76
  static_cast<DefaultPlatform*>(platform)->SetTracingController(
77
      std::unique_ptr<v8::TracingController>(tracing_controller));
78 79
}

80
const int DefaultPlatform::kMaxThreadPoolSize = 8;
81

82 83 84
DefaultPlatform::DefaultPlatform(
    IdleTaskSupport idle_task_support,
    std::unique_ptr<v8::TracingController> tracing_controller)
85
    : thread_pool_size_(0),
86
      idle_task_support_(idle_task_support),
87
      tracing_controller_(std::move(tracing_controller)),
88
      page_allocator_(new v8::base::PageAllocator()),
89
      time_function_for_testing_(nullptr) {
90
  if (!tracing_controller_) {
91 92 93 94 95
    tracing::TracingController* controller = new tracing::TracingController();
    controller->Initialize(nullptr);
    tracing_controller_.reset(controller);
  }
}
96 97

DefaultPlatform::~DefaultPlatform() {
98
  base::LockGuard<base::Mutex> guard(&lock_);
99
  if (worker_threads_task_runner_) worker_threads_task_runner_->Terminate();
100 101
  for (auto it : foreground_task_runner_map_) {
    it.second->Terminate();
102
  }
103 104 105
}

void DefaultPlatform::SetThreadPoolSize(int thread_pool_size) {
106
  base::LockGuard<base::Mutex> guard(&lock_);
107
  DCHECK_GE(thread_pool_size, 0);
108
  if (thread_pool_size < 1) {
109
    thread_pool_size = base::SysInfo::NumberOfProcessors() - 1;
110
  }
111 112
  thread_pool_size_ =
      std::max(std::min(thread_pool_size, kMaxThreadPoolSize), 1);
113
}
114

115
void DefaultPlatform::EnsureBackgroundTaskRunnerInitialized() {
116
  base::LockGuard<base::Mutex> guard(&lock_);
117 118 119
  if (!worker_threads_task_runner_) {
    worker_threads_task_runner_ =
        std::make_shared<DefaultWorkerThreadsTaskRunner>(thread_pool_size_);
120 121 122
  }
}

123
namespace {
124

125 126 127
double DefaultTimeFunction() {
  return base::TimeTicks::HighResolutionNow().ToInternalValue() /
         static_cast<double>(base::Time::kMicrosecondsPerSecond);
128 129
}

130
}  // namespace
131

132 133
void DefaultPlatform::SetTimeFunctionForTesting(
    DefaultPlatform::TimeFunction time_function) {
134
  base::LockGuard<base::Mutex> guard(&lock_);
135 136 137
  time_function_for_testing_ = time_function;
  // The time function has to be right after the construction of the platform.
  DCHECK(foreground_task_runner_map_.empty());
138 139 140
}

bool DefaultPlatform::PumpMessageLoop(v8::Isolate* isolate,
141 142
                                      MessageLoopBehavior wait_for_work) {
  bool failed_result = wait_for_work == MessageLoopBehavior::kWaitForWork;
143
  std::shared_ptr<DefaultForegroundTaskRunner> task_runner;
144 145
  {
    base::LockGuard<base::Mutex> guard(&lock_);
146 147 148
    if (foreground_task_runner_map_.find(isolate) ==
        foreground_task_runner_map_.end()) {
      return failed_result;
149
    }
150 151
    task_runner = foreground_task_runner_map_[isolate];
  }
152

153
  std::unique_ptr<Task> task = task_runner->PopTaskFromQueue(wait_for_work);
154
  if (!task) return failed_result;
155

156 157 158 159
  task->Run();
  return true;
}

160 161
void DefaultPlatform::RunIdleTasks(v8::Isolate* isolate,
                                   double idle_time_in_seconds) {
162
  DCHECK_EQ(IdleTaskSupport::kEnabled, idle_task_support_);
163 164 165 166 167 168 169 170 171
  std::shared_ptr<DefaultForegroundTaskRunner> task_runner;
  {
    base::LockGuard<base::Mutex> guard(&lock_);
    if (foreground_task_runner_map_.find(isolate) ==
        foreground_task_runner_map_.end()) {
      return;
    }
    task_runner = foreground_task_runner_map_[isolate];
  }
172 173
  double deadline_in_seconds =
      MonotonicallyIncreasingTime() + idle_time_in_seconds;
174

175
  while (deadline_in_seconds > MonotonicallyIncreasingTime()) {
176 177 178
    std::unique_ptr<IdleTask> task = task_runner->PopTaskFromIdleQueue();
    if (!task) return;
    task->Run(deadline_in_seconds);
179 180
  }
}
181

182 183 184 185 186 187 188 189 190 191 192 193
std::shared_ptr<TaskRunner> DefaultPlatform::GetForegroundTaskRunner(
    v8::Isolate* isolate) {
  base::LockGuard<base::Mutex> guard(&lock_);
  if (foreground_task_runner_map_.find(isolate) ==
      foreground_task_runner_map_.end()) {
    foreground_task_runner_map_.insert(std::make_pair(
        isolate, std::make_shared<DefaultForegroundTaskRunner>(
                     idle_task_support_, time_function_for_testing_
                                             ? time_function_for_testing_
                                             : DefaultTimeFunction)));
  }
  return foreground_task_runner_map_[isolate];
194 195
}

196
void DefaultPlatform::CallOnWorkerThread(std::unique_ptr<Task> task) {
197 198
  EnsureBackgroundTaskRunnerInitialized();
  worker_threads_task_runner_->PostTask(std::move(task));
199
}
200

201 202
void DefaultPlatform::CallDelayedOnWorkerThread(std::unique_ptr<Task> task,
                                                double delay_in_seconds) {
203 204 205
  EnsureBackgroundTaskRunnerInitialized();
  worker_threads_task_runner_->PostDelayedTask(std::move(task),
                                               delay_in_seconds);
206 207
}

208
void DefaultPlatform::CallOnForegroundThread(v8::Isolate* isolate, Task* task) {
209
  GetForegroundTaskRunner(isolate)->PostTask(std::unique_ptr<Task>(task));
210 211
}

212 213 214
void DefaultPlatform::CallDelayedOnForegroundThread(Isolate* isolate,
                                                    Task* task,
                                                    double delay_in_seconds) {
215 216
  GetForegroundTaskRunner(isolate)->PostDelayedTask(std::unique_ptr<Task>(task),
                                                    delay_in_seconds);
217 218
}

219 220
void DefaultPlatform::CallIdleOnForegroundThread(Isolate* isolate,
                                                 IdleTask* task) {
221 222
  GetForegroundTaskRunner(isolate)->PostIdleTask(
      std::unique_ptr<IdleTask>(task));
223 224
}

225 226 227
bool DefaultPlatform::IdleTasksEnabled(Isolate* isolate) {
  return idle_task_support_ == IdleTaskSupport::kEnabled;
}
228

229
double DefaultPlatform::MonotonicallyIncreasingTime() {
230 231
  if (time_function_for_testing_) return time_function_for_testing_();
  return DefaultTimeFunction();
232
}
233

234 235 236 237
double DefaultPlatform::CurrentClockTimeMillis() {
  return base::OS::TimeCurrentMillis();
}

238 239 240 241
TracingController* DefaultPlatform::GetTracingController() {
  return tracing_controller_.get();
}

242
void DefaultPlatform::SetTracingController(
243 244 245
    std::unique_ptr<v8::TracingController> tracing_controller) {
  DCHECK_NOT_NULL(tracing_controller.get());
  tracing_controller_ = std::move(tracing_controller);
246
}
247

248
int DefaultPlatform::NumberOfWorkerThreads() { return thread_pool_size_; }
249

250 251 252 253
Platform::StackTracePrinter DefaultPlatform::GetStackTracePrinter() {
  return PrintStackTrace;
}

254 255 256 257
v8::PageAllocator* DefaultPlatform::GetPageAllocator() {
  return page_allocator_.get();
}

258 259
}  // namespace platform
}  // namespace v8