#include "config.h"
#include "JITWorklist.h"
#if ENABLE(JIT)
#include "JIT.h"
#include "VMInlines.h"
namespace JSC {
class JITWorklist::Plan : public ThreadSafeRefCounted<JITWorklist::Plan> {
public:
Plan(CodeBlock* codeBlock, BytecodeIndex loopOSREntryBytecodeIndex)
: m_codeBlock(codeBlock)
, m_jit(codeBlock->vm(), codeBlock, loopOSREntryBytecodeIndex)
{
m_jit.doMainThreadPreparationBeforeCompile();
}
void compileInThread()
{
m_jit.compileWithoutLinking(JITCompilationCanFail);
LockHolder locker(m_lock);
m_isFinishedCompiling = true;
}
void finalize()
{
CompilationResult result = m_jit.link();
switch (result) {
case CompilationFailed:
CODEBLOCK_LOG_EVENT(m_codeBlock, "delayJITCompile", ("compilation failed"));
dataLogLnIf(Options::verboseOSR(), " JIT compilation failed.");
m_codeBlock->dontJITAnytimeSoon();
m_codeBlock->m_didFailJITCompilation = true;
return;
case CompilationSuccessful:
dataLogLnIf(Options::verboseOSR(), " JIT compilation successful.");
m_codeBlock->ownerExecutable()->installCode(m_codeBlock);
m_codeBlock->jitSoon();
return;
default:
RELEASE_ASSERT_NOT_REACHED();
return;
}
}
CodeBlock* codeBlock() { return m_codeBlock; }
VM& vm() { return m_codeBlock->vm(); }
bool isFinishedCompiling()
{
LockHolder locker(m_lock);
return m_isFinishedCompiling;
}
static void compileNow(CodeBlock* codeBlock, BytecodeIndex loopOSREntryBytecodeIndex)
{
Plan plan(codeBlock, loopOSREntryBytecodeIndex);
plan.compileInThread();
plan.finalize();
}
private:
CodeBlock* m_codeBlock;
JIT m_jit;
Lock m_lock;
bool m_isFinishedCompiling { false };
};
class JITWorklist::Thread final : public AutomaticThread {
public:
Thread(const AbstractLocker& locker, JITWorklist& worklist)
: AutomaticThread(locker, worklist.m_lock, worklist.m_condition.copyRef())
, m_worklist(worklist)
{
m_worklist.m_numAvailableThreads++;
}
const char* name() const final
{
#if OS(LINUX)
return "JITWorker";
#else
return "JIT Worklist Helper Thread";
#endif
}
private:
PollResult poll(const AbstractLocker&) final
{
RELEASE_ASSERT(m_worklist.m_numAvailableThreads);
if (m_worklist.m_queue.isEmpty())
return PollResult::Wait;
m_myPlans = WTFMove(m_worklist.m_queue);
m_worklist.m_numAvailableThreads--;
return PollResult::Work;
}
WorkResult work() final
{
RELEASE_ASSERT(!m_myPlans.isEmpty());
for (RefPtr<Plan>& plan : m_myPlans) {
plan->compileInThread();
plan = nullptr;
LockHolder locker(*m_worklist.m_lock);
m_worklist.m_condition->notifyAll(locker);
}
m_myPlans.clear();
LockHolder locker(*m_worklist.m_lock);
m_worklist.m_numAvailableThreads++;
return WorkResult::Continue;
}
JITWorklist& m_worklist;
Plans m_myPlans;
};
JITWorklist::JITWorklist()
: m_lock(Box<Lock>::create())
, m_condition(AutomaticThreadCondition::create())
{
LockHolder locker(*m_lock);
m_thread = new Thread(locker, *this);
}
JITWorklist::~JITWorklist()
{
UNREACHABLE_FOR_PLATFORM();
}
bool JITWorklist::completeAllForVM(VM& vm)
{
bool result = false;
DeferGC deferGC(vm.heap);
for (;;) {
Vector<RefPtr<Plan>, 32> myPlans;
{
LockHolder locker(*m_lock);
for (;;) {
bool didFindUnfinishedPlan = false;
m_plans.removeAllMatching(
[&] (RefPtr<Plan>& plan) {
if (&plan->vm() != &vm)
return false;
if (!plan->isFinishedCompiling()) {
didFindUnfinishedPlan = true;
return false;
}
myPlans.append(WTFMove(plan));
return true;
});
if (!myPlans.isEmpty())
break;
if (!didFindUnfinishedPlan)
return result;
m_condition->wait(*m_lock);
}
}
RELEASE_ASSERT(!myPlans.isEmpty());
result = true;
finalizePlans(myPlans);
}
}
void JITWorklist::poll(VM& vm)
{
DeferGC deferGC(vm.heap);
Plans myPlans;
{
LockHolder locker(*m_lock);
m_plans.removeAllMatching(
[&] (RefPtr<Plan>& plan) {
if (&plan->vm() != &vm)
return false;
if (!plan->isFinishedCompiling())
return false;
myPlans.append(WTFMove(plan));
return true;
});
}
finalizePlans(myPlans);
}
void JITWorklist::compileLater(CodeBlock* codeBlock, BytecodeIndex loopOSREntryBytecodeIndex)
{
DeferGC deferGC(codeBlock->vm().heap);
RELEASE_ASSERT(codeBlock->jitType() == JITType::InterpreterThunk);
if (codeBlock->m_didFailJITCompilation) {
codeBlock->dontJITAnytimeSoon();
return;
}
if (!Options::useConcurrentJIT()) {
Plan::compileNow(codeBlock, loopOSREntryBytecodeIndex);
return;
}
codeBlock->jitSoon();
{
LockHolder locker(*m_lock);
if (m_planned.contains(codeBlock))
return;
if (m_numAvailableThreads) {
m_planned.add(codeBlock);
RefPtr<Plan> plan = adoptRef(new Plan(codeBlock, loopOSREntryBytecodeIndex));
m_plans.append(plan);
m_queue.append(plan);
m_condition->notifyAll(locker);
return;
}
}
Plan::compileNow(codeBlock, loopOSREntryBytecodeIndex);
}
void JITWorklist::compileNow(CodeBlock* codeBlock, BytecodeIndex loopOSREntryBytecodeIndex)
{
VM& vm = codeBlock->vm();
DeferGC deferGC(vm.heap);
if (codeBlock->jitType() != JITType::InterpreterThunk)
return;
bool isPlanned;
{
LockHolder locker(*m_lock);
isPlanned = m_planned.contains(codeBlock);
}
if (isPlanned) {
RELEASE_ASSERT(Options::useConcurrentJIT());
completeAllForVM(vm);
}
if (codeBlock->jitType() != JITType::InterpreterThunk)
return;
codeBlock->resetJITData();
JIT::compile(vm, codeBlock, JITCompilationMustSucceed, loopOSREntryBytecodeIndex);
codeBlock->ownerExecutable()->installCode(codeBlock);
}
void JITWorklist::finalizePlans(Plans& myPlans)
{
for (RefPtr<Plan>& plan : myPlans) {
plan->finalize();
LockHolder locker(*m_lock);
m_planned.remove(plan->codeBlock());
}
}
static JITWorklist* theGlobalJITWorklist { nullptr };
JITWorklist* JITWorklist::existingGlobalWorklistOrNull()
{
return theGlobalJITWorklist;
}
JITWorklist& JITWorklist::ensureGlobalWorklist()
{
static std::once_flag once;
std::call_once(
once,
[] {
auto* worklist = new JITWorklist();
WTF::storeStoreFence();
theGlobalJITWorklist = worklist;
});
return *theGlobalJITWorklist;
}
}
#endif // ENABLE(JIT)