wasm-engine.h 17.7 KB
Newer Older
1 2 3 4
// Copyright 2017 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.

5 6
#ifndef V8_WASM_WASM_ENGINE_H_
#define V8_WASM_WASM_ENGINE_H_
7

8 9
#include <algorithm>
#include <map>
10
#include <memory>
11
#include <unordered_map>
12
#include <unordered_set>
13

14 15
#include "src/base/platform/condition-variable.h"
#include "src/base/platform/mutex.h"
16
#include "src/tasks/cancelable-task.h"
17
#include "src/wasm/wasm-code-manager.h"
18
#include "src/wasm/wasm-tier.h"
19
#include "src/zone/accounting-allocator.h"
20 21 22 23

namespace v8 {
namespace internal {

24
class AsmWasmData;
25
class CodeTracer;
26
class CompilationStatistics;
27
class HeapNumber;
28
class WasmInstanceObject;
29
class WasmModuleObject;
30
class JSArrayBuffer;
31

32 33
namespace wasm {

34 35 36 37 38 39
#ifdef V8_ENABLE_WASM_GDB_REMOTE_DEBUGGING
namespace gdb_server {
class GdbServer;
}
#endif  // V8_ENABLE_WASM_GDB_REMOTE_DEBUGGING

40
class AsyncCompileJob;
41 42
class ErrorThrower;
struct ModuleWireBytes;
43
class WasmFeatures;
44

45 46 47 48
class V8_EXPORT_PRIVATE CompilationResultResolver {
 public:
  virtual void OnCompilationSucceeded(Handle<WasmModuleObject> result) = 0;
  virtual void OnCompilationFailed(Handle<Object> error_reason) = 0;
49
  virtual ~CompilationResultResolver() = default;
50 51 52 53 54 55
};

class V8_EXPORT_PRIVATE InstantiationResultResolver {
 public:
  virtual void OnInstantiationSucceeded(Handle<WasmInstanceObject> result) = 0;
  virtual void OnInstantiationFailed(Handle<Object> error_reason) = 0;
56
  virtual ~InstantiationResultResolver() = default;
57 58
};

59 60 61
// Native modules cached by their wire bytes.
class NativeModuleCache {
 public:
62 63 64 65 66 67 68 69 70 71 72 73 74 75
  struct Key {
    // Store the prefix hash as part of the key for faster lookup, and to
    // quickly check existing prefixes for streaming compilation.
    size_t prefix_hash;
    Vector<const uint8_t> bytes;

    bool operator==(const Key& other) const {
      bool eq = bytes == other.bytes;
      DCHECK_IMPLIES(eq, prefix_hash == other.prefix_hash);
      return eq;
    }

    bool operator<(const Key& other) const {
      if (prefix_hash != other.prefix_hash) {
76 77
        DCHECK_IMPLIES(!bytes.empty() && !other.bytes.empty(),
                       bytes != other.bytes);
78 79
        return prefix_hash < other.prefix_hash;
      }
80 81 82 83 84 85
      if (bytes.size() != other.bytes.size()) {
        return bytes.size() < other.bytes.size();
      }
      // Fast path when the base pointers are the same.
      // Also handles the {nullptr} case which would be UB for memcmp.
      if (bytes.begin() == other.bytes.begin()) {
86
        DCHECK_EQ(prefix_hash, other.prefix_hash);
87 88 89 90 91
        return false;
      }
      DCHECK_NOT_NULL(bytes.begin());
      DCHECK_NOT_NULL(other.bytes.begin());
      return memcmp(bytes.begin(), other.bytes.begin(), bytes.size()) < 0;
92
    }
93 94 95 96
  };

  std::shared_ptr<NativeModule> MaybeGetNativeModule(
      ModuleOrigin origin, Vector<const uint8_t> wire_bytes);
97 98 99 100
  bool GetStreamingCompilationOwnership(size_t prefix_hash);
  void StreamingCompilationFailed(size_t prefix_hash);
  std::shared_ptr<NativeModule> Update(
      std::shared_ptr<NativeModule> native_module, bool error);
101 102
  void Erase(NativeModule* native_module);

103 104
  bool empty() { return map_.empty(); }

105 106 107 108 109 110 111 112
  static size_t WireBytesHash(Vector<const uint8_t> bytes);

