{

static V8Platform& GetInstance();

void EnsureInitialized();

V8GlobalFlags GetGlobalFlags() const;

virtual int NumberOfWorkerThreads() override;

virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(v8::Isolate* pIsolate) override;

virtual void CallOnWorkerThread(std::unique_ptr<v8::Task> upTask) override;

virtual void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> upTask, double delayInSeconds) override;

virtual std::unique_ptr<v8::JobHandle> PostJob(v8::TaskPriority priority, std::unique_ptr<v8::JobTask> upJobTask) override;

virtual double MonotonicallyIncreasingTime() override;

virtual double CurrentClockTimeMillis() override;

virtual v8::TracingController* GetTracingController() override;

V8Platform();

static V8Platform ms_Instance;

OnceFlag m_InitializationFlag;

V8GlobalFlags m_GlobalFlags;

v8::TracingController m_TracingController;

{

m_InitializationFlag.CallOnce([this]

{

v8::V8::InitializePlatform(&ms_Instance);

ASSERT_EVAL(v8::V8::Initialize());

m_GlobalFlags = V8_SPLIT_PROXY_MANAGED_INVOKE_NOTHROW(V8GlobalFlags, GetGlobalFlags);

std::vector<std::string> flagStrings;

#ifdef CLEARSCRIPT_TOP_LEVEL_AWAIT_CONTROL

if (!HasFlag(globalFlags, V8GlobalFlags::EnableTopLevelAwait))

{

flagStrings.push_back("--no_harmony_top_level_await");

}

#endif // CLEARSCRIPT_TOP_LEVEL_AWAIT_CONTROL

#if defined(__APPLE__) && defined(__arm64__)

// WORKAROUND: On Apple M1 only, our lone WebAssembly test crashes consistently unless this

// option is disabled. The crash is indicative of corruption within the SplitProxyManaged

// pointer table or of its address in thread-local storage.

flagStrings.push_back("--no_wasm_async_compilation");

#endif // defined(__APPLE__) && defined(__arm64__)

if (HasFlag(m_GlobalFlags, V8GlobalFlags::DisableJITCompilation))

{

flagStrings.push_back("--jitless");

}

if (HasFlag(m_GlobalFlags, V8GlobalFlags::DisableBackgroundWork))

{

flagStrings.push_back("--single_threaded");

}

if (!flagStrings.empty())

{

std::string flagsString(flagStrings[0]);

for (size_t index = 1; index < flagStrings.size(); index++)

{

flagsString += " ";

flagsString += flagStrings[index];

}

v8::V8::SetFlagsFromString(flagsString.c_str(), flagsString.length());

}

});

{

auto pIsolate = v8::Isolate::GetCurrent();

if (pIsolate == nullptr)

{

upTask->Run();

}

else

{

V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->RunTaskAsync(std::move(upTask));

}

{

auto pIsolate = v8::Isolate::GetCurrent();

if (pIsolate != nullptr)

{

V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->RunTaskDelayed(std::move(upTask), delayInSeconds);

}

{

PROHIBIT_COPY(V8ForegroundTaskRunner)

V8ForegroundTaskRunner(V8IsolateImpl& isolateImpl);

virtual void PostTask(std::unique_ptr<v8::Task> upTask) override;

virtual void PostNonNestableTask(std::unique_ptr<v8::Task> upTask) override;

virtual void PostDelayedTask(std::unique_ptr<v8::Task> upTask, double delayInSeconds) override;

virtual void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> upTask, double delayInSeconds) override;

virtual void PostIdleTask(std::unique_ptr<v8::IdleTask> upTask) override;

virtual bool IdleTasksEnabled() override;

virtual bool NonNestableTasksEnabled() const override;

virtual bool NonNestableDelayedTasksEnabled() const override;

V8IsolateImpl& m_IsolateImpl;

WeakRef<V8Isolate> m_wrIsolate;

m_IsolateImpl(isolateImpl),

m_wrIsolate(isolateImpl.CreateWeakRef())

{

{

auto spIsolate = m_wrIsolate.GetTarget();

if (spIsolate.IsEmpty())

{

upTask->Run();

}

else

{

m_IsolateImpl.RunTaskWithLockAsync(true /*allowNesting*/, std::move(upTask));

}

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_IsolateImpl.RunTaskWithLockAsync(false /*allowNesting*/, std::move(upTask));

}

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_IsolateImpl.RunTaskWithLockDelayed(true /*allowNesting*/, std::move(upTask), delayInSeconds);

}

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_IsolateImpl.RunTaskWithLockDelayed(false /*allowNesting*/, std::move(upTask), delayInSeconds);

}

{

// unexpected call to unsupported method

std::terminate();

{

V8ArrayBufferAllocator(V8IsolateImpl& isolateImpl);

virtual void* Allocate(size_t size) override;

virtual void* AllocateUninitialized(size_t size) override;

virtual void Free(void* pvData, size_t size) override;

V8IsolateImpl& m_IsolateImpl;

WeakRef<V8Isolate> m_wrIsolate;

m_IsolateImpl(isolateImpl),

m_wrIsolate(isolateImpl.CreateWeakRef())

{

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_IsolateImpl.FreeArrayBuffer(pvData, size);

}

else if (pvData)

{

::free(pvData);

}

{

PROHIBIT_COPY(V8OutputStream)

explicit V8OutputStream(void* pvStream):

m_pvStream(pvStream)

{

}

virtual int GetChunkSize() override;

virtual WriteResult WriteAsciiChunk(char* pData, int size) override;

virtual void EndOfStream() override;

void* m_pvStream;

{

try

{

V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(WriteBytesToStream, m_pvStream, reinterpret_cast<uint8_t*>(pData), size);

return kContinue;

}

catch (const HostException& exception)

{

V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(ScheduleForwardingException, exception.GetException());

return kAbort;

}

m_Name(name),

m_CallWithLockLevel(0),

m_DebuggingEnabled(false),

m_MaxArrayBufferAllocation(options.MaxArrayBufferAllocation),

m_ArrayBufferAllocation(0),

m_MaxHeapSize(0),

m_HeapSizeSampleInterval(0.0),

m_HeapWatchLevel(0),

m_HeapExpansionMultiplier(options.HeapExpansionMultiplier),

m_MaxStackUsage(0),

m_EnableInterruptPropagation(false),

m_DisableHeapSizeViolationInterrupt(false),

m_CpuProfileSampleInterval(1000U),

m_StackWatchLevel(0),

m_pStackLimit(nullptr),

m_pExecutionScope(nullptr),

m_pDocumentInfo(nullptr),

m_IsOutOfMemory(false),

m_IsExecutionTerminating(false),

m_Released(false)

{

V8Platform::GetInstance().EnsureInitialized();

m_upIsolate.reset(v8::Isolate::Allocate());

m_upIsolate->SetData(0, this);

BEGIN_ADDREF_SCOPE

v8::Isolate::CreateParams params;

params.array_buffer_allocator_shared = std::make_shared<V8ArrayBufferAllocator>(*this);

if (pConstraints != nullptr)

{

params.constraints.set_max_young_generation_size_in_bytes(pConstraints->max_young_generation_size_in_bytes());

params.constraints.set_max_old_generation_size_in_bytes(pConstraints->max_old_generation_size_in_bytes());

}

v8::Isolate::Initialize(m_upIsolate.get(), params);

m_upIsolate->AddNearHeapLimitCallback(HeapExpansionCallback, this);

m_upIsolate->AddBeforeCallEnteredCallback(OnBeforeCallEntered);

BEGIN_ISOLATE_SCOPE

m_upIsolate->SetCaptureStackTraceForUncaughtExceptions(true, 64, v8::StackTrace::kDetailed);

m_hHostObjectHolderKey = CreatePersistent(CreatePrivate());

if (options.EnableDebugging)

{

EnableDebugging(options.DebugPort, options.EnableRemoteDebugging);

}

m_upIsolate->SetHostInitializeImportMetaObjectCallback(ImportMetaInitializeCallback);

if (options.EnableDynamicModuleImports)

{

m_upIsolate->SetHostImportModuleDynamicallyCallback(ModuleImportCallback);

}

END_ISOLATE_SCOPE

END_ADDREF_SCOPE

++s_InstanceCount;

{

_ASSERTE(IsCurrent() && IsLocked());

if (!options.EnableDebugging)

{

m_ContextEntries.emplace_back(pContextImpl);

}

else

{

m_ContextEntries.emplace_front(pContextImpl);

EnableDebugging(options.DebugPort, options.EnableRemoteDebugging);

}

if (options.EnableDynamicModuleImports)

{

m_upIsolate->SetHostImportModuleDynamicallyCallback(ModuleImportCallback);

}

if (m_upInspector)

{

m_upInspector->contextCreated(v8_inspector::V8ContextInfo(pContextImpl->GetContext(), s_ContextGroupId, pContextImpl->GetName().GetStringView()));

}

{

_ASSERTE(IsCurrent() && IsLocked());

if (m_upInspector)

{

m_upInspector->contextDestroyed(pContextImpl->GetContext());

}

m_ContextEntries.remove_if([pContextImpl] (const ContextEntry& contextEntry)

{

return contextEntry.pContextImpl == pContextImpl;

});

{

_ASSERTE(IsCurrent() && IsLocked());

if (!m_DebuggingEnabled)

{

const char* pVersion = v8::V8::GetVersion();

StdString version(v8_inspector::StringView(reinterpret_cast<const uint8_t*>(pVersion), strlen(pVersion)));

if (port < 1)

{

port = 9222;

}

auto wrIsolate = CreateWeakRef();

m_pvDebugAgent = HostObjectUtil::GetInstance().CreateDebugAgent(m_Name, version, port, remote, [this, wrIsolate] (IHostObjectUtil::DebugDirective directive, const StdString* pCommand)

{

auto spIsolate = wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

if (directive == IHostObjectUtil::DebugDirective::ConnectClient)

{

ConnectDebugClient();

}

else if ((directive == IHostObjectUtil::DebugDirective::SendCommand) && pCommand)

{

SendDebugCommand(*pCommand);

}

else if (directive == IHostObjectUtil::DebugDirective::DisconnectClient)

{

DisconnectDebugClient();

}

}

});

m_upInspector = v8_inspector::V8Inspector::create(m_upIsolate.get(), this);

m_DebuggingEnabled = true;

m_DebugPort = port;

}

{

_ASSERTE(IsCurrent() && IsLocked());

if (m_DebuggingEnabled)

{

m_upInspectorSession.reset();

m_upInspector.reset();

HostObjectUtil::GetInstance().DestroyDebugAgent(m_pvDebugAgent);

m_DebuggingEnabled = false;

}

{

m_MaxHeapSize = value;

m_IsOutOfMemory = false;

{

BEGIN_ISOLATE_SCOPE

if (m_DebuggingEnabled)

{

if (!m_upInspectorSession)

{

auto exitReason = RunMessageLoop(RunMessageLoopReason::AwaitingDebugger);

switch (exitReason)

{

case ExitMessageLoopReason::TerminatedExecution:

throw V8Exception(V8Exception::Type::Interrupt, m_Name, StdString(SL("Script execution interrupted by host while awaiting debugger connection")), false);

case ExitMessageLoopReason::CanceledAwaitDebugger:

return;

default:

_ASSERTE(exitReason == ExitMessageLoopReason::ResumedExecution);

}

}

_ASSERTE(m_upInspectorSession);

if (m_upInspectorSession)

{

StdString breakReason(SL("Break on debugger connection"));

m_upInspectorSession->schedulePauseOnNextStatement(breakReason.GetStringView(), breakReason.GetStringView());

}

}

END_ISOLATE_SCOPE

{

BEGIN_MUTEX_SCOPE(m_DataMutex)

if (m_optRunMessageLoopReason == RunMessageLoopReason::AwaitingDebugger)

{

m_optExitMessageLoopReason = ExitMessageLoopReason::CanceledAwaitDebugger;

m_CallWithLockQueueChanged.notify_one();

}

END_MUTEX_SCOPE

{

BEGIN_ISOLATE_SCOPE

m_upIsolate->GetHeapStatistics(&heapStatistics);

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

BEGIN_MUTEX_SCOPE(m_DataMutex)

return m_Statistics;

END_MUTEX_SCOPE

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (exhaustive)

{

ClearScriptCache();

LowMemoryNotification();

}

else

{

while (!IdleNotificationDeadline(V8Platform::GetInstance().MonotonicallyIncreasingTime() + 0.1));

{

BEGIN_ISOLATE_SCOPE

if (!m_upCpuProfiler)

{

m_upCpuProfiler.reset(v8::CpuProfiler::New(m_upIsolate.get()));

}

v8::Local<v8::String> hName;

if (!CreateString(name).ToLocal(&hName))

{

return false;

}

m_upCpuProfiler->StartProfiling(hName, mode, recordSamples);

return true;

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (!m_upCpuProfiler)

{

return false;

}

v8::Local<v8::String> hName;

if (!CreateString(name).ToLocal(&hName))

{

return false;

}

UniqueDeletePtr<v8::CpuProfile> upProfile(m_upCpuProfiler->StopProfiling(hName));

if (!upProfile)

{

return false;

}

if (pCallback)

{

pCallback(*upProfile, pvArg);

}

return true;

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

v8::CpuProfiler::CollectSample(m_upIsolate.get());

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (value != m_CpuProfileSampleInterval)

{

m_CpuProfileSampleInterval = std::min(std::max(value, 125U), static_cast<uint32_t>(INT_MAX));

if (!m_upCpuProfiler)

{

m_upCpuProfiler.reset(v8::CpuProfiler::New(m_upIsolate.get()));

}

m_upCpuProfiler->SetSamplingInterval(static_cast<int>(m_CpuProfileSampleInterval));

}

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

auto pSnapshot = m_upIsolate->GetHeapProfiler()->TakeHeapSnapshot();

V8OutputStream stream(pvStream);

pSnapshot->Serialize(&stream);

const_cast<v8::HeapSnapshot*>(pSnapshot)->Delete();

END_ISOLATE_SCOPE

{

_ASSERTE(IsCurrent() && IsLocked());

BEGIN_MUTEX_SCOPE(m_DataMutex)

m_optExitMessageLoopReason = ExitMessageLoopReason::ResumedExecution;

END_MUTEX_SCOPE