AuroraRuntime/Source/Async/WorkItem.cpp

404 lines
9.2 KiB
C++
Raw Normal View History

/***
Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.
File: WorkItem.cpp
Date: 2021-6-26
Author: Reece
***/
2021-09-30 14:57:41 +00:00
#include <Source/RuntimeInternal.hpp>
2021-06-30 09:28:52 +00:00
#include "Async.hpp"
2021-06-27 21:25:29 +00:00
#include "WorkItem.hpp"
2021-06-30 09:28:52 +00:00
#include "AsyncApp.hpp"
2021-06-30 12:00:32 +00:00
#include "Schedular.hpp"
2021-06-27 21:25:29 +00:00
namespace Aurora::Async
{
WorkItem::WorkItem(IThreadPoolInternal *owner, const WorkerId_t &worker, const AuSPtr<IWorkItemHandler> &task, bool supportsBlocking) : worker_(worker), task_(task), owner_(owner)
2021-06-27 21:25:29 +00:00
{
if (supportsBlocking)
{
this->finishedEvent_ = AuThreadPrimitives::EventUnique(false, true, true);
SysAssert(this->finishedEvent_);
2021-06-27 21:25:29 +00:00
}
}
WorkItem::~WorkItem()
{
2021-06-30 09:28:52 +00:00
//Fail();
2021-06-27 21:25:29 +00:00
}
AuSPtr<IWorkItem> WorkItem::WaitFor(const AuSPtr<IWorkItem> &workItem)
2021-06-27 21:25:29 +00:00
{
bool status {};
2021-06-27 21:25:29 +00:00
{
auto dependency = AuReinterpretCast<WorkItem>(workItem);
AU_LOCK_GUARD(this->lock);
2021-09-06 10:58:08 +00:00
AU_LOCK_GUARD(dependency->lock);
if (dependency->HasFailed())
{
status = true;
}
2021-06-27 21:25:29 +00:00
dependency->waiters_.push_back(shared_from_this());
this->waitOn_.push_back(workItem);
2021-06-27 21:25:29 +00:00
}
if (status)
{
Fail();
}
return AU_SHARED_FROM_THIS;
}
2021-07-12 14:37:05 +00:00
AuSPtr<IWorkItem> WorkItem::WaitFor(const AuList<AuSPtr<IWorkItem>> &workItems)
{
bool status {};
{
AU_LOCK_GUARD(this->lock);
for (auto &workItem : workItems)
{
auto dependency = AuReinterpretCast<WorkItem>(workItem);
2021-09-06 10:58:08 +00:00
AU_LOCK_GUARD(dependency->lock);
if (dependency->HasFailed())
{
status = true;
}
dependency->waiters_.push_back(shared_from_this());
this->waitOn_.push_back(workItem);
}
}
if (status)
{
Fail();
}
return AU_SHARED_FROM_THIS;
2021-06-27 21:25:29 +00:00
}
2021-07-12 14:37:05 +00:00
AuSPtr<IWorkItem> WorkItem::Then(const AuSPtr<IWorkItem> &next)
{
auto that = AU_SHARED_FROM_THIS;
next->WaitFor(that);
next->Dispatch();
return that;
}
2021-06-30 12:00:32 +00:00
AuSPtr<IWorkItem> WorkItem::SetSchedTimeNs(AuUInt64 ns)
2021-06-30 12:00:32 +00:00
{
this->dispatchTimeNs_ = Time::CurrentClockNS() + ns;
return AU_SHARED_FROM_THIS;
}
AuSPtr<IWorkItem> WorkItem::SetSchedTimeAbs(AuUInt32 ms)
{
this->dispatchTimeNs_ = AuUInt64(ms) * AuUInt64(1000000);
return AU_SHARED_FROM_THIS;
}
AuSPtr<IWorkItem> WorkItem::SetSchedTimeNsAbs(AuUInt64 ns)
{
this->dispatchTimeNs_ = ns;
return AU_SHARED_FROM_THIS;
2021-06-30 12:00:32 +00:00
}
AuSPtr<IWorkItem> WorkItem::SetSchedTime(AuUInt32 ms)
2021-06-27 21:25:29 +00:00
{
this->dispatchTimeNs_ = Time::CurrentClockNS() + (AuUInt64(ms) * AuUInt64(1000000));
return AU_SHARED_FROM_THIS;
2021-06-27 21:25:29 +00:00
}
AuSPtr<IWorkItem> WorkItem::AddDelayTime(AuUInt32 ms)
{
this->delayTimeNs_ += AuUInt64(ms) * AuUInt64(1000000);
return AU_SHARED_FROM_THIS;
}
AuSPtr<IWorkItem> WorkItem::AddDelayTimeNs(AuUInt64 ns)
{
this->delayTimeNs_ += ns;
return AU_SHARED_FROM_THIS;
}
2021-06-27 21:25:29 +00:00
AuSPtr<IWorkItem> WorkItem::Dispatch()
2021-06-27 21:25:29 +00:00
{
DispatchEx(false);
return AU_SHARED_FROM_THIS;
2021-06-27 21:25:29 +00:00
}
void WorkItem::DispatchEx(bool check)
{
2021-09-06 10:58:08 +00:00
AU_LOCK_GUARD(lock);
2021-06-27 21:25:29 +00:00
if (check)
{
if (this->dispatchPending_)
2021-06-27 21:25:29 +00:00
{
return;
}
}
if (HasFailed())
{
return;
}
2021-06-27 21:25:29 +00:00
for (auto itr = waitOn_.begin(); itr != waitOn_.end(); )
{
auto &waitable = *itr;
if (!waitable->HasFinished())
{
return;
}
itr = waitOn_.erase(itr);
}
this->dispatchPending_ = true;
2021-09-06 10:58:08 +00:00
if (Time::CurrentClockNS() < this->dispatchTimeNs_)
{
Schedule();
return;
}
2022-01-19 17:08:13 +00:00
if (auto delay = AuExchange(delayTimeNs_, {}))
2021-06-27 21:25:29 +00:00
{
this->dispatchTimeNs_ = delay + Time::CurrentClockNS();
2021-06-27 21:25:29 +00:00
Schedule();
return;
}
SendOff();
}
float WorkItem::GetPrio()
{
return prio_;
}
void WorkItem::SetPrio(float val)
{
prio_ = val;
}
2021-06-30 09:28:52 +00:00
void WorkItem::CancelAsync()
{
AU_TRY_LOCK_GUARD_NAMED(this->lock, asd);
2021-06-30 09:28:52 +00:00
Fail();
}
void WorkItem::RunAsync()
2021-06-27 21:25:29 +00:00
{
AU_LOCK_GUARD(this->lock);
2021-06-27 21:25:29 +00:00
IWorkItemHandler::ProcessInfo info(true);
info.pool = this->owner_->ToThreadPool();
2021-09-06 10:58:08 +00:00
if (this->task_)
2021-09-06 10:58:08 +00:00
{
this->task_->DispatchFrame(info);
2021-09-06 10:58:08 +00:00
}
2021-06-27 21:25:29 +00:00
switch (info.type)
{
case IWorkItemHandler::EProcessNext::eFinished:
{
// do nothing
break;
}
case IWorkItemHandler::EProcessNext::eInvalid:
{
SysPanic("Handle Invalid");
break;
}
case IWorkItemHandler::EProcessNext::eSchedule:
{
if (info.reschedMs)
{
SetSchedTime(info.reschedMs);
}
else if (info.reschedNs)
2021-06-30 12:00:32 +00:00
{
SetSchedTimeNs(info.reschedNs);
}
else if (info.reschedClockAbsMs)
{
SetSchedTimeAbs(info.reschedMs);
}
else if (info.reschedClockAbsNs)
{
SetSchedTimeNsAbs(info.reschedNs);
}
2021-06-27 21:25:29 +00:00
WaitFor(info.waitFor);
2021-06-27 21:25:29 +00:00
}
[[fallthrough]];
2021-06-27 21:25:29 +00:00
case IWorkItemHandler::EProcessNext::eRerun:
{
DispatchEx(false);
return;
}
case IWorkItemHandler::EProcessNext::eFailed:
{
Fail();
return;
}
}
this->finished = true;
if (this->finishedEvent_)
2021-06-27 21:25:29 +00:00
{
this->finishedEvent_->Set();
2021-06-27 21:25:29 +00:00
}
2021-09-06 10:58:08 +00:00
for (auto &waiter : this->waiters_)
2021-09-06 10:58:08 +00:00
{
AuReinterpretCast<WorkItem>(waiter)->DispatchEx(true);
2021-09-06 10:58:08 +00:00
}
2021-06-27 21:25:29 +00:00
}
void WorkItem::Fail()
{
failed = true;
2022-01-19 17:08:13 +00:00
if (auto task_ = AuExchange(this->task_, {}))
2021-06-27 21:25:29 +00:00
{
task_->Shutdown();
}
for (auto &waiter : this->waiters_)
2021-06-27 21:25:29 +00:00
{
AuReinterpretCast<WorkItem>(waiter)->Fail();
2021-06-27 21:25:29 +00:00
}
this->waiters_.clear();
this->waitOn_.clear();
2021-06-27 21:25:29 +00:00
if (this->finishedEvent_)
2021-06-27 21:25:29 +00:00
{
this->finishedEvent_->Set();
2021-06-27 21:25:29 +00:00
}
}
bool WorkItem::BlockUntilComplete()
{
if (!this->finishedEvent_) return false;
return this->owner_->WaitFor(this->worker_, AuUnsafeRaiiToShared(this->finishedEvent_), 0);
2021-06-27 21:25:29 +00:00
}
bool WorkItem::HasFinished()
{
return this->finished;
2021-06-27 21:25:29 +00:00
}
2021-09-29 08:01:42 +00:00
void WorkItem::Cancel()
{
AU_LOCK_GUARD(this->lock);
2021-09-29 08:01:42 +00:00
Fail();
}
2021-06-27 21:25:29 +00:00
bool WorkItem::HasFailed()
{
return this->failed;
2021-06-27 21:25:29 +00:00
}
void WorkItem::Schedule()
{
Async::Schedule(this->dispatchTimeNs_, this->owner_, this->worker_, this->shared_from_this());
2021-06-27 21:25:29 +00:00
}
void WorkItem::SendOff()
{
if (!this->task_)
{
// If we aren't actually calling a task interface, we may as well just dispatch objects waiting on us from here
RunAsync();
}
else
{
this->owner_->Run(this->worker_, this->shared_from_this());
}
2021-06-27 21:25:29 +00:00
}
static auto GetWorkerInternal(const AuSPtr<IThreadPool> &pool)
{
return AuStaticPointerCast<ThreadPool>(pool).get();
}
static auto GetWorkerInternal()
{
return static_cast<AsyncApp *>(GetAsyncApp());
}
2021-06-27 21:25:29 +00:00
AUKN_SYM AuSPtr<IWorkItem> NewWorkItem(const WorkerId_t &worker, const AuSPtr<IWorkItemHandler> &task, bool supportsBlocking)
2021-06-27 21:25:29 +00:00
{
if (!task)
{
return {};
}
return AuMakeShared<WorkItem>(GetWorkerInternal(), worker, task, supportsBlocking);
}
AUKN_SYM AuSPtr<IWorkItem> NewWorkItem(const WorkerPId_t &worker, const AuSPtr<IWorkItemHandler> &task, bool supportsBlocking)
{
if (!task)
{
return {};
}
if (!worker.pool)
{
return {};
}
return AuMakeShared<WorkItem>(GetWorkerInternal(), worker, task, supportsBlocking);
2021-06-27 21:25:29 +00:00
}
AUKN_SYM AuSPtr<IWorkItem> NewFence()
{
return AuMakeShared<WorkItem>(GetWorkerInternal(), WorkerId_t{}, AuSPtr<IWorkItemHandler>{}, true);
}
void *WorkItem::GetPrivateData()
{
if (!this->task_)
{
return nullptr;
}
return this->task_->GetPrivateData();
}
AuOptional<void *> WorkItem::ToWorkResultT()
{
if (!this->task_)
{
return nullptr;
}
auto priv = reinterpret_cast<Async::WorkPriv *>(this->task_->GetPrivateData());
if (!priv)
{
return nullptr;
}
if (priv->magic == AuConvertMagicTag32("BWOT"))
{
return reinterpret_cast<Async::BasicWorkCtx *>(priv)->opt;
}
return {};
}
2021-06-27 21:25:29 +00:00
}