  // Hash the wire bytes up to the code section header. Used as a heuristic to
  // avoid streaming compilation of modules that are likely already in the
  // cache. See {GetStreamingCompilationOwnership}. Assumes that the bytes have
  // already been validated.
  static size_t PrefixHash(Vector<const uint8_t> wire_bytes);

113 114 115 116 117 118 119 120 121 122 123 124
 private:
  // Each key points to the corresponding native module's wire bytes, so they
  // should always be valid as long as the native module is alive.  When
  // the native module dies, {FreeNativeModule} deletes the entry from the
  // map, so that we do not leave any dangling key pointing to an expired
  // weak_ptr. This also serves as a way to regularly clean up the map, which
  // would otherwise accumulate expired entries.
  // A {nullopt} value is inserted to indicate that this native module is
  // currently being created in some thread, and that other threads should wait
  // before trying to get it from the cache.
  // By contrast, an expired {weak_ptr} indicates that the native module died
  // and will soon be cleaned up from the cache.
125
  std::map<Key, base::Optional<std::weak_ptr<NativeModule>>> map_;
126 127 128 129 130 131 132 133 134

  base::Mutex mutex_;

  // This condition variable is used to synchronize threads compiling the same
  // module. Only one thread will create the {NativeModule}. Other threads
  // will wait on this variable until the first thread wakes them up.
  base::ConditionVariable cache_cv_;
};

135
// The central data structure that represents an engine instance capable of
136
// loading, instantiating, and executing Wasm code.
137
class V8_EXPORT_PRIVATE WasmEngine {
138
 public:
139
  WasmEngine();
140
  ~WasmEngine();
141

142
  // Synchronously validates the given bytes that represent an encoded Wasm
143
  // module.
144 145
  bool SyncValidate(Isolate* isolate, const WasmFeatures& enabled,
                    const ModuleWireBytes& bytes);
146

147 148
  // Synchronously compiles the given bytes that represent a translated
  // asm.js module.
149
  MaybeHandle<AsmWasmData> SyncCompileTranslatedAsmJs(
150
      Isolate* isolate, ErrorThrower* thrower, const ModuleWireBytes& bytes,
151
      Vector<const byte> asm_js_offset_table_bytes,
152
      Handle<HeapNumber> uses_bitset, LanguageMode language_mode);
153 154 155
  Handle<WasmModuleObject> FinalizeTranslatedAsmJs(
      Isolate* isolate, Handle<AsmWasmData> asm_wasm_data,
      Handle<Script> script);
156

157
  // Synchronously compiles the given bytes that represent an encoded Wasm
158 159
  // module.
  MaybeHandle<WasmModuleObject> SyncCompile(Isolate* isolate,
160
                                            const WasmFeatures& enabled,
161 162 163
                                            ErrorThrower* thrower,
                                            const ModuleWireBytes& bytes);

164
  // Synchronously instantiate the given Wasm module with the given imports.
165 166 167 168 169 170 171 172
  // If the module represents an asm.js module, then the supplied {memory}
  // should be used as the memory of the instance.
  MaybeHandle<WasmInstanceObject> SyncInstantiate(
      Isolate* isolate, ErrorThrower* thrower,
      Handle<WasmModuleObject> module_object, MaybeHandle<JSReceiver> imports,
      MaybeHandle<JSArrayBuffer> memory);

