lazy-compile-dispatcher.cc | Explore in Territory

// 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.

#include "src/compiler-dispatcher/lazy-compile-dispatcher.h"

#include <atomic>

#include "include/v8-platform.h"
#include "src/base/platform/mutex.h"
#include "src/base/platform/time.h"
#include "src/codegen/compiler.h"
#include "src/common/globals.h"
#include "src/execution/isolate.h"
#include "src/flags/flags.h"
#include "src/heap/parked-scope.h"
#include "src/logging/counters.h"
#include "src/logging/runtime-call-stats-scope.h"
#include "src/objects/instance-type.h"
#include "src/objects/objects-inl.h"
#include "src/parsing/parse-info.h"
#include "src/parsing/scanner.h"
#include "src/tasks/cancelable-task.h"
#include "src/tasks/task-utils.h"
#include "src/zone/zone-list-inl.h"  // crbug.com/v8/8816

namespace v8 {
namespace internal {

// The maximum amount of time we should allow a single function's FinishNow to
// spend opportunistically finalizing other finalizable jobs.
static constexpr int kMaxOpportunisticFinalizeTimeMs = …;

class LazyCompileDispatcher::JobTask : public v8::JobTask { … };

LazyCompileDispatcher::Job::Job(std::unique_ptr<BackgroundCompileTask> task)
    : … { … }

LazyCompileDispatcher::Job::~Job() = default;

LazyCompileDispatcher::LazyCompileDispatcher(Isolate* isolate,
                                             Platform* platform,
                                             size_t max_stack_size)
    : … { … }

LazyCompileDispatcher::~LazyCompileDispatcher() { … }

namespace {

// If the SharedFunctionInfo's UncompiledData has a job slot, then write into
// it. Otherwise, allocate a new UncompiledData with a job slot, and then write
// into that. Since we have two optional slots (preparse data and job), this
// gets a little messy.
void SetUncompiledDataJobPointer(LocalIsolate* isolate,
                                 DirectHandle<SharedFunctionInfo> shared_info,
                                 Address job_address) { … }

}  // namespace

void LazyCompileDispatcher::Enqueue(
    LocalIsolate* isolate, Handle<SharedFunctionInfo> shared_info,
    std::unique_ptr<Utf16CharacterStream> character_stream) { … }

bool LazyCompileDispatcher::IsEnqueued(
    DirectHandle<SharedFunctionInfo> shared) const { … }

void LazyCompileDispatcher::WaitForJobIfRunningOnBackground(
    Job* job, const base::MutexGuard& lock) { … }

bool LazyCompileDispatcher::FinishNow(
    DirectHandle<SharedFunctionInfo> function) { … }

void LazyCompileDispatcher::AbortJob(
    DirectHandle<SharedFunctionInfo> shared_info) { … }

void LazyCompileDispatcher::AbortAll() { … }

LazyCompileDispatcher::Job* LazyCompileDispatcher::GetJobFor(
    DirectHandle<SharedFunctionInfo> shared, const base::MutexGuard&) const { … }

void LazyCompileDispatcher::ScheduleIdleTaskFromAnyThread(
    const base::MutexGuard&) { … }

void LazyCompileDispatcher::DoBackgroundWork(JobDelegate* delegate) { … }

LazyCompileDispatcher::Job* LazyCompileDispatcher::PopSingleFinalizeJob() { … }

bool LazyCompileDispatcher::FinalizeSingleJob() { … }

void LazyCompileDispatcher::DoIdleWork(double deadline_in_seconds) { … }

void LazyCompileDispatcher::DeleteJob(Job* job) { … }

void LazyCompileDispatcher::DeleteJob(Job* job, const base::MutexGuard&) { … }

#ifdef DEBUG
void LazyCompileDispatcher::VerifyBackgroundTaskCount(const base::MutexGuard&) { … }
#endif

}  // namespace internal
}  // namespace v8
chromium/v8/src/compiler-dispatcher/lazy-compile-dispatcher.cc
