882 lines
25 KiB
C++
882 lines
25 KiB
C++
// WARNING: This is an internal implementation header, which must be included from a specific location/namespace
|
|
// That is the reason that this header does not contain a #pragma once, nor namespace guards
|
|
|
|
enum class eTaskRef;
|
|
template <typename tRet> class TaskPromise;
|
|
class TaskInternalBase;
|
|
template <typename tRet> class TaskInternal;
|
|
|
|
//--- tTaskReadyFn ---//
|
|
using tTaskReadyFn = std::function<bool()>;
|
|
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
auto CancelTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn);
|
|
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
auto StopTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn);
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable, typename tTimeFn>
|
|
auto StopTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn, tTaskTime in_timeout, tTimeFn in_timeFn);
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable, typename T>
|
|
auto StopTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn, tTaskTime in_timeout);
|
|
|
|
//--- Suspend-If Awaiter ---//
|
|
struct SuspendIf
|
|
{
|
|
SuspendIf(bool in_suspend)
|
|
: m_suspend(in_suspend)
|
|
{
|
|
}
|
|
bool await_ready() noexcept { return !m_suspend; }
|
|
void await_suspend(std::coroutine_handle<>) noexcept {}
|
|
void await_resume() noexcept {}
|
|
|
|
private:
|
|
bool m_suspend;
|
|
};
|
|
|
|
//--- Task Debug Stack Formatter ---//
|
|
struct TaskDebugStackFormatter
|
|
{
|
|
// Format function (formats a debug output string) [virtual]
|
|
virtual std::string Format(const std::string& in_str)
|
|
{
|
|
std::string result = Indent(0);
|
|
int32_t indent = 0;
|
|
size_t start = 0;
|
|
size_t found = 0;
|
|
while((found = in_str.find('\n', start)) != std::string::npos)
|
|
{
|
|
size_t end = found + 1;
|
|
if((found < in_str.size() - 1) && (in_str[found + 1] == '`')) // indent
|
|
{
|
|
++indent;
|
|
++end;
|
|
}
|
|
else if((found >= 1) && (in_str[found - 1] == '`')) // dedent
|
|
{
|
|
--indent;
|
|
--found;
|
|
}
|
|
result += in_str.substr(start, found - start) + '\n' + Indent(indent);
|
|
start = end;
|
|
}
|
|
result += in_str.substr(start);
|
|
return result;
|
|
}
|
|
virtual std::string Indent(int32_t in_indent)
|
|
{
|
|
return std::string((long long)in_indent * 2, ' ');
|
|
}
|
|
};
|
|
static std::string FormatDebugString(std::string in_str)
|
|
{
|
|
std::replace(in_str.begin(), in_str.end(), '\n', ' ');
|
|
return in_str.substr(0, 32);
|
|
}
|
|
|
|
//--- SetDebugName Awaiter ---//
|
|
#if SQUID_ENABLE_TASK_DEBUG
|
|
struct SetDebugName
|
|
{
|
|
// Sets a Task's debug name field
|
|
SetDebugName(const char* in_name)
|
|
: m_name(in_name)
|
|
{
|
|
}
|
|
SetDebugName(const char* in_name, std::function<std::string()> in_dataFn)
|
|
: m_name(in_name)
|
|
, m_dataFn(in_dataFn)
|
|
{
|
|
}
|
|
|
|
private:
|
|
template <typename tRet> friend class TaskPromiseBase;
|
|
const char* m_name = nullptr;
|
|
std::function<std::string()> m_dataFn;
|
|
};
|
|
#endif //SQUID_ENABLE_TASK_DEBUG
|
|
|
|
//--- AddStopTask Awaiter ---//
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
struct AddStopTaskAwaiter
|
|
{
|
|
AddStopTaskAwaiter(Task<tRet, RefType, Resumable>& in_taskToStop)
|
|
: m_taskToStop(&in_taskToStop)
|
|
{
|
|
}
|
|
|
|
private:
|
|
template <typename tRet> friend class TaskPromiseBase;
|
|
Task<tRet, RefType, Resumable>* m_taskToStop = nullptr;
|
|
};
|
|
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
auto AddStopTask(Task<tRet, RefType, Resumable>& in_taskToStop)
|
|
{
|
|
return AddStopTaskAwaiter<tRet, RefType, Resumable>(in_taskToStop);
|
|
};
|
|
|
|
//--- RemoveStopTask Awaiter ---//
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
struct RemoveStopTaskAwaiter
|
|
{
|
|
RemoveStopTaskAwaiter(Task<tRet, RefType, Resumable>& in_taskToStop)
|
|
: m_taskToStop(&in_taskToStop)
|
|
{
|
|
}
|
|
|
|
private:
|
|
template <typename tRet> friend class TaskPromiseBase;
|
|
Task<tRet, RefType, Resumable>* m_taskToStop = nullptr;
|
|
};
|
|
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
auto RemoveStopTask(Task<tRet, RefType, Resumable>& in_taskToStop)
|
|
{
|
|
return RemoveStopTaskAwaiter<tRet, RefType, Resumable>(in_taskToStop);
|
|
};
|
|
|
|
//--- Task Awaiter ---//
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable, typename promise_type>
|
|
struct TaskAwaiterBase
|
|
{
|
|
TaskAwaiterBase(const Task<tRet, RefType, Resumable>& in_task)
|
|
{
|
|
// This constructor exists to minimize downstream compile-error spam when co_awaiting a non-copyable Task by copy
|
|
}
|
|
TaskAwaiterBase(Task<tRet, RefType, Resumable>&& in_task)
|
|
: m_task(std::move(in_task))
|
|
{
|
|
SQUID_RUNTIME_CHECK(m_task.IsValid(), "Tried to await an invalid task");
|
|
}
|
|
TaskAwaiterBase(TaskAwaiterBase&& in_taskAwaiter) noexcept
|
|
{
|
|
m_task = std::move(in_taskAwaiter.m_task);
|
|
}
|
|
bool await_ready() noexcept
|
|
{
|
|
if(m_task.IsDone())
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
template <eTaskResumable UResumable = Resumable, typename std::enable_if_t<UResumable == eTaskResumable::Yes>* = nullptr>
|
|
bool await_suspend(std::coroutine_handle<promise_type> in_coroHandle) noexcept
|
|
{
|
|
// Set the sub-task on the suspending task
|
|
auto& promise = in_coroHandle.promise();
|
|
auto taskInternal = promise.GetInternalTask();
|
|
auto subTaskInternal = m_task.GetInternalTask();
|
|
if(taskInternal->IsStopRequested())
|
|
{
|
|
subTaskInternal->RequestStop(); // Propagate any stop request to new sub-tasks
|
|
}
|
|
taskInternal->SetSubTask(std::static_pointer_cast<TaskInternalBase>(subTaskInternal));
|
|
|
|
// Resume the task
|
|
if(m_task.Resume() == eTaskStatus::Done)
|
|
{
|
|
taskInternal->SetSubTask(nullptr);
|
|
return false; // Do not suspend, because the task is done
|
|
}
|
|
return true; // Suspend, because the task is not done
|
|
}
|
|
template <eTaskResumable UResumable = Resumable, typename std::enable_if_t<UResumable == eTaskResumable::No>* = nullptr>
|
|
bool await_suspend(std::coroutine_handle<promise_type> in_coroHandle) noexcept
|
|
{
|
|
auto& promise = in_coroHandle.promise();
|
|
if(!m_task.IsDone())
|
|
{
|
|
promise.SetReadyFunction([this] { return m_task.IsDone(); });
|
|
return true; // Suspend, because the task is not done
|
|
}
|
|
return false; // Do not suspend, because the task is done
|
|
}
|
|
|
|
protected:
|
|
auto GetInternalTask() const
|
|
{
|
|
return m_task.GetInternalTask();
|
|
}
|
|
Task<tRet, RefType, Resumable> m_task;
|
|
};
|
|
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable, typename promise_type>
|
|
struct TaskAwaiter : public TaskAwaiterBase<tRet, RefType, Resumable, promise_type>
|
|
{
|
|
using TaskAwaiterBase<tRet, RefType, Resumable, promise_type>::TaskAwaiterBase;
|
|
|
|
template <typename U = tRet, typename std::enable_if_t<!std::is_void<U>::value>* = nullptr>
|
|
auto await_resume()
|
|
{
|
|
this->m_task.RethrowUnhandledException(); // Re-throw any exceptions
|
|
auto retVal = this->m_task.TakeReturnValue();
|
|
SQUID_RUNTIME_CHECK(retVal.has_value(), "Awaited task return value is unset");
|
|
return std::move(retVal.value());
|
|
}
|
|
|
|
template <typename U = tRet, typename std::enable_if_t<std::is_void<U>::value>* = nullptr>
|
|
void await_resume()
|
|
{
|
|
this->m_task.RethrowUnhandledException(); // Re-throw any exceptions
|
|
}
|
|
};
|
|
|
|
//--- Future Awaiter ---//
|
|
template <typename tRet, typename promise_type>
|
|
struct FutureAwaiter
|
|
{
|
|
FutureAwaiter(std::future<tRet>&& in_future)
|
|
: m_future(std::move(in_future))
|
|
{
|
|
}
|
|
~FutureAwaiter()
|
|
{
|
|
}
|
|
FutureAwaiter(FutureAwaiter&& in_futureAwaiter) noexcept
|
|
{
|
|
m_future = std::move(in_futureAwaiter.m_future);
|
|
}
|
|
bool await_ready() noexcept
|
|
{
|
|
bool isReady = m_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
|
|
return isReady;
|
|
}
|
|
bool await_suspend(std::coroutine_handle<promise_type> in_coroHandle) noexcept
|
|
{
|
|
// Set the ready function
|
|
auto& promise = in_coroHandle.promise();
|
|
auto IsFutureReady = [this] {
|
|
return m_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
|
|
};
|
|
|
|
// Suspend if future is not ready
|
|
bool isReady = m_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
|
|
if(!isReady)
|
|
{
|
|
promise.SetReadyFunction(IsFutureReady);
|
|
}
|
|
return !isReady;
|
|
}
|
|
|
|
template <typename U = tRet, typename std::enable_if_t<!std::is_void<U>::value>* = nullptr>
|
|
auto await_resume()
|
|
{
|
|
return m_future.get(); // Re-throws any exceptions
|
|
}
|
|
|
|
template <typename U = tRet, typename std::enable_if_t<std::is_void<U>::value>* = nullptr>
|
|
void await_resume()
|
|
{
|
|
m_future.get(); // Re-throws any exceptions
|
|
}
|
|
|
|
private:
|
|
std::future<tRet> m_future;
|
|
};
|
|
|
|
//--- Shared Future Awaiter ---//
|
|
template <typename tRet, typename promise_type>
|
|
struct SharedFutureAwaiter
|
|
{
|
|
SharedFutureAwaiter(const std::shared_future<tRet>& in_sharedFuture)
|
|
: m_sharedFuture(in_sharedFuture)
|
|
{
|
|
}
|
|
bool await_ready() noexcept
|
|
{
|
|
bool isReady = m_sharedFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
|
|
return isReady;
|
|
}
|
|
bool await_suspend(std::coroutine_handle<promise_type> in_coroHandle) noexcept
|
|
{
|
|
// Set the ready function
|
|
auto& promise = in_coroHandle.promise();
|
|
auto IsFutureReady = [this] {
|
|
return m_sharedFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
|
|
};
|
|
|
|
// Suspend if future is not ready
|
|
bool isReady = m_sharedFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
|
|
if(!isReady)
|
|
{
|
|
promise.SetReadyFunction(IsFutureReady);
|
|
}
|
|
return !isReady;
|
|
}
|
|
|
|
template <typename U = tRet, typename std::enable_if_t<!std::is_void<U>::value>* = nullptr>
|
|
auto await_resume()
|
|
{
|
|
return m_sharedFuture.get(); // Re-throws any exceptions
|
|
}
|
|
|
|
template <typename U = tRet, typename std::enable_if_t<std::is_void<U>::value>* = nullptr>
|
|
void await_resume()
|
|
{
|
|
m_sharedFuture.get(); // Re-throws any exceptions
|
|
}
|
|
|
|
private:
|
|
std::shared_future<tRet> m_sharedFuture;
|
|
};
|
|
|
|
//--- TaskPromiseBase ---//
|
|
template <typename tRet>
|
|
class TaskPromiseBase
|
|
{
|
|
public:
|
|
// Type aliases
|
|
using promise_type = TaskPromise<tRet>;
|
|
using tTaskInternal = TaskInternal<tRet>;
|
|
|
|
// Destructor
|
|
~TaskPromiseBase()
|
|
{
|
|
// NOTE: Destructor is non-virtual, because it is always handled + destroyed as its concrete type
|
|
m_taskInternal->OnTaskPromiseDestroyed();
|
|
}
|
|
|
|
// Coroutine interface functions
|
|
auto initial_suspend() noexcept
|
|
{
|
|
return std::suspend_always();
|
|
}
|
|
auto final_suspend() noexcept
|
|
{
|
|
return std::suspend_always();
|
|
}
|
|
auto get_return_object()
|
|
{
|
|
return std::coroutine_handle<promise_type>::from_promise(*static_cast<promise_type*>(this));
|
|
}
|
|
static std::shared_ptr<tTaskInternal> get_return_object_on_allocation_failure()
|
|
{
|
|
SQUID_THROW(std::bad_alloc(), "Failed to allocate memory for Task");
|
|
return {};
|
|
}
|
|
void unhandled_exception() noexcept
|
|
{
|
|
#if SQUID_USE_EXCEPTIONS
|
|
// Propagate exceptions for handling
|
|
m_taskInternal->SetUnhandledException(std::current_exception());
|
|
#endif //SQUID_USE_EXCEPTIONS
|
|
}
|
|
|
|
// Internal Task
|
|
void SetInternalTask(tTaskInternal* in_taskInternal)
|
|
{
|
|
m_taskInternal = in_taskInternal;
|
|
}
|
|
tTaskInternal* GetInternalTask()
|
|
{
|
|
return m_taskInternal;
|
|
}
|
|
const tTaskInternal* GetInternalTask() const
|
|
{
|
|
return m_taskInternal;
|
|
}
|
|
|
|
// Ready Function
|
|
void SetReadyFunction(const tTaskReadyFn& in_taskReadyFn)
|
|
{
|
|
m_taskInternal->SetReadyFunction(in_taskReadyFn);
|
|
}
|
|
|
|
// Await-Transforms
|
|
auto await_transform(Suspend in_awaiter)
|
|
{
|
|
return in_awaiter;
|
|
}
|
|
auto await_transform(std::suspend_never in_awaiter)
|
|
{
|
|
return in_awaiter;
|
|
}
|
|
|
|
#if SQUID_ENABLE_TASK_DEBUG
|
|
auto await_transform(SetDebugName in_awaiter)
|
|
{
|
|
m_taskInternal->SetDebugName(in_awaiter.m_name);
|
|
m_taskInternal->SetDebugDataFn(in_awaiter.m_dataFn);
|
|
return std::suspend_never();
|
|
}
|
|
#endif //SQUID_ENABLE_TASK_DEBUG
|
|
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
auto await_transform(AddStopTaskAwaiter<tRet, RefType, Resumable> in_awaiter)
|
|
{
|
|
m_taskInternal->AddStopTask(*in_awaiter.m_taskToStop);
|
|
return std::suspend_never();
|
|
}
|
|
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
auto await_transform(RemoveStopTaskAwaiter<tRet, RefType, Resumable> in_awaiter)
|
|
{
|
|
m_taskInternal->RemoveStopTask(*in_awaiter.m_taskToStop);
|
|
return std::suspend_never();
|
|
}
|
|
|
|
auto await_transform(GetStopContext in_awaiter)
|
|
{
|
|
struct GetStopContextAwaiter : public std::suspend_never
|
|
{
|
|
GetStopContextAwaiter(StopContext in_stopCtx)
|
|
: stopCtx(in_stopCtx)
|
|
{
|
|
}
|
|
auto await_resume() noexcept
|
|
{
|
|
return stopCtx;
|
|
}
|
|
StopContext stopCtx;
|
|
};
|
|
GetStopContextAwaiter stopCtxAwaiter{ m_taskInternal->GetStopContext() };
|
|
return stopCtxAwaiter;
|
|
}
|
|
auto await_transform(const tTaskReadyFn& in_taskReadyFn)
|
|
{
|
|
// Check if we are already ready, and suspend if we are not
|
|
bool isReady = in_taskReadyFn();
|
|
if(!isReady)
|
|
{
|
|
m_taskInternal->SetReadyFunction(in_taskReadyFn);
|
|
}
|
|
return SuspendIf(!isReady); // Suspend if the function isn't already ready
|
|
}
|
|
|
|
template <typename tFutureRet>
|
|
auto await_transform(std::future<tFutureRet>&& in_future)
|
|
{
|
|
return FutureAwaiter<tFutureRet, promise_type>(std::move(in_future));
|
|
}
|
|
|
|
template <typename tFutureRet>
|
|
auto await_transform(const std::shared_future<tFutureRet>& in_sharedFuture)
|
|
{
|
|
return SharedFutureAwaiter<tFutureRet, promise_type>(in_sharedFuture);
|
|
}
|
|
|
|
// Task Await-Transforms
|
|
template <typename tTaskRet, eTaskRef RefType, eTaskResumable Resumable,
|
|
typename std::enable_if_t<Resumable == eTaskResumable::Yes>* = nullptr>
|
|
auto await_transform(Task<tTaskRet, RefType, Resumable>&& in_task) // Move version
|
|
{
|
|
return TaskAwaiter<tTaskRet, RefType, Resumable, promise_type>(std::move(in_task));
|
|
}
|
|
|
|
template <typename tTaskRet, eTaskRef RefType, eTaskResumable Resumable,
|
|
typename std::enable_if_t<Resumable == eTaskResumable::No>* = nullptr>
|
|
auto await_transform(Task<tTaskRet, RefType, Resumable> in_task) // Copy version (Non-Resumable)
|
|
{
|
|
return TaskAwaiter<tTaskRet, RefType, Resumable, promise_type>(std::move(in_task));
|
|
}
|
|
|
|
template <typename tTaskRet, eTaskRef RefType, eTaskResumable Resumable,
|
|
typename std::enable_if_t<Resumable == eTaskResumable::Yes>* = nullptr>
|
|
auto await_transform(const Task<tTaskRet, RefType, Resumable>& in_task) // Invalid copy version (Resumable)
|
|
{
|
|
static_assert(static_false<tTaskRet>::value, "Cannot await a non-copyable (resumable) Task by copy (try co_await std::move(task), co_await WeakTaskHandle(task), or co_await task.WaitUntilDone()");
|
|
return TaskAwaiter<tTaskRet, RefType, Resumable, promise_type>(std::move(in_task));
|
|
}
|
|
|
|
protected:
|
|
tTaskInternal* m_taskInternal = nullptr;
|
|
};
|
|
|
|
//--- TaskPromise ---//
|
|
template <typename tRet>
|
|
class TaskPromise : public TaskPromiseBase<tRet>
|
|
{
|
|
public:
|
|
// Return value access
|
|
void return_value(const tRet& in_retVal) // Copy return value
|
|
{
|
|
this->m_taskInternal->SetReturnValue(in_retVal);
|
|
}
|
|
void return_value(tRet&& in_retVal) // Move return value
|
|
{
|
|
this->m_taskInternal->SetReturnValue(std::move(in_retVal));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
class TaskPromise<void> : public TaskPromiseBase<void>
|
|
{
|
|
public:
|
|
void return_void()
|
|
{
|
|
}
|
|
};
|
|
|
|
//--- TaskInternalBase ---//
|
|
class TaskInternalBase
|
|
{
|
|
public:
|
|
TaskInternalBase(std::coroutine_handle<> in_coroHandle)
|
|
: m_coroHandle(in_coroHandle)
|
|
{
|
|
SQUID_RUNTIME_CHECK(m_coroHandle, "Invalid coroutine handle passed into Task");
|
|
}
|
|
~TaskInternalBase() // NOTE: Destructor is intentionally non-virtual (shared_ptr preserves concrete type via deleter)
|
|
{
|
|
Kill(); // Used for killing subtasks
|
|
}
|
|
StopContext GetStopContext() const
|
|
{
|
|
return { &m_isStopRequested };
|
|
}
|
|
bool IsStopRequested() const
|
|
{
|
|
return m_isStopRequested;
|
|
}
|
|
void RequestStop() // Propagates a request for the task to come to a 'graceful' stop
|
|
{
|
|
m_isStopRequested = true;
|
|
for(auto& stopTask : m_stopTasks)
|
|
{
|
|
if(auto locked = stopTask.lock())
|
|
{
|
|
locked->RequestStop();
|
|
}
|
|
}
|
|
m_stopTasks.clear();
|
|
}
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
void AddStopTask(Task<tRet, RefType, Resumable>& in_taskToStop) // Adds a task to the list of tasks to which we propagate stop requests
|
|
{
|
|
if(m_isStopRequested)
|
|
{
|
|
in_taskToStop.RequestStop();
|
|
}
|
|
else if(in_taskToStop.IsValid())
|
|
{
|
|
m_stopTasks.push_back(in_taskToStop.GetInternalTask());
|
|
}
|
|
}
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
|
|
void RemoveStopTask(Task<tRet, RefType, Resumable>& in_taskToStop) // Removes a task to the list of tasks to which we propagate stop requests
|
|
{
|
|
if(in_taskToStop.IsValid())
|
|
{
|
|
for(size_t i = 0; i < m_stopTasks.size(); ++i)
|
|
{
|
|
if(m_stopTasks[i].lock() == in_taskToStop.GetInternalTask())
|
|
{
|
|
m_stopTasks[i] = m_stopTasks.back();
|
|
m_stopTasks.pop_back();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
eTaskStatus Resume() // Returns whether the task is still running
|
|
{
|
|
// Make sure this task is not already mid-resume
|
|
SQUID_RUNTIME_CHECK(m_internalState != eInternalState::Resuming, "Attempted to resume Task while already resumed");
|
|
|
|
// Task is destroyed, therefore task is done
|
|
if(m_internalState == eInternalState::Destroyed)
|
|
{
|
|
return eTaskStatus::Done;
|
|
}
|
|
|
|
// Mark task as resuming
|
|
m_internalState = eInternalState::Resuming;
|
|
|
|
// Resume any active sub-task
|
|
if(m_subTaskInternal)
|
|
{
|
|
// Propagate any stop requests to sub-task prior to resuming
|
|
if(m_isStopRequested)
|
|
{
|
|
m_subTaskInternal->m_isStopRequested = true;
|
|
}
|
|
|
|
// Resume the sub-task
|
|
if(m_subTaskInternal->Resume() != eTaskStatus::Done)
|
|
{
|
|
m_internalState = eInternalState::Idle;
|
|
return eTaskStatus::Suspended; // Sub-task not done, therefore task is not done
|
|
}
|
|
|
|
// Clear the sub-task
|
|
m_subTaskInternal = nullptr;
|
|
}
|
|
|
|
// Resume task, if necessary
|
|
if(CanResume())
|
|
{
|
|
m_taskReadyFn = nullptr; // Clear any ready function we were waiting on
|
|
m_coroHandle.resume(); // Resume the underlying std::coroutine_handle
|
|
}
|
|
|
|
// Return to idle state and return current task status
|
|
auto taskStatus = m_coroHandle.done() ? eTaskStatus::Done : eTaskStatus::Suspended;
|
|
if(taskStatus == eTaskStatus::Done)
|
|
{
|
|
m_isDone = true; // Mark task done
|
|
}
|
|
m_internalState = eInternalState::Idle;
|
|
return taskStatus;
|
|
}
|
|
|
|
// Sub-task
|
|
void SetSubTask(std::shared_ptr<TaskInternalBase> in_subTaskInternal)
|
|
{
|
|
m_subTaskInternal = in_subTaskInternal;
|
|
}
|
|
|
|
#if SQUID_ENABLE_TASK_DEBUG
|
|
// Debug task name + stack
|
|
std::string GetDebugName() const
|
|
{
|
|
return (!IsDone() && m_debugDataFn) ? (std::string(m_debugName) + " [" + m_debugDataFn() + "]") : m_debugName;
|
|
}
|
|
std::string GetDebugStack() const
|
|
{
|
|
std::string result = m_subTaskInternal ? (GetDebugName() + " -> " + m_subTaskInternal->GetDebugStack()) : GetDebugName();
|
|
return result;
|
|
}
|
|
void SetDebugName(const char* in_debugName)
|
|
{
|
|
if(in_debugName)
|
|
{
|
|
m_debugName = in_debugName;
|
|
}
|
|
}
|
|
void SetDebugDataFn(std::function<std::string()> in_debugDataFn)
|
|
{
|
|
m_debugDataFn = in_debugDataFn;
|
|
}
|
|
#endif //SQUID_ENABLE_TASK_DEBUG
|
|
|
|
// Exceptions
|
|
#if SQUID_USE_EXCEPTIONS
|
|
std::exception_ptr GetUnhandledException() const
|
|
{
|
|
if(m_isExceptionSet)
|
|
{
|
|
return m_exception;
|
|
}
|
|
return nullptr;
|
|
}
|
|
#endif //SQUID_USE_EXCEPTIONS
|
|
|
|
protected:
|
|
#if SQUID_USE_EXCEPTIONS
|
|
// Internal implementation of exception-setting (called by TaskInternal<> child classes)
|
|
void InternalSetUnhandledException(std::exception_ptr in_exception)
|
|
{
|
|
// NOTE: This must never be called more than once in the lifetime of an internal task
|
|
SQUID_RUNTIME_CHECK(!m_isExceptionSet, "Exception was set for a task after it had already been set");
|
|
if(!m_isExceptionSet)
|
|
{
|
|
m_exception = in_exception;
|
|
m_isExceptionSet = true;
|
|
}
|
|
}
|
|
#endif //SQUID_USE_EXCEPTIONS
|
|
|
|
private:
|
|
template <typename tRet> friend class TaskPromiseBase;
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable, typename promise_type> friend struct TaskAwaiterBase;
|
|
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable> friend class Task;
|
|
|
|
// Kill this task
|
|
void Kill() // Kill() can safely be called multiple times
|
|
{
|
|
SQUID_RUNTIME_CHECK(m_internalState != eInternalState::Resuming, "Attempted to kill Task while resumed");
|
|
if(m_internalState == eInternalState::Idle)
|
|
{
|
|
// Mark task done
|
|
m_isDone = true;
|
|
|
|
// First destroy any sub-tasks
|
|
if(m_subTaskInternal)
|
|
{
|
|
m_subTaskInternal->Kill();
|
|
}
|
|
|
|
// Destroy the underlying std::coroutine_handle
|
|
m_coroHandle.destroy(); // This should only ever be called directly from this one place
|
|
m_coroHandle = nullptr;
|
|
m_taskReadyFn = nullptr; // Clear out the ready function
|
|
m_internalState = eInternalState::Destroyed;
|
|
}
|
|
}
|
|
|
|
// Done + can-resume status
|
|
void SetReadyFunction(const tTaskReadyFn& in_taskReadyFn)
|
|
{
|
|
m_taskReadyFn = in_taskReadyFn;
|
|
}
|
|
bool CanResume() const
|
|
{
|
|
if(IsDone())
|
|
{
|
|
return false;
|
|
}
|
|
if(m_subTaskInternal)
|
|
{
|
|
bool canResume = m_subTaskInternal->CanResume();
|
|
return canResume;
|
|
}
|
|
bool isReady = !m_taskReadyFn || m_taskReadyFn();
|
|
return isReady;
|
|
}
|
|
bool IsDone() const
|
|
{
|
|
return m_isDone;
|
|
}
|
|
bool m_isDone = false;
|
|
|
|
// Internal state
|
|
enum class eInternalState
|
|
{
|
|
Idle,
|
|
Resuming,
|
|
Destroyed,
|
|
};
|
|
eInternalState m_internalState = eInternalState::Idle;
|
|
|
|
// Task ready condition (when awaiting a std::function<bool>)
|
|
tTaskReadyFn m_taskReadyFn;
|
|
|
|
#if SQUID_USE_EXCEPTIONS
|
|
// Exceptions
|
|
std::exception_ptr m_exception = nullptr;
|
|
bool m_isExceptionSet = false;
|
|
#endif //SQUID_USE_EXCEPTIONS
|
|
|
|
// Sub-task
|
|
std::shared_ptr<TaskInternalBase> m_subTaskInternal;
|
|
|
|
// Reference-counting (determines underlying std::coroutine_handle lifetime, not lifetime of this internal task)
|
|
void AddLogicalRef()
|
|
{
|
|
++m_refCount;
|
|
}
|
|
void RemoveLogicalRef()
|
|
{
|
|
--m_refCount;
|
|
if(m_refCount == 0)
|
|
{
|
|
Kill();
|
|
}
|
|
}
|
|
int32_t m_refCount = 0; // Number of (strong) non-weak tasks referencing the internal task
|
|
|
|
// C++ std::coroutine_handle
|
|
std::coroutine_handle<> m_coroHandle;
|
|
|
|
// Stop request
|
|
bool m_isStopRequested = false;
|
|
std::vector<std::weak_ptr<TaskInternalBase>> m_stopTasks;
|
|
|
|
#if SQUID_ENABLE_TASK_DEBUG
|
|
// Debug Data
|
|
const char* m_debugName = "[unnamed task]";
|
|
std::function<std::string()> m_debugDataFn;
|
|
#endif //SQUID_ENABLE_TASK_DEBUG
|
|
};
|
|
|
|
//--- TaskInternal ---//
|
|
template <typename tRet>
|
|
class TaskInternal : public TaskInternalBase
|
|
{
|
|
public:
|
|
using promise_type = TaskPromise<tRet>;
|
|
|
|
TaskInternal(std::coroutine_handle<promise_type> in_handle)
|
|
: TaskInternalBase(in_handle)
|
|
{
|
|
auto& promisePtr = in_handle.promise();
|
|
promisePtr.SetInternalTask(this);
|
|
}
|
|
#if SQUID_USE_EXCEPTIONS
|
|
void SetUnhandledException(std::exception_ptr in_exception)
|
|
{
|
|
m_retValState = eTaskRetValState::Orphaned; // Return value can never be set if there was an unhandled exception
|
|
InternalSetUnhandledException(in_exception);
|
|
}
|
|
#endif //SQUID_USE_EXCEPTIONS
|
|
void SetReturnValue(const tRet& in_retVal)
|
|
{
|
|
tRet retVal = in_retVal;
|
|
SetReturnValue(std::move(retVal));
|
|
}
|
|
void SetReturnValue(tRet&& in_retVal)
|
|
{
|
|
if(m_retValState == eTaskRetValState::Unset)
|
|
{
|
|
m_retVal = std::move(in_retVal);
|
|
m_retValState = eTaskRetValState::Set;
|
|
return;
|
|
}
|
|
|
|
// These conditions should (logically) never be met, but they are included in case future changes violate that constraint
|
|
SQUID_RUNTIME_CHECK(m_retValState != eTaskRetValState::Set, "Attempted to set a task's return value when it was already set");
|
|
SQUID_RUNTIME_CHECK(m_retValState != eTaskRetValState::Taken, "Attempted to set a task's return value after it was already taken");
|
|
SQUID_RUNTIME_CHECK(m_retValState != eTaskRetValState::Orphaned, "Attempted to set a task's return value after it was orphaned");
|
|
}
|
|
std::optional<tRet> TakeReturnValue()
|
|
{
|
|
// If the value has been set, mark it as taken and move-return the value
|
|
if(m_retValState == eTaskRetValState::Set)
|
|
{
|
|
m_retValState = eTaskRetValState::Taken;
|
|
return std::move(m_retVal);
|
|
}
|
|
|
|
// If the value was not set, return an unset optional (checking that it was neither taken nor orphaned)
|
|
SQUID_RUNTIME_CHECK(m_retValState != eTaskRetValState::Taken, "Attempted to take a task's return value after it was already successfully taken");
|
|
SQUID_RUNTIME_CHECK(m_retValState != eTaskRetValState::Orphaned, "Attempted to take a task's return value that will never be set (task ended prematurely)");
|
|
return {};
|
|
}
|
|
void OnTaskPromiseDestroyed()
|
|
{
|
|
// Mark the return value as orphaned if it was never set
|
|
m_retValState = eTaskRetValState::Orphaned;
|
|
}
|
|
|
|
private:
|
|
// Internal state
|
|
enum class eTaskRetValState
|
|
{
|
|
Unset, // Has not yet been set
|
|
Set, // Has been set and can be taken
|
|
Taken, // Has been taken and can no longer be taken
|
|
Orphaned, // Will never be set because the TaskPromise has been destroyed
|
|
};
|
|
|
|
eTaskRetValState m_retValState = eTaskRetValState::Unset; // Initially unset
|
|
std::optional<tRet> m_retVal;
|
|
};
|
|
|
|
template <>
|
|
class TaskInternal<void> : public TaskInternalBase
|
|
{
|
|
public:
|
|
using promise_type = TaskPromise<void>;
|
|
|
|
TaskInternal(std::coroutine_handle<promise_type> in_handle)
|
|
: TaskInternalBase(in_handle)
|
|
{
|
|
auto& promisePtr = in_handle.promise();
|
|
promisePtr.SetInternalTask(this);
|
|
}
|
|
#if SQUID_USE_EXCEPTIONS
|
|
void SetUnhandledException(std::exception_ptr in_exception)
|
|
{
|
|
InternalSetUnhandledException(in_exception);
|
|
}
|
|
#endif //SQUID_USE_EXCEPTIONS
|
|
void TakeReturnValue() // This function is an intentional no-op, to simplify certain templated function implementations
|
|
{
|
|
}
|
|
void OnTaskPromiseDestroyed()
|
|
{
|
|
}
|
|
};
|