  // Begin an asynchronous compilation of the given bytes that represent an
173
  // encoded Wasm module.
174 175
  // The {is_shared} flag indicates if the bytes backing the module could
  // be shared across threads, i.e. could be concurrently modified.
176
  void AsyncCompile(Isolate* isolate, const WasmFeatures& enabled,
177
                    std::shared_ptr<CompilationResultResolver> resolver,
178 179
                    const ModuleWireBytes& bytes, bool is_shared,
                    const char* api_method_name_for_errors);
180

181
  // Begin an asynchronous instantiation of the given Wasm module.
182 183
  void AsyncInstantiate(Isolate* isolate,
                        std::unique_ptr<InstantiationResultResolver> resolver,
184 185 186
                        Handle<WasmModuleObject> module_object,
                        MaybeHandle<JSReceiver> imports);

187
  std::shared_ptr<StreamingDecoder> StartStreamingCompilation(
188
      Isolate* isolate, const WasmFeatures& enabled, Handle<Context> context,
189
      const char* api_method_name,
190
      std::shared_ptr<CompilationResultResolver> resolver);
191

192 193 194 195
  // Compiles the function with the given index at a specific compilation tier.
  // Errors are stored internally in the CompilationState.
  // This is mostly used for testing to force a function into a specific tier.
  void CompileFunction(Isolate* isolate, NativeModule* native_module,
196
                       uint32_t function_index, ExecutionTier tier);
197

198
  void TierDownAllModulesPerIsolate(Isolate* isolate);
199
  void TierUpAllModulesPerIsolate(Isolate* isolate);
200

201 202 203 204 205 206 207 208
  // Exports the sharable parts of the given module object so that they can be
  // transferred to a different Context/Isolate using the same engine.
  std::shared_ptr<NativeModule> ExportNativeModule(
      Handle<WasmModuleObject> module_object);

  // Imports the shared part of a module from a different Context/Isolate using
  // the the same engine, recreating a full module object in the given Isolate.
  Handle<WasmModuleObject> ImportNativeModule(
209 210
      Isolate* isolate, std::shared_ptr<NativeModule> shared_module,
      Vector<const char> source_url);
211

212
  WasmCodeManager* code_manager() { return &code_manager_; }
213

214 215
  AccountingAllocator* allocator() { return &allocator_; }

216 217 218 219 220 221
  // Compilation statistics for TurboFan compilations.
  CompilationStatistics* GetOrCreateTurboStatistics();

  // Prints the gathered compilation statistics, then resets them.
  void DumpAndResetTurboStatistics();

222 223 224
  // Used to redirect tracing output from {stdout} to a file.
  CodeTracer* GetCodeTracer();

225
  // Remove {job} from the list of active compile jobs.
226
  std::unique_ptr<AsyncCompileJob> RemoveCompileJob(AsyncCompileJob* job);
227

228 229 230
  // Returns true if at least one AsyncCompileJob that belongs to the given
  // Isolate is currently running.
  bool HasRunningCompileJob(Isolate* isolate);
231

232 233 234 235 236
  // Deletes all AsyncCompileJobs that belong to the given context. All
  // compilation is aborted, no more callbacks will be triggered. This is used
  // when a context is disposed, e.g. because of browser navigation.
  void DeleteCompileJobsOnContext(Handle<Context> context);

237
  // Deletes all AsyncCompileJobs that belong to the given Isolate. All
238 239
  // compilation is aborted, no more callbacks will be triggered. This is used
  // for tearing down an isolate, or to clean it up to be reused.
240
  void DeleteCompileJobsOnIsolate(Isolate* isolate);
241

242 243 244 245
  // Manage the set of Isolates that use this WasmEngine.
  void AddIsolate(Isolate* isolate);
  void RemoveIsolate(Isolate* isolate);

246 247
  template <typename T, typename... Args>
  std::unique_ptr<T> NewBackgroundCompileTask(Args&&... args) {
248 249
    return std::make_unique<T>(&background_compile_task_manager_,
                               std::forward<Args>(args)...);
250 251
  }

252 253 254 255
  // Trigger code logging for the given code objects in all Isolates which have
  // access to the NativeModule containing this code. This method can be called
  // from background threads.
  void LogCode(Vector<WasmCode*>);
256

257 258 259 260 261
  // Enable code logging for the given Isolate. Initially, code logging is
  // enabled if {WasmCode::ShouldBeLogged(Isolate*)} returns true during
  // {AddIsolate}.
  void EnableCodeLogging(Isolate*);

262 263 264 265
  // This is called from the foreground thread of the Isolate to log all
  // outstanding code objects (added via {LogCode}).
  void LogOutstandingCodesForIsolate(Isolate*);

266 267 268
  // Create a new NativeModule. The caller is responsible for its
  // lifetime. The native module will be given some memory for code,
  // which will be page size aligned. The size of the initial memory
269 270 271
  // is determined by {code_size_estimate}. The native module may later request
  // more memory.
  // TODO(wasm): isolate is only required here for CompilationState.
272 273
  std::shared_ptr<NativeModule> NewNativeModule(
      Isolate* isolate, const WasmFeatures& enabled_features,
274
      std::shared_ptr<const WasmModule> module, size_t code_size_estimate);
275

276 277 278 279 280 281 282
  // Try getting a cached {NativeModule}, or get ownership for its creation.
  // Return {nullptr} if no {NativeModule} exists for these bytes. In this case,
  // a {nullopt} entry is added to let other threads know that a {NativeModule}
  // for these bytes is currently being created. The caller should eventually
  // call {UpdateNativeModuleCache} to update the entry and wake up other
  // threads. The {wire_bytes}' underlying array should be valid at least until
  // the call to {UpdateNativeModuleCache}.
283
  std::shared_ptr<NativeModule> MaybeGetNativeModule(
284
      ModuleOrigin origin, Vector<const uint8_t> wire_bytes, Isolate* isolate);
285

286 287
  // Replace the temporary {nullopt} with the new native module, or
  // erase it if any error occurred. Wake up blocked threads waiting for this
288
  // module.
289 290 291 292 293 294 295
  // To avoid a deadlock on the main thread between synchronous and streaming
  // compilation, two compilation jobs might compile the same native module at
  // the same time. In this case the first call to {UpdateNativeModuleCache}
  // will insert the native module in the cache, and the last call will discard
  // its {native_module} argument and replace it with the existing entry.
  // Return true in the former case, and false in the latter.
  bool UpdateNativeModuleCache(bool error,
296 297
                               std::shared_ptr<NativeModule>* native_module,
                               Isolate* isolate);
298 299 300 301 302 303 304 305 306 307 308 309 310

