AuroraRuntime/Source/Async/AsyncApp.cpp
2022-04-02 01:48:29 +01:00

208 lines
4.7 KiB
C++

/***
Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.
File: AsyncApp.cpp
Date: 2021-6-26
Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include "Async.hpp"
#include "AsyncApp.hpp"
#include "WorkItem.hpp"
#include "Schedular.hpp"
#include <Source/Console/Commands/Commands.hpp>
namespace Aurora::Async
{
static AsyncApp *gAsyncApp;
static AuSPtr<AsyncApp> gAsyncAppMem;
void InitApp()
{
gAsyncAppMem = AuMakeShared<AsyncApp>();
gAsyncApp = gAsyncAppMem.get();
}
void ReleaseApp()
{
gAsyncAppMem->Shutdown();
gAsyncAppMem.reset();
}
void AsyncApp::Start()
{
ThreadPool::SetRunningMode(true);
SysAssert(ThreadPool::Create({0, 0}));
StartSched(); // this is now an init once function
}
void AsyncApp::Main()
{
ThreadPool::Entrypoint({0, 0});
}
void AsyncApp::SetConsoleCommandDispatcher(WorkerId_t id)
{
commandDispatcher_ = id;
Console::Commands::UpdateDispatcher(commandDispatcher_);
}
void AsyncApp::CleanUpWorker(WorkerId_t id)
{
// This shouldn't be a problem; however, we're going to handle the one edge case where
// some angry sysadmin is spamming commands
if ((commandDispatcher_.has_value())
&& (commandDispatcher_.value() == id))
{
Console::Commands::UpdateDispatcher({});
}
}
void AsyncApp::CleanWorkerPoolReservedZeroFree()
{
// TODO: this is a hack. we need to reference count
DeinitSched();
ThreadPool::Shutdown();
}
AUKN_SYM IAsyncApp *GetAsyncApp()
{
return gAsyncApp;
}
AUKN_SYM AuSPtr<IAsyncApp> GetSharedAsyncApp()
{
return AuUnsafeRaiiToShared(gAsyncApp);
}
bool AsyncApp::Spawn(WorkerId_t workerId)
{
return ThreadPool::Spawn(workerId);
}
void AsyncApp::SetRunningMode(bool eventRunning)
{
ThreadPool::SetRunningMode(eventRunning);
}
bool AsyncApp::Create(WorkerId_t workerId)
{
return ThreadPool::Create(workerId);
}
bool AsyncApp::InRunnerMode()
{
return ThreadPool::InRunnerMode();
}
bool AsyncApp::Poll()
{
return ThreadPool::Poll();
}
bool AsyncApp::RunOnce()
{
return ThreadPool::RunOnce();
}
bool AsyncApp::Run()
{
return ThreadPool::Run();
}
void AsyncApp::Shutdown()
{
ThreadPool::Shutdown();
}
bool AsyncApp::Exiting()
{
return ThreadPool::Exiting();
}
AuSPtr<IWorkItem> AsyncApp::NewWorkItem(const WorkerId_t &worker, const AuSPtr<IWorkItemHandler> &task, bool supportsBlocking)
{
return ThreadPool::NewWorkItem(worker, task, supportsBlocking);
}
AuSPtr<IWorkItem> AsyncApp::NewFence()
{
return ThreadPool::NewFence();
}
Threading::Threads::ThreadShared_t AsyncApp::ResolveHandle(WorkerId_t id)
{
return ThreadPool::ResolveHandle(id);
}
AuBST<ThreadGroup_t, AuList<ThreadId_t>> AsyncApp::GetThreads()
{
return ThreadPool::GetThreads();
}
WorkerId_t AsyncApp::GetCurrentThread()
{
return ThreadPool::GetCurrentThread();
}
bool AsyncApp::Sync(WorkerId_t workerId, AuUInt32 timeoutMs, bool requireSignal)
{
return ThreadPool::Sync(workerId, timeoutMs, requireSignal);
}
AuSPtr<Loop::ILoopSource> AsyncApp::WorkerToLoopSource(WorkerId_t id)
{
return ThreadPool::WorkerToLoopSource(id);
}
void AsyncApp::Signal(WorkerId_t workerId)
{
ThreadPool::Signal(workerId);
}
void AsyncApp::SyncAllSafe()
{
ThreadPool::SyncAllSafe();
}
void AsyncApp::AddFeature(WorkerId_t id, AuSPtr<Threading::Threads::IThreadFeature> feature, bool async)
{
ThreadPool::AddFeature(id, feature, async);
}
void AsyncApp::AssertInThreadGroup(ThreadGroup_t group)
{
ThreadPool::AssertInThreadGroup(group);
}
void AsyncApp::AssertWorker(WorkerId_t id)
{
ThreadPool::AssertWorker(id);
}
AuSPtr<Loop::ILoopQueue> AsyncApp::ToKernelWorkQueue()
{
return ThreadPool::ToKernelWorkQueue();
}
AuSPtr<Loop::ILoopQueue> AsyncApp::ToKernelWorkQueue(WorkerId_t workerId)
{
return ThreadPool::ToKernelWorkQueue(workerId);
}
void AsyncApp::UpdateWorkMode(WorkerId_t workerId, RunMode mode)
{
ThreadPool::UpdateWorkMode(workerId, mode);
}
ERunMode AsyncApp::GetCurrentThreadRunMode()
{
return ThreadPool::GetCurrentThreadRunMode();
}
ERunMode AsyncApp::GetThreadRunMode(WorkerId_t workerId)
{
return ThreadPool::GetThreadRunMode(workerId);
}
}