js/src/jit/IonCompileTask.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef jit_IonCompileTask_h
   8 #define jit_IonCompileTask_h
   9
  10 #include "mozilla/LinkedList.h"
  11
  12 #include "jit/MIRGenerator.h"
  13
  14 #include "js/Utility.h"
  15 #include "vm/HelperThreadTask.h"
  16
  17 struct JS_PUBLIC_API JSContext;
  18
  19 namespace js {
  20 namespace jit {
  21
  22 class CodeGenerator;
  23 class WarpSnapshot;
  24
  25 // IonCompileTask represents a single off-thread Ion compilation task.
  26 class IonCompileTask final : public HelperThreadTask,
  27                              public mozilla::LinkedListElement<IonCompileTask> {
  28   MIRGenerator& mirGen_;
  29
  30   // If off thread compilation is successful, the final code generator is
  31   // attached here. Code has been generated, but not linked (there is not yet
  32   // an IonScript). This is heap allocated, and must be explicitly destroyed,
  33   // performed by FinishOffThreadTask().
  34   CodeGenerator* backgroundCodegen_ = nullptr;
  35
  36   WarpSnapshot* snapshot_ = nullptr;
  37
  38   // Alias of the JSContext field of this task, to determine the priority of
  39   // compiling this script. Contexts are destroyed after the pending tasks are
  40   // removed from the helper threads. Thus this should be safe.
  41   const mozilla::Atomic<bool, mozilla::ReleaseAcquire>& isExecuting_;
  42
  43  public:
  44   explicit IonCompileTask(JSContext* cx, MIRGenerator& mirGen,
  45                           WarpSnapshot* snapshot);
  46
  47   JSScript* script() { return mirGen_.outerInfo().script(); }
  48   MIRGenerator& mirGen() { return mirGen_; }
  49   TempAllocator& alloc() { return mirGen_.alloc(); }
  50   WarpSnapshot* snapshot() { return snapshot_; }
  51
  52   size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf);
  53   void trace(JSTracer* trc);
  54
  55   CodeGenerator* backgroundCodegen() const { return backgroundCodegen_; }
  56   void setBackgroundCodegen(CodeGenerator* codegen) {
  57     backgroundCodegen_ = codegen;
  58   }
  59
  60   // Return whether the main thread which scheduled this task is currently
  61   // executing JS code. This changes the way we prioritize tasks.
  62   bool isMainThreadRunningJS() const { return isExecuting_; }
  63
  64   ThreadType threadType() override { return THREAD_TYPE_ION; }
  65   void runTask();
  66   void runHelperThreadTask(AutoLockHelperThreadState& locked) override;
  67 };
  68
  69 class IonFreeTask : public HelperThreadTask {
  70   IonFreeCompileTasks tasks_;
  71
  72  public:
  73   explicit IonFreeTask(IonFreeCompileTasks&& tasks) : tasks_(std::move(tasks)) {
  74     MOZ_ASSERT(!tasks_.empty());
  75   }
  76
  77   const IonFreeCompileTasks& compileTasks() const { return tasks_; }
  78
  79   ThreadType threadType() override { return THREAD_TYPE_ION_FREE; }
  80   void runHelperThreadTask(AutoLockHelperThreadState& locked) override;
  81 };
  82
  83 void AttachFinishedCompilations(JSContext* cx);
  84 void FinishOffThreadTask(JSRuntime* runtime, AutoStartIonFreeTask& freeTask,
  85                          IonCompileTask* task);
  86 void FreeIonCompileTasks(const IonFreeCompileTasks& tasks);
  87
  88 }  // namespace jit
  89 }  // namespace js
  90
  91 #endif /* jit_IonCompileTask_h */