  // Register this prefix hash for a streaming compilation job.
  // If the hash is not in the cache yet, the function returns true and the
  // caller owns the compilation of this module.
  // Otherwise another compilation job is currently preparing or has already
  // prepared a module with the same prefix hash. The caller should wait until
  // the stream is finished and call {MaybeGetNativeModule} to either get the
  // module from the cache or get ownership for the compilation of these bytes.
  bool GetStreamingCompilationOwnership(size_t prefix_hash);

  // Remove the prefix hash from the cache when compilation failed. If
  // compilation succeeded, {UpdateNativeModuleCache} should be called instead.
  void StreamingCompilationFailed(size_t prefix_hash);
311

312 313
  void FreeNativeModule(NativeModule*);

314 315 316 317 318
  // Sample the code size of the given {NativeModule} in all isolates that have
  // access to it. Call this after top-tier compilation finished.
  // This will spawn foreground tasks that do *not* keep the NativeModule alive.
  void SampleTopTierCodeSizeInAllIsolates(const std::shared_ptr<NativeModule>&);

319 320 321 322 323
  // Called by each Isolate to report its live code for a GC cycle. First
  // version reports an externally determined set of live code (might be empty),
  // second version gets live code from the execution stack of that isolate.
  void ReportLiveCodeForGC(Isolate*, Vector<WasmCode*>);
  void ReportLiveCodeFromStackForGC(Isolate*);
324

325 326 327 328 329 330 331
  // Add potentially dead code. The occurrence in the set of potentially dead
  // code counts as a reference, and is decremented on the next GC.
  // Returns {true} if the code was added to the set of potentially dead code,
  // {false} if an entry already exists. The ref count is *unchanged* in any
  // case.
  V8_WARN_UNUSED_RESULT bool AddPotentiallyDeadCode(WasmCode*);

332 333 334 335
  // Free dead code.
  using DeadCodeMap = std::unordered_map<NativeModule*, std::vector<WasmCode*>>;
  void FreeDeadCode(const DeadCodeMap&);
  void FreeDeadCodeLocked(const DeadCodeMap&);
336

337 338
  Handle<Script> GetOrCreateScript(Isolate*,
                                   const std::shared_ptr<NativeModule>&,
339 340
                                   Vector<const char> source_url = {});

341 342 343 344
  // Call on process start and exit.
  static void InitializeOncePerProcess();
  static void GlobalTearDown();

345 346 347
  // Returns a reference to the WasmEngine shared by the entire process. Try to
  // use {Isolate::wasm_engine} instead if it is available, which encapsulates
  // engine lifetime decisions during Isolate bootstrapping.
348 349
  static std::shared_ptr<WasmEngine> GetWasmEngine();

350
 private:
351
  struct CurrentGCInfo;
352
  struct IsolateInfo;
353
  struct NativeModuleInfo;
354

355
  AsyncCompileJob* CreateAsyncCompileJob(
356 357
      Isolate* isolate, const WasmFeatures& enabled,
      std::unique_ptr<byte[]> bytes_copy, size_t length,
358
      Handle<Context> context, const char* api_method_name,
359
      std::shared_ptr<CompilationResultResolver> resolver);
360

361
  void TriggerGC(int8_t gc_sequence_index);
362

363 364 365 366 367 368 369 370 371
  // Remove an isolate from the outstanding isolates of the current GC. Returns
  // true if the isolate was still outstanding, false otherwise. Hold {mutex_}
  // when calling this method.
  bool RemoveIsolateFromCurrentGC(Isolate*);

