bunnei
5 years ago
33 changed files with 397 additions and 621 deletions
-
6src/core/CMakeLists.txt
-
10src/core/hle/kernel/address_arbiter.cpp
-
3src/core/hle/kernel/client_port.cpp
-
11src/core/hle/kernel/client_session.cpp
-
8src/core/hle/kernel/client_session.h
-
3src/core/hle/kernel/errors.h
-
5src/core/hle/kernel/k_scheduler.cpp
-
171src/core/hle/kernel/k_synchronization_object.cpp
-
58src/core/hle/kernel/k_synchronization_object.h
-
15src/core/hle/kernel/kernel.cpp
-
6src/core/hle/kernel/kernel.h
-
4src/core/hle/kernel/mutex.cpp
-
21src/core/hle/kernel/process.cpp
-
14src/core/hle/kernel/process.h
-
18src/core/hle/kernel/readable_event.cpp
-
12src/core/hle/kernel/readable_event.h
-
14src/core/hle/kernel/server_port.cpp
-
7src/core/hle/kernel/server_port.h
-
23src/core/hle/kernel/server_session.cpp
-
12src/core/hle/kernel/server_session.h
-
11src/core/hle/kernel/session.cpp
-
8src/core/hle/kernel/session.h
-
47src/core/hle/kernel/svc.cpp
-
9src/core/hle/kernel/svc_wrap.h
-
116src/core/hle/kernel/synchronization.cpp
-
44src/core/hle/kernel/synchronization.h
-
49src/core/hle/kernel/synchronization_object.cpp
-
77src/core/hle/kernel/synchronization_object.h
-
66src/core/hle/kernel/thread.cpp
-
131src/core/hle/kernel/thread.h
-
3src/core/hle/service/sm/sm.cpp
-
19src/yuzu/debugger/wait_tree.cpp
-
17src/yuzu/debugger/wait_tree.h
@ -0,0 +1,171 @@ |
|||||
|
// Copyright 2021 yuzu Emulator Project
|
||||
|
// Licensed under GPLv2 or any later version
|
||||
|
// Refer to the license.txt file included.
|
||||
|
|
||||
|
#include "common/assert.h"
|
||||
|
#include "common/common_types.h"
|
||||
|
#include "core/hle/kernel/k_scheduler.h"
|
||||
|
#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
|
||||
|
#include "core/hle/kernel/k_synchronization_object.h"
|
||||
|
#include "core/hle/kernel/kernel.h"
|
||||
|
#include "core/hle/kernel/svc_results.h"
|
||||
|
#include "core/hle/kernel/thread.h"
|
||||
|
|
||||
|
namespace Kernel { |
||||
|
|
||||
|
ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index, |
||||
|
KSynchronizationObject** objects, const s32 num_objects, |
||||
|
s64 timeout) { |
||||
|
// Allocate space on stack for thread nodes.
|
||||
|
std::vector<ThreadListNode> thread_nodes(num_objects); |
||||
|
|
||||
|
// Prepare for wait.
|
||||
|
Thread* thread = kernel.CurrentScheduler()->GetCurrentThread(); |
||||
|
Handle timer = InvalidHandle; |
||||
|
|
||||
|
{ |
||||
|
// Setup the scheduling lock and sleep.
|
||||
|
KScopedSchedulerLockAndSleep slp(kernel, timer, thread, timeout); |
||||
|
|
||||
|
// Check if any of the objects are already signaled.
|
||||
|
for (auto i = 0; i < num_objects; ++i) { |
||||
|
ASSERT(objects[i] != nullptr); |
||||
|
|
||||
|
if (objects[i]->IsSignaled()) { |
||||
|
*out_index = i; |
||||
|
slp.CancelSleep(); |
||||
|
return RESULT_SUCCESS; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Check if the timeout is zero.
|
||||
|
if (timeout == 0) { |
||||
|
slp.CancelSleep(); |
||||
|
return Svc::ResultTimedOut; |
||||
|
} |
||||
|
|
||||
|
// Check if the thread should terminate.
|
||||
|
if (thread->IsTerminationRequested()) { |
||||
|
slp.CancelSleep(); |
||||
|
return Svc::ResultTerminationRequested; |
||||
|
} |
||||
|
|
||||
|
// Check if waiting was canceled.
|
||||
|
if (thread->IsWaitCancelled()) { |
||||
|
slp.CancelSleep(); |
||||
|
thread->ClearWaitCancelled(); |
||||
|
return Svc::ResultCancelled; |
||||
|
} |
||||
|
|
||||
|
// Add the waiters.
|
||||
|
for (auto i = 0; i < num_objects; ++i) { |
||||
|
thread_nodes[i].thread = thread; |
||||
|
thread_nodes[i].next = nullptr; |
||||
|
|
||||
|
if (objects[i]->thread_list_tail == nullptr) { |
||||
|
objects[i]->thread_list_head = std::addressof(thread_nodes[i]); |
||||
|
} else { |
||||
|
objects[i]->thread_list_tail->next = std::addressof(thread_nodes[i]); |
||||
|
} |
||||
|
|
||||
|
objects[i]->thread_list_tail = std::addressof(thread_nodes[i]); |
||||
|
} |
||||
|
|
||||
|
// For debugging only
|
||||
|
thread->SetWaitObjectsForDebugging(objects, num_objects); |
||||
|
|
||||
|
// Mark the thread as waiting.
|
||||
|
thread->SetCancellable(); |
||||
|
thread->SetSyncedObject(nullptr, Svc::ResultTimedOut); |
||||
|
thread->SetState(ThreadState::WaitSynch); |
||||
|
} |
||||
|
|
||||
|
// The lock/sleep is done, so we should be able to get our result.
|
||||
|
|
||||
|
// Thread is no longer cancellable.
|
||||
|
thread->ClearCancellable(); |
||||
|
|
||||
|
// For debugging only
|
||||
|
thread->SetWaitObjectsForDebugging(nullptr, 0); |
||||
|
|
||||
|
// Cancel the timer as needed.
|
||||
|
if (timer != InvalidHandle) { |
||||
|
auto& time_manager = kernel.TimeManager(); |
||||
|
time_manager.UnscheduleTimeEvent(timer); |
||||
|
} |
||||
|
|
||||
|
// Get the wait result.
|
||||
|
ResultCode wait_result{RESULT_SUCCESS}; |
||||
|
s32 sync_index = -1; |
||||
|
{ |
||||
|
KScopedSchedulerLock lock(kernel); |
||||
|
KSynchronizationObject* synced_obj; |
||||
|
wait_result = thread->GetWaitResult(std::addressof(synced_obj)); |
||||
|
|
||||
|
for (auto i = 0; i < num_objects; ++i) { |
||||
|
// Unlink the object from the list.
|
||||
|
ThreadListNode* prev_ptr = |
||||
|
reinterpret_cast<ThreadListNode*>(std::addressof(objects[i]->thread_list_head)); |
||||
|
ThreadListNode* prev_val = nullptr; |
||||
|
ThreadListNode *prev, *tail_prev; |
||||
|
|
||||
|
do { |
||||
|
prev = prev_ptr; |
||||
|
prev_ptr = prev_ptr->next; |
||||
|
tail_prev = prev_val; |
||||
|
prev_val = prev_ptr; |
||||
|
} while (prev_ptr != std::addressof(thread_nodes[i])); |
||||
|
|
||||
|
if (objects[i]->thread_list_tail == std::addressof(thread_nodes[i])) { |
||||
|
objects[i]->thread_list_tail = tail_prev; |
||||
|
} |
||||
|
|
||||
|
prev->next = thread_nodes[i].next; |
||||
|
|
||||
|
if (objects[i] == synced_obj) { |
||||
|
sync_index = i; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Set output.
|
||||
|
*out_index = sync_index; |
||||
|
return wait_result; |
||||
|
} |
||||
|
|
||||
|
KSynchronizationObject::KSynchronizationObject(KernelCore& kernel) : Object{kernel} {} |
||||
|
|
||||
|
KSynchronizationObject ::~KSynchronizationObject() = default; |
||||
|
|
||||
|
void KSynchronizationObject::NotifyAvailable(ResultCode result) { |
||||
|
KScopedSchedulerLock lock(kernel); |
||||
|
|
||||
|
// If we're not signaled, we've nothing to notify.
|
||||
|
if (!this->IsSignaled()) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// Iterate over each thread.
|
||||
|
for (auto* cur_node = thread_list_head; cur_node != nullptr; cur_node = cur_node->next) { |
||||
|
Thread* thread = cur_node->thread; |
||||
|
if (thread->GetState() == ThreadSchedStatus::Paused) { |
||||
|
thread->SetSyncedObject(this, result); |
||||
|
thread->SetState(ThreadStatus::Ready); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
std::vector<Thread*> KSynchronizationObject::GetWaitingThreadsForDebugging() const { |
||||
|
std::vector<Thread*> threads; |
||||
|
|
||||
|
// If debugging, dump the list of waiters.
|
||||
|
{ |
||||
|
KScopedSchedulerLock lock(kernel); |
||||
|
for (auto* cur_node = thread_list_head; cur_node != nullptr; cur_node = cur_node->next) { |
||||
|
threads.emplace_back(cur_node->thread); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return threads; |
||||
|
} |
||||
|
} // namespace Kernel
|
||||
@ -0,0 +1,58 @@ |
|||||
|
// Copyright 2021 yuzu Emulator Project |
||||
|
// Licensed under GPLv2 or any later version |
||||
|
// Refer to the license.txt file included. |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <vector> |
||||
|
|
||||
|
#include "core/hle/kernel/object.h" |
||||
|
#include "core/hle/result.h" |
||||
|
|
||||
|
namespace Kernel { |
||||
|
|
||||
|
class KernelCore; |
||||
|
class Synchronization; |
||||
|
class Thread; |
||||
|
|
||||
|
/// Class that represents a Kernel object that a thread can be waiting on |
||||
|
class KSynchronizationObject : public Object { |
||||
|
public: |
||||
|
struct ThreadListNode { |
||||
|
ThreadListNode* next{}; |
||||
|
Thread* thread{}; |
||||
|
}; |
||||
|
|
||||
|
[[nodiscard]] static ResultCode Wait(KernelCore& kernel, s32* out_index, |
||||
|
KSynchronizationObject** objects, const s32 num_objects, |
||||
|
s64 timeout); |
||||
|
|
||||
|
[[nodiscard]] virtual bool IsSignaled() const = 0; |
||||
|
|
||||
|
[[nodiscard]] std::vector<Thread*> GetWaitingThreadsForDebugging() const; |
||||
|
|
||||
|
protected: |
||||
|
explicit KSynchronizationObject(KernelCore& kernel); |
||||
|
virtual ~KSynchronizationObject(); |
||||
|
|
||||
|
void NotifyAvailable(ResultCode result); |
||||
|
void NotifyAvailable() { |
||||
|
return this->NotifyAvailable(RESULT_SUCCESS); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
ThreadListNode* thread_list_head{}; |
||||
|
ThreadListNode* thread_list_tail{}; |
||||
|
}; |
||||
|
|
||||
|
// Specialization of DynamicObjectCast for KSynchronizationObjects |
||||
|
template <> |
||||
|
inline std::shared_ptr<KSynchronizationObject> DynamicObjectCast<KSynchronizationObject>( |
||||
|
std::shared_ptr<Object> object) { |
||||
|
if (object != nullptr && object->IsWaitable()) { |
||||
|
return std::static_pointer_cast<KSynchronizationObject>(object); |
||||
|
} |
||||
|
return nullptr; |
||||
|
} |
||||
|
|
||||
|
} // namespace Kernel |
||||
@ -1,116 +0,0 @@ |
|||||
// Copyright 2020 yuzu Emulator Project
|
|
||||
// Licensed under GPLv2 or any later version
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include "core/core.h"
|
|
||||
#include "core/hle/kernel/errors.h"
|
|
||||
#include "core/hle/kernel/handle_table.h"
|
|
||||
#include "core/hle/kernel/k_scheduler.h"
|
|
||||
#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
|
|
||||
#include "core/hle/kernel/kernel.h"
|
|
||||
#include "core/hle/kernel/synchronization.h"
|
|
||||
#include "core/hle/kernel/synchronization_object.h"
|
|
||||
#include "core/hle/kernel/thread.h"
|
|
||||
#include "core/hle/kernel/time_manager.h"
|
|
||||
|
|
||||
namespace Kernel { |
|
||||
|
|
||||
Synchronization::Synchronization(Core::System& system) : system{system} {} |
|
||||
|
|
||||
void Synchronization::SignalObject(SynchronizationObject& obj) const { |
|
||||
auto& kernel = system.Kernel(); |
|
||||
KScopedSchedulerLock lock(kernel); |
|
||||
if (obj.IsSignaled()) { |
|
||||
for (auto thread : obj.GetWaitingThreads()) { |
|
||||
if (thread->GetSchedulingStatus() == ThreadSchedStatus::Paused) { |
|
||||
if (thread->GetStatus() != ThreadStatus::WaitHLEEvent) { |
|
||||
ASSERT(thread->GetStatus() == ThreadStatus::WaitSynch); |
|
||||
ASSERT(thread->IsWaitingSync()); |
|
||||
} |
|
||||
thread->SetSynchronizationResults(&obj, RESULT_SUCCESS); |
|
||||
thread->ResumeFromWait(); |
|
||||
} |
|
||||
} |
|
||||
obj.ClearWaitingThreads(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
std::pair<ResultCode, Handle> Synchronization::WaitFor( |
|
||||
std::vector<std::shared_ptr<SynchronizationObject>>& sync_objects, s64 nano_seconds) { |
|
||||
auto& kernel = system.Kernel(); |
|
||||
auto* const thread = kernel.CurrentScheduler()->GetCurrentThread(); |
|
||||
Handle event_handle = InvalidHandle; |
|
||||
{ |
|
||||
KScopedSchedulerLockAndSleep lock(kernel, event_handle, thread, nano_seconds); |
|
||||
const auto itr = |
|
||||
std::find_if(sync_objects.begin(), sync_objects.end(), |
|
||||
[thread](const std::shared_ptr<SynchronizationObject>& object) { |
|
||||
return object->IsSignaled(); |
|
||||
}); |
|
||||
|
|
||||
if (itr != sync_objects.end()) { |
|
||||
// We found a ready object, acquire it and set the result value
|
|
||||
SynchronizationObject* object = itr->get(); |
|
||||
object->Acquire(thread); |
|
||||
const u32 index = static_cast<s32>(std::distance(sync_objects.begin(), itr)); |
|
||||
lock.CancelSleep(); |
|
||||
return {RESULT_SUCCESS, index}; |
|
||||
} |
|
||||
|
|
||||
if (nano_seconds == 0) { |
|
||||
lock.CancelSleep(); |
|
||||
return {RESULT_TIMEOUT, InvalidHandle}; |
|
||||
} |
|
||||
|
|
||||
if (thread->IsPendingTermination()) { |
|
||||
lock.CancelSleep(); |
|
||||
return {ERR_THREAD_TERMINATING, InvalidHandle}; |
|
||||
} |
|
||||
|
|
||||
if (thread->IsSyncCancelled()) { |
|
||||
thread->SetSyncCancelled(false); |
|
||||
lock.CancelSleep(); |
|
||||
return {ERR_SYNCHRONIZATION_CANCELED, InvalidHandle}; |
|
||||
} |
|
||||
|
|
||||
for (auto& object : sync_objects) { |
|
||||
object->AddWaitingThread(SharedFrom(thread)); |
|
||||
} |
|
||||
|
|
||||
thread->SetSynchronizationObjects(&sync_objects); |
|
||||
thread->SetSynchronizationResults(nullptr, RESULT_TIMEOUT); |
|
||||
thread->SetStatus(ThreadStatus::WaitSynch); |
|
||||
thread->SetWaitingSync(true); |
|
||||
} |
|
||||
thread->SetWaitingSync(false); |
|
||||
|
|
||||
if (event_handle != InvalidHandle) { |
|
||||
auto& time_manager = kernel.TimeManager(); |
|
||||
time_manager.UnscheduleTimeEvent(event_handle); |
|
||||
} |
|
||||
|
|
||||
{ |
|
||||
KScopedSchedulerLock lock(kernel); |
|
||||
ResultCode signaling_result = thread->GetSignalingResult(); |
|
||||
SynchronizationObject* signaling_object = thread->GetSignalingObject(); |
|
||||
thread->SetSynchronizationObjects(nullptr); |
|
||||
auto shared_thread = SharedFrom(thread); |
|
||||
for (auto& obj : sync_objects) { |
|
||||
obj->RemoveWaitingThread(shared_thread); |
|
||||
} |
|
||||
if (signaling_object != nullptr) { |
|
||||
const auto itr = std::find_if( |
|
||||
sync_objects.begin(), sync_objects.end(), |
|
||||
[signaling_object](const std::shared_ptr<SynchronizationObject>& object) { |
|
||||
return object.get() == signaling_object; |
|
||||
}); |
|
||||
ASSERT(itr != sync_objects.end()); |
|
||||
signaling_object->Acquire(thread); |
|
||||
const u32 index = static_cast<s32>(std::distance(sync_objects.begin(), itr)); |
|
||||
return {signaling_result, index}; |
|
||||
} |
|
||||
return {signaling_result, -1}; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
} // namespace Kernel
|
|
||||
@ -1,44 +0,0 @@ |
|||||
// Copyright 2020 yuzu Emulator Project |
|
||||
// Licensed under GPLv2 or any later version |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <memory> |
|
||||
#include <utility> |
|
||||
#include <vector> |
|
||||
|
|
||||
#include "core/hle/kernel/object.h" |
|
||||
#include "core/hle/result.h" |
|
||||
|
|
||||
namespace Core { |
|
||||
class System; |
|
||||
} // namespace Core |
|
||||
|
|
||||
namespace Kernel { |
|
||||
|
|
||||
class SynchronizationObject; |
|
||||
|
|
||||
/** |
|
||||
* The 'Synchronization' class is an interface for handling synchronization methods |
|
||||
* used by Synchronization objects and synchronization SVCs. This centralizes processing of |
|
||||
* such |
|
||||
*/ |
|
||||
class Synchronization { |
|
||||
public: |
|
||||
explicit Synchronization(Core::System& system); |
|
||||
|
|
||||
/// Signals a synchronization object, waking up all its waiting threads |
|
||||
void SignalObject(SynchronizationObject& obj) const; |
|
||||
|
|
||||
/// Tries to see if waiting for any of the sync_objects is necessary, if not |
|
||||
/// it returns Success and the handle index of the signaled sync object. In |
|
||||
/// case not, the current thread will be locked and wait for nano_seconds or |
|
||||
/// for a synchronization object to signal. |
|
||||
std::pair<ResultCode, Handle> WaitFor( |
|
||||
std::vector<std::shared_ptr<SynchronizationObject>>& sync_objects, s64 nano_seconds); |
|
||||
|
|
||||
private: |
|
||||
Core::System& system; |
|
||||
}; |
|
||||
} // namespace Kernel |
|
||||
@ -1,49 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project
|
|
||||
// Licensed under GPLv2 or any later version
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include <algorithm>
|
|
||||
#include "common/assert.h"
|
|
||||
#include "common/common_types.h"
|
|
||||
#include "common/logging/log.h"
|
|
||||
#include "core/core.h"
|
|
||||
#include "core/hle/kernel/kernel.h"
|
|
||||
#include "core/hle/kernel/object.h"
|
|
||||
#include "core/hle/kernel/process.h"
|
|
||||
#include "core/hle/kernel/synchronization.h"
|
|
||||
#include "core/hle/kernel/synchronization_object.h"
|
|
||||
#include "core/hle/kernel/thread.h"
|
|
||||
|
|
||||
namespace Kernel { |
|
||||
|
|
||||
SynchronizationObject::SynchronizationObject(KernelCore& kernel) : Object{kernel} {} |
|
||||
SynchronizationObject::~SynchronizationObject() = default; |
|
||||
|
|
||||
void SynchronizationObject::Signal() { |
|
||||
kernel.Synchronization().SignalObject(*this); |
|
||||
} |
|
||||
|
|
||||
void SynchronizationObject::AddWaitingThread(std::shared_ptr<Thread> thread) { |
|
||||
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread); |
|
||||
if (itr == waiting_threads.end()) |
|
||||
waiting_threads.push_back(std::move(thread)); |
|
||||
} |
|
||||
|
|
||||
void SynchronizationObject::RemoveWaitingThread(std::shared_ptr<Thread> thread) { |
|
||||
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread); |
|
||||
// If a thread passed multiple handles to the same object,
|
|
||||
// the kernel might attempt to remove the thread from the object's
|
|
||||
// waiting threads list multiple times.
|
|
||||
if (itr != waiting_threads.end()) |
|
||||
waiting_threads.erase(itr); |
|
||||
} |
|
||||
|
|
||||
void SynchronizationObject::ClearWaitingThreads() { |
|
||||
waiting_threads.clear(); |
|
||||
} |
|
||||
|
|
||||
const std::vector<std::shared_ptr<Thread>>& SynchronizationObject::GetWaitingThreads() const { |
|
||||
return waiting_threads; |
|
||||
} |
|
||||
|
|
||||
} // namespace Kernel
|
|
||||
@ -1,77 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project |
|
||||
// Licensed under GPLv2 or any later version |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <atomic> |
|
||||
#include <memory> |
|
||||
#include <vector> |
|
||||
|
|
||||
#include "core/hle/kernel/object.h" |
|
||||
|
|
||||
namespace Kernel { |
|
||||
|
|
||||
class KernelCore; |
|
||||
class Synchronization; |
|
||||
class Thread; |
|
||||
|
|
||||
/// Class that represents a Kernel object that a thread can be waiting on |
|
||||
class SynchronizationObject : public Object { |
|
||||
public: |
|
||||
explicit SynchronizationObject(KernelCore& kernel); |
|
||||
~SynchronizationObject() override; |
|
||||
|
|
||||
/** |
|
||||
* Check if the specified thread should wait until the object is available |
|
||||
* @param thread The thread about which we're deciding. |
|
||||
* @return True if the current thread should wait due to this object being unavailable |
|
||||
*/ |
|
||||
virtual bool ShouldWait(const Thread* thread) const = 0; |
|
||||
|
|
||||
/// Acquire/lock the object for the specified thread if it is available |
|
||||
virtual void Acquire(Thread* thread) = 0; |
|
||||
|
|
||||
/// Signal this object |
|
||||
virtual void Signal(); |
|
||||
|
|
||||
virtual bool IsSignaled() const { |
|
||||
return is_signaled; |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Add a thread to wait on this object |
|
||||
* @param thread Pointer to thread to add |
|
||||
*/ |
|
||||
void AddWaitingThread(std::shared_ptr<Thread> thread); |
|
||||
|
|
||||
/** |
|
||||
* Removes a thread from waiting on this object (e.g. if it was resumed already) |
|
||||
* @param thread Pointer to thread to remove |
|
||||
*/ |
|
||||
void RemoveWaitingThread(std::shared_ptr<Thread> thread); |
|
||||
|
|
||||
/// Get a const reference to the waiting threads list for debug use |
|
||||
const std::vector<std::shared_ptr<Thread>>& GetWaitingThreads() const; |
|
||||
|
|
||||
void ClearWaitingThreads(); |
|
||||
|
|
||||
protected: |
|
||||
std::atomic_bool is_signaled{}; // Tells if this sync object is signaled |
|
||||
|
|
||||
private: |
|
||||
/// Threads waiting for this object to become available |
|
||||
std::vector<std::shared_ptr<Thread>> waiting_threads; |
|
||||
}; |
|
||||
|
|
||||
// Specialization of DynamicObjectCast for SynchronizationObjects |
|
||||
template <> |
|
||||
inline std::shared_ptr<SynchronizationObject> DynamicObjectCast<SynchronizationObject>( |
|
||||
std::shared_ptr<Object> object) { |
|
||||
if (object != nullptr && object->IsWaitable()) { |
|
||||
return std::static_pointer_cast<SynchronizationObject>(object); |
|
||||
} |
|
||||
return nullptr; |
|
||||
} |
|
||||
|
|
||||
} // namespace Kernel |
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue