compiler-dispatcher.h 7.02 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2016 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_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_
#define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_

8
#include <cstdint>
9 10
#include <map>
#include <memory>
11
#include <unordered_set>
12 13
#include <utility>

14
#include "src/base/atomic-utils.h"
15
#include "src/base/macros.h"
16
#include "src/base/optional.h"
17 18
#include "src/base/platform/condition-variable.h"
#include "src/base/platform/mutex.h"
19
#include "src/base/platform/semaphore.h"
20
#include "src/common/globals.h"
21
#include "src/handles/maybe-handles.h"
22
#include "src/utils/identity-map.h"
23
#include "testing/gtest/include/gtest/gtest_prod.h"  // nogncheck
24 25

namespace v8 {
26 27

class Platform;
28
enum class MemoryPressureLevel;
29

30 31
namespace internal {

32
class AstRawString;
33
class AstValueFactory;
34
class BackgroundCompileTask;
35
class CancelableTaskManager;
36
class UnoptimizedCompileJob;
37
class CompilerDispatcherTracer;
38
class DeferredHandles;
39
class FunctionLiteral;
40
class Isolate;
41
class ParseInfo;
42
class SharedFunctionInfo;
43
class TimedHistogram;
44
class WorkerThreadRuntimeCallStats;
45
class Zone;
46 47 48 49

template <typename T>
class Handle;

50 51
// The CompilerDispatcher uses a combination of idle tasks and background tasks
// to parse and compile lazily parsed functions.
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
//
// As both parsing and compilation currently requires a preparation and
// finalization step that happens on the main thread, every task has to be
// advanced during idle time first. Depending on the properties of the task, it
// can then be parsed or compiled on either background threads, or during idle
// time. Last, it has to be finalized during idle time again.
//
// CompilerDispatcher::jobs_ maintains the list of all CompilerDispatcherJobs
// the CompilerDispatcher knows about.
//
// CompilerDispatcher::pending_background_jobs_ contains the set of
// CompilerDispatcherJobs that can be processed on a background thread.
//
// CompilerDispatcher::running_background_jobs_ contains the set of
// CompilerDispatcherJobs that are currently being processed on a background
// thread.
//
// CompilerDispatcher::DoIdleWork tries to advance as many jobs out of jobs_ as
// possible during idle time. If a job can't be advanced, but is suitable for
// background processing, it fires off background threads.
//
// CompilerDispatcher::DoBackgroundWork advances one of the pending jobs, and
// then spins of another idle task to potentially do the final step on the main
// thread.
76 77
class V8_EXPORT_PRIVATE CompilerDispatcher {
 public:
78
  using JobId = uintptr_t;
79

80 81
  CompilerDispatcher(Isolate* isolate, Platform* platform,
                     size_t max_stack_size);
82 83
  ~CompilerDispatcher();

84 85 86
  // Returns true if the compiler dispatcher is enabled.
  bool IsEnabled() const;

87 88 89
  base::Optional<JobId> Enqueue(const ParseInfo* outer_parse_info,
                                const AstRawString* function_name,
                                const FunctionLiteral* function_literal);
90

91
  // Registers the given |function| with the compilation job |job_id|.
92
  void RegisterSharedFunctionInfo(JobId job_id, SharedFunctionInfo function);
93

94 95 96 97
  // Returns true if there is a pending job with the given id.
  bool IsEnqueued(JobId job_id) const;

  // Returns true if there is a pending job registered for the given function.
98 99 100
  bool IsEnqueued(Handle<SharedFunctionInfo> function) const;

  // Blocks until the given function is compiled (and does so as fast as
101
  // possible). Returns true if the compile job was successful.
102 103
  bool FinishNow(Handle<SharedFunctionInfo> function);

104 105 106
  // Aborts compilation job |job_id|.
  void AbortJob(JobId job_id);

107 108
  // Aborts all jobs, blocking until all jobs are aborted.
  void AbortAll();
109

110
 private:
111
  FRIEND_TEST(CompilerDispatcherTest, IdleTaskNoIdleTime);
112
  FRIEND_TEST(CompilerDispatcherTest, IdleTaskSmallIdleTime);
113
  FRIEND_TEST(CompilerDispatcherTest, FinishNowWithWorkerTask);
114 115
  FRIEND_TEST(CompilerDispatcherTest, AbortJobNotStarted);
  FRIEND_TEST(CompilerDispatcherTest, AbortJobAlreadyStarted);
116 117
  FRIEND_TEST(CompilerDispatcherTest, AsyncAbortAllPendingWorkerTask);
  FRIEND_TEST(CompilerDispatcherTest, AsyncAbortAllRunningWorkerTask);
118
  FRIEND_TEST(CompilerDispatcherTest, CompileMultipleOnBackgroundThread);
119

120 121 122 123
  struct Job {
    explicit Job(BackgroundCompileTask* task_arg);
    ~Job();

124
    bool IsReadyToFinalize(const base::MutexGuard&) {
125
      return has_run && (!function.is_null() || aborted);
126 127 128
    }

    bool IsReadyToFinalize(base::Mutex* mutex) {
129
      base::MutexGuard lock(mutex);
130 131 132 133 134 135
      return IsReadyToFinalize(lock);
    }

    std::unique_ptr<BackgroundCompileTask> task;
    MaybeHandle<SharedFunctionInfo> function;
    bool has_run;
136
    bool aborted;
137 138
  };

139 140
  using JobMap = std::map<JobId, std::unique_ptr<Job>>;
  using SharedToJobIdMap = IdentityMap<JobId, FreeStoreAllocationPolicy>;
141 142

  void WaitForJobIfRunningOnBackground(Job* job);
143
  JobMap::const_iterator GetJobFor(Handle<SharedFunctionInfo> shared) const;
144
  void ScheduleMoreWorkerTasksIfNeeded();
145
  void ScheduleIdleTaskFromAnyThread(const base::MutexGuard&);
146
  void DoBackgroundWork();
147
  void DoIdleWork(double deadline_in_seconds);
148
  // Returns iterator to the inserted job.
149
  JobMap::const_iterator InsertJob(std::unique_ptr<Job> job);
150 151
  // Returns iterator following the removed job.
  JobMap::const_iterator RemoveJob(JobMap::const_iterator job);
152 153

  Isolate* isolate_;
154 155
  AccountingAllocator* allocator_;
  WorkerThreadRuntimeCallStats* worker_thread_runtime_call_stats_;
156
  TimedHistogram* background_compile_timer_;
157
  std::shared_ptr<v8::TaskRunner> taskrunner_;
158
  Platform* platform_;
159
  size_t max_stack_size_;
160 161 162 163

  // Copy of FLAG_trace_compiler_dispatcher to allow for access from any thread.
  bool trace_compiler_dispatcher_;

164
  std::unique_ptr<CancelableTaskManager> task_manager_;
165

166 167 168 169
  // Id for next job to be added
  JobId next_job_id_;

  // Mapping from job_id to job.
170
  JobMap jobs_;
171

172 173 174
  // Mapping from SharedFunctionInfo to the corresponding unoptimized
  // compilation's JobId;
  SharedToJobIdMap shared_to_unoptimized_job_id_;
175

176 177 178 179
  // The following members can be accessed from any thread. Methods need to hold
  // the mutex |mutex_| while accessing them.
  base::Mutex mutex_;

180
  // True if an idle task is scheduled to be run.
181 182
  bool idle_task_scheduled_;

183 184
  // Number of scheduled or running WorkerTask objects.
  int num_worker_tasks_;
185

186 187
  // The set of jobs that can be run on a background thread.
  std::unordered_set<Job*> pending_background_jobs_;
188

189 190
  // The set of jobs currently being run on background threads.
  std::unordered_set<Job*> running_background_jobs_;
191 192 193

  // If not nullptr, then the main thread waits for the task processing
  // this job, and blocks on the ConditionVariable main_thread_blocking_signal_.
194
  Job* main_thread_blocking_on_job_;
195 196
  base::ConditionVariable main_thread_blocking_signal_;

197 198 199 200
  // Test support.
  base::AtomicValue<bool> block_for_testing_;
  base::Semaphore semaphore_for_testing_;

201 202 203 204 205 206 207
  DISALLOW_COPY_AND_ASSIGN(CompilerDispatcher);
};

}  // namespace internal
}  // namespace v8

#endif  // V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_