  // Finish a GC if there are no more outstanding isolates. Hold {mutex_} when
  // calling this method.
  void PotentiallyFinishCurrentGC();

372
  WasmCodeManager code_manager_;
373
  AccountingAllocator allocator_;
374

375 376 377 378
  // Task manager managing all background compile jobs. Before shut down of the
  // engine, they must all be finished because they access the allocator.
  CancelableTaskManager background_compile_task_manager_;

379 380 381 382 383
#ifdef V8_ENABLE_WASM_GDB_REMOTE_DEBUGGING
  // Implements a GDB-remote stub for WebAssembly debugging.
  std::unique_ptr<gdb_server::GdbServer> gdb_server_;
#endif  // V8_ENABLE_WASM_GDB_REMOTE_DEBUGGING

384 385 386 387 388 389 390
  // This mutex protects all information which is mutated concurrently or
  // fields that are initialized lazily on the first access.
  base::Mutex mutex_;

  //////////////////////////////////////////////////////////////////////////////
  // Protected by {mutex_}:

391 392
  // We use an AsyncCompileJob as the key for itself so that we can delete the
  // job from the map when it is finished.
393 394
  std::unordered_map<AsyncCompileJob*, std::unique_ptr<AsyncCompileJob>>
      async_compile_jobs_;
395

396 397 398
  std::unique_ptr<CompilationStatistics> compilation_stats_;
  std::unique_ptr<CodeTracer> code_tracer_;

399 400 401
  // Set of isolates which use this WasmEngine.
  std::unordered_map<Isolate*, std::unique_ptr<IsolateInfo>> isolates_;

402 403 404 405 406 407 408
  // Set of native modules managed by this engine.
  std::unordered_map<NativeModule*, std::unique_ptr<NativeModuleInfo>>
      native_modules_;

  // Size of code that became dead since the last GC. If this exceeds a certain
  // threshold, a new GC is triggered.
  size_t new_potentially_dead_code_size_ = 0;
409

410 411 412 413
  // If an engine-wide GC is currently running, this pointer stores information
  // about that.
  std::unique_ptr<CurrentGCInfo> current_gc_info_;

414
  NativeModuleCache native_module_cache_;
415

416 417 418
  // End of fields protected by {mutex_}.
  //////////////////////////////////////////////////////////////////////////////

419
  DISALLOW_COPY_AND_ASSIGN(WasmEngine);
420 421 422 423 424 425
};

}  // namespace wasm
}  // namespace internal
}  // namespace v8

426
#endif  // V8_WASM_WASM_ENGINE_H_