From a6012b73f4a6d06b4e1315e05c9c78085b6ce449 Mon Sep 17 00:00:00 2001 From: Ben Vanik Date: Tue, 14 Jul 2015 23:13:56 -0700 Subject: [PATCH] Switching audio system to platform-agnostic primitives. --- src/xenia/apu/audio_system.cc | 56 ++++---- src/xenia/apu/audio_system.h | 30 ++-- src/xenia/apu/nop/nop_audio_system.cc | 3 +- src/xenia/apu/nop/nop_audio_system.h | 2 +- src/xenia/apu/xaudio2/xaudio2_audio_driver.cc | 19 +-- src/xenia/apu/xaudio2/xaudio2_audio_driver.h | 14 +- src/xenia/apu/xaudio2/xaudio2_audio_system.cc | 3 +- src/xenia/apu/xaudio2/xaudio2_audio_system.h | 2 +- src/xenia/base/threading.h | 132 ++++++++---------- src/xenia/base/threading_win.cc | 18 +-- src/xenia/kernel/xboxkrnl_crypt.cc | 6 +- src/xenia/kernel/xboxkrnl_debug.cc | 9 +- src/xenia/kernel/xobject.cc | 21 +-- 13 files changed, 150 insertions(+), 165 deletions(-) diff --git a/src/xenia/apu/audio_system.cc b/src/xenia/apu/audio_system.cc index 97f692c30..eca7f0939 100644 --- a/src/xenia/apu/audio_system.cc +++ b/src/xenia/apu/audio_system.cc @@ -73,19 +73,14 @@ AudioSystem::AudioSystem(Emulator* emulator) } for (size_t i = 0; i < kMaximumClientCount; ++i) { client_semaphores_[i] = - CreateSemaphore(NULL, 0, kMaximumQueuedFrames, NULL); - wait_handles_[i] = client_semaphores_[i]; + xe::threading::Semaphore::Create(0, kMaximumQueuedFrames); + wait_handles_[i] = client_semaphores_[i].get(); } - shutdown_event_ = CreateEvent(NULL, TRUE, FALSE, NULL); - wait_handles_[kMaximumClientCount] = shutdown_event_; + shutdown_event_ = xe::threading::Event::CreateManualResetEvent(false); + wait_handles_[kMaximumClientCount] = shutdown_event_.get(); } -AudioSystem::~AudioSystem() { - for (size_t i = 0; i < kMaximumClientCount; ++i) { - CloseHandle(client_semaphores_[i]); - } - CloseHandle(shutdown_event_); -} +AudioSystem::~AudioSystem() = default; X_STATUS AudioSystem::Setup() { processor_ = emulator_->processor(); @@ -111,18 +106,17 @@ void AudioSystem::WorkerThreadMain() { // Main run loop. while (worker_running_) { - auto result = - WaitForMultipleObjectsEx(DWORD(xe::countof(wait_handles_)), - wait_handles_, FALSE, INFINITE, FALSE); - if (result == WAIT_FAILED || - result == WAIT_OBJECT_0 + kMaximumClientCount) { + auto result = xe::threading::WaitAny( + wait_handles_, DWORD(xe::countof(wait_handles_)), true); + if (result.first == xe::threading::WaitResult::kFailed || + (result.first == xe::threading::WaitResult::kSuccess && + result.second == kMaximumClientCount)) { continue; } size_t pumped = 0; - if (result >= WAIT_OBJECT_0 && - result <= WAIT_OBJECT_0 + (kMaximumClientCount - 1)) { - size_t index = result - WAIT_OBJECT_0; + if (result.first == xe::threading::WaitResult::kSuccess) { + size_t index = result.second; do { lock_.lock(); uint32_t client_callback = clients_[index].callback; @@ -138,8 +132,9 @@ void AudioSystem::WorkerThreadMain() { pumped++; index++; } while (index < kMaximumClientCount && - WaitForSingleObject(client_semaphores_[index], 0) == - WAIT_OBJECT_0); + xe::threading::Wait(client_semaphores_[index].get(), false, + std::chrono::milliseconds(0)) == + xe::threading::WaitResult::kSuccess); } if (!worker_running_) { @@ -160,7 +155,7 @@ void AudioSystem::Initialize() {} void AudioSystem::Shutdown() { worker_running_ = false; - SetEvent(shutdown_event_); + shutdown_event_->Set(); worker_thread_->Wait(0, 0, 0, nullptr); worker_thread_.reset(); } @@ -172,9 +167,9 @@ X_STATUS AudioSystem::RegisterClient(uint32_t callback, uint32_t callback_arg, auto index = unused_clients_.front(); - auto client_semaphore = client_semaphores_[index]; - BOOL ret = ReleaseSemaphore(client_semaphore, kMaximumQueuedFrames, NULL); - assert_true(ret == TRUE); + auto client_semaphore = client_semaphores_[index].get(); + auto ret = client_semaphore->Release(kMaximumQueuedFrames, nullptr); + assert_true(ret); AudioDriver* driver; auto result = CreateDriver(index, client_semaphore, &driver); @@ -215,13 +210,14 @@ void AudioSystem::UnregisterClient(size_t index) { clients_[index] = {0}; unused_clients_.push(index); - // drain the semaphore of its count - auto client_semaphore = client_semaphores_[index]; - DWORD wait_result; + // Drain the semaphore of its count. + auto client_semaphore = client_semaphores_[index].get(); + xe::threading::WaitResult wait_result; do { - wait_result = WaitForSingleObject(client_semaphore, 0); - } while (wait_result == WAIT_OBJECT_0); - assert_true(wait_result == WAIT_TIMEOUT); + wait_result = xe::threading::Wait(client_semaphore, false, + std::chrono::milliseconds(0)); + } while (wait_result == xe::threading::WaitResult::kSuccess); + assert_true(wait_result == xe::threading::WaitResult::kTimeout); } } // namespace apu diff --git a/src/xenia/apu/audio_system.h b/src/xenia/apu/audio_system.h index 47e248e1f..f4da723cd 100644 --- a/src/xenia/apu/audio_system.h +++ b/src/xenia/apu/audio_system.h @@ -14,11 +14,10 @@ #include #include +#include "xenia/base/threading.h" #include "xenia/emulator.h" #include "xenia/xbox.h" -typedef void* HANDLE; - namespace xe { namespace kernel { class XHostThread; @@ -48,7 +47,15 @@ class AudioSystem { void UnregisterClient(size_t index); void SubmitFrame(size_t index, uint32_t samples_ptr); - virtual X_STATUS CreateDriver(size_t index, HANDLE semaphore, + protected: + AudioSystem(Emulator* emulator); + + virtual void Initialize(); + + void WorkerThreadMain(); + + virtual X_STATUS CreateDriver(size_t index, + xe::threading::Semaphore* semaphore, AudioDriver** out_driver) = 0; virtual void DestroyDriver(AudioDriver* driver) = 0; @@ -56,15 +63,6 @@ class AudioSystem { // XAUDIO2_MAX_QUEUED_BUFFERS)) static const size_t kMaximumQueuedFrames = 64; - protected: - virtual void Initialize(); - - private: - void WorkerThreadMain(); - - protected: - AudioSystem(Emulator* emulator); - Emulator* emulator_; Memory* memory_; cpu::Processor* processor_; @@ -83,9 +81,11 @@ class AudioSystem { uint32_t wrapped_callback_arg; } clients_[kMaximumClientCount]; - HANDLE client_semaphores_[kMaximumClientCount]; - HANDLE shutdown_event_; // Event is always there in case we have no clients. - HANDLE wait_handles_[kMaximumClientCount + 1]; + std::unique_ptr + client_semaphores_[kMaximumClientCount]; + // Event is always there in case we have no clients. + std::unique_ptr shutdown_event_; + xe::threading::WaitHandle* wait_handles_[kMaximumClientCount + 1]; std::queue unused_clients_; }; diff --git a/src/xenia/apu/nop/nop_audio_system.cc b/src/xenia/apu/nop/nop_audio_system.cc index 7f662928f..765efd2e6 100644 --- a/src/xenia/apu/nop/nop_audio_system.cc +++ b/src/xenia/apu/nop/nop_audio_system.cc @@ -23,7 +23,8 @@ NopAudioSystem::NopAudioSystem(Emulator* emulator) : AudioSystem(emulator) {} NopAudioSystem::~NopAudioSystem() = default; -X_STATUS NopAudioSystem::CreateDriver(size_t index, HANDLE wait_handle, +X_STATUS NopAudioSystem::CreateDriver(size_t index, + xe::threading::Semaphore* semaphore, AudioDriver** out_driver) { return X_STATUS_NOT_IMPLEMENTED; } diff --git a/src/xenia/apu/nop/nop_audio_system.h b/src/xenia/apu/nop/nop_audio_system.h index ddbb78487..3b30f3e5f 100644 --- a/src/xenia/apu/nop/nop_audio_system.h +++ b/src/xenia/apu/nop/nop_audio_system.h @@ -23,7 +23,7 @@ class NopAudioSystem : public AudioSystem { static std::unique_ptr Create(Emulator* emulator); - X_STATUS CreateDriver(size_t index, HANDLE wait_handle, + X_STATUS CreateDriver(size_t index, xe::threading::Semaphore* semaphore, AudioDriver** out_driver) override; void DestroyDriver(AudioDriver* driver) override; }; diff --git a/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc b/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc index 8d37a03a2..0c98feffc 100644 --- a/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc +++ b/src/xenia/apu/xaudio2/xaudio2_audio_driver.cc @@ -24,32 +24,27 @@ namespace xaudio2 { class XAudio2AudioDriver::VoiceCallback : public IXAudio2VoiceCallback { public: - VoiceCallback(HANDLE semaphore) : semaphore_(semaphore) {} + VoiceCallback(xe::threading::Semaphore* semaphore) : semaphore_(semaphore) {} ~VoiceCallback() {} void OnStreamEnd() {} void OnVoiceProcessingPassEnd() {} void OnVoiceProcessingPassStart(uint32_t samples_required) {} void OnBufferEnd(void* context) { - BOOL ret = ReleaseSemaphore(semaphore_, 1, NULL); - assert_true(ret == TRUE); + auto ret = semaphore_->Release(1, nullptr); + assert_true(ret); } void OnBufferStart(void* context) {} void OnLoopEnd(void* context) {} void OnVoiceError(void* context, HRESULT result) {} private: - HANDLE semaphore_; + xe::threading::Semaphore* semaphore_ = nullptr; }; -XAudio2AudioDriver::XAudio2AudioDriver(Emulator* emulator, HANDLE semaphore) - : AudioDriver(emulator), - audio_(nullptr), - mastering_voice_(nullptr), - pcm_voice_(nullptr), - semaphore_(semaphore), - voice_callback_(nullptr), - current_frame_(0) { +XAudio2AudioDriver::XAudio2AudioDriver(Emulator* emulator, + xe::threading::Semaphore* semaphore) + : AudioDriver(emulator), semaphore_(semaphore) { static_assert(frame_count_ == XAUDIO2_MAX_QUEUED_BUFFERS, "xaudio header differs"); } diff --git a/src/xenia/apu/xaudio2/xaudio2_audio_driver.h b/src/xenia/apu/xaudio2/xaudio2_audio_driver.h index bae67ebb4..914986b9f 100644 --- a/src/xenia/apu/xaudio2/xaudio2_audio_driver.h +++ b/src/xenia/apu/xaudio2/xaudio2_audio_driver.h @@ -22,7 +22,7 @@ namespace xaudio2 { class XAudio2AudioDriver : public AudioDriver { public: - XAudio2AudioDriver(Emulator* emulator, HANDLE semaphore); + XAudio2AudioDriver(Emulator* emulator, xe::threading::Semaphore* semaphore); ~XAudio2AudioDriver() override; void Initialize(); @@ -30,13 +30,13 @@ class XAudio2AudioDriver : public AudioDriver { void Shutdown(); private: - IXAudio2* audio_; - IXAudio2MasteringVoice* mastering_voice_; - IXAudio2SourceVoice* pcm_voice_; - HANDLE semaphore_; + IXAudio2* audio_ = nullptr; + IXAudio2MasteringVoice* mastering_voice_ = nullptr; + IXAudio2SourceVoice* pcm_voice_ = nullptr; + xe::threading::Semaphore* semaphore_ = nullptr; class VoiceCallback; - VoiceCallback* voice_callback_; + VoiceCallback* voice_callback_ = nullptr; static const uint32_t frame_count_ = 64; static const uint32_t frame_channels_ = 6; @@ -44,7 +44,7 @@ class XAudio2AudioDriver : public AudioDriver { static const uint32_t frame_samples_ = frame_channels_ * channel_samples_; static const uint32_t frame_size_ = sizeof(float) * frame_samples_; float frames_[frame_count_][frame_samples_]; - uint32_t current_frame_; + uint32_t current_frame_ = 0; }; } // namespace xaudio2 diff --git a/src/xenia/apu/xaudio2/xaudio2_audio_system.cc b/src/xenia/apu/xaudio2/xaudio2_audio_system.cc index 0c8f05852..f67d5609e 100644 --- a/src/xenia/apu/xaudio2/xaudio2_audio_system.cc +++ b/src/xenia/apu/xaudio2/xaudio2_audio_system.cc @@ -30,7 +30,8 @@ XAudio2AudioSystem::~XAudio2AudioSystem() {} void XAudio2AudioSystem::Initialize() { AudioSystem::Initialize(); } -X_STATUS XAudio2AudioSystem::CreateDriver(size_t index, HANDLE semaphore, +X_STATUS XAudio2AudioSystem::CreateDriver(size_t index, + xe::threading::Semaphore* semaphore, AudioDriver** out_driver) { assert_not_null(out_driver); auto driver = new XAudio2AudioDriver(emulator_, semaphore); diff --git a/src/xenia/apu/xaudio2/xaudio2_audio_system.h b/src/xenia/apu/xaudio2/xaudio2_audio_system.h index 0b879578b..4c7c45ab4 100644 --- a/src/xenia/apu/xaudio2/xaudio2_audio_system.h +++ b/src/xenia/apu/xaudio2/xaudio2_audio_system.h @@ -23,7 +23,7 @@ class XAudio2AudioSystem : public AudioSystem { static std::unique_ptr Create(Emulator* emulator); - X_RESULT CreateDriver(size_t index, HANDLE semaphore, + X_RESULT CreateDriver(size_t index, xe::threading::Semaphore* semaphore, AudioDriver** out_driver) override; void DestroyDriver(AudioDriver* driver) override; diff --git a/src/xenia/base/threading.h b/src/xenia/base/threading.h index 5c876a028..0116d6165 100644 --- a/src/xenia/base/threading.h +++ b/src/xenia/base/threading.h @@ -111,83 +111,73 @@ class WaitHandle { public: virtual ~WaitHandle() = default; - // Waits until the wait handle is in the signaled state, an alert triggers and - // a user callback is queued to the thread, or the timeout interval elapses. - // If timeout is zero the call will return immediately instead of waiting and - // if the timeout is max() the wait will not time out. - inline WaitResult Wait( - bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { - return WaitHandle::Wait(this, is_alertable, timeout); - } - - // Waits until the wait handle is in the signaled state, an alert triggers and - // a user callback is queued to the thread, or the timeout interval elapses. - // If timeout is zero the call will return immediately instead of waiting and - // if the timeout is max() the wait will not time out. - static WaitResult Wait( - WaitHandle* wait_handle, bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()); - - // Signals one object and waits on another object as a single operation. - // Waits until the wait handle is in the signaled state, an alert triggers and - // a user callback is queued to the thread, or the timeout interval elapses. - // If timeout is zero the call will return immediately instead of waiting and - // if the timeout is max() the wait will not time out. - static WaitResult SignalAndWait( - WaitHandle* wait_handle_to_signal, WaitHandle* wait_handle_to_wait_on, - bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()); - - // Waits until all of the specified objects are in the signaled state, a - // user callback is queued to the thread, or the time-out interval elapses. - // If timeout is zero the call will return immediately instead of waiting and - // if the timeout is max() the wait will not time out. - inline static WaitResult WaitAll( - WaitHandle* wait_handles[], size_t wait_handle_count, bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { - return WaitMultiple(wait_handles, wait_handle_count, true, is_alertable, - timeout).first; - } - inline static WaitResult WaitAll( - std::vector wait_handles, bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { - return WaitAll(wait_handles.data(), wait_handles.size(), is_alertable, - timeout); - } - - // Waits until any of the specified objects are in the signaled state, a - // user callback is queued to the thread, or the time-out interval elapses. - // If timeout is zero the call will return immediately instead of waiting and - // if the timeout is max() the wait will not time out. - // The second argument of the return tuple indicates which wait handle caused - // the wait to be satisfied or abandoned. - inline static std::pair WaitAny( - WaitHandle* wait_handles[], size_t wait_handle_count, bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { - return WaitMultiple(wait_handles, wait_handle_count, false, is_alertable, - timeout); - } - inline static std::pair WaitAny( - std::vector wait_handles, bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { - return WaitAny(wait_handles.data(), wait_handles.size(), is_alertable, - timeout); - } - - protected: - WaitHandle() = default; - // Returns the native handle of the object on the host system. // This value is platform specific. virtual void* native_handle() const = 0; - static std::pair WaitMultiple( - WaitHandle* wait_handles[], size_t wait_handle_count, bool wait_all, - bool is_alertable, - std::chrono::milliseconds timeout = std::chrono::milliseconds::max()); + protected: + WaitHandle() = default; }; +// Waits until the wait handle is in the signaled state, an alert triggers and +// a user callback is queued to the thread, or the timeout interval elapses. +// If timeout is zero the call will return immediately instead of waiting and +// if the timeout is max() the wait will not time out. +WaitResult Wait( + WaitHandle* wait_handle, bool is_alertable, + std::chrono::milliseconds timeout = std::chrono::milliseconds::max()); + +// Signals one object and waits on another object as a single operation. +// Waits until the wait handle is in the signaled state, an alert triggers and +// a user callback is queued to the thread, or the timeout interval elapses. +// If timeout is zero the call will return immediately instead of waiting and +// if the timeout is max() the wait will not time out. +WaitResult SignalAndWait( + WaitHandle* wait_handle_to_signal, WaitHandle* wait_handle_to_wait_on, + bool is_alertable, + std::chrono::milliseconds timeout = std::chrono::milliseconds::max()); + +std::pair WaitMultiple( + WaitHandle* wait_handles[], size_t wait_handle_count, bool wait_all, + bool is_alertable, + std::chrono::milliseconds timeout = std::chrono::milliseconds::max()); + +// Waits until all of the specified objects are in the signaled state, a +// user callback is queued to the thread, or the time-out interval elapses. +// If timeout is zero the call will return immediately instead of waiting and +// if the timeout is max() the wait will not time out. +inline WaitResult WaitAll( + WaitHandle* wait_handles[], size_t wait_handle_count, bool is_alertable, + std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { + return WaitMultiple(wait_handles, wait_handle_count, true, is_alertable, + timeout).first; +} +inline WaitResult WaitAll( + std::vector wait_handles, bool is_alertable, + std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { + return WaitAll(wait_handles.data(), wait_handles.size(), is_alertable, + timeout); +} + +// Waits until any of the specified objects are in the signaled state, a +// user callback is queued to the thread, or the time-out interval elapses. +// If timeout is zero the call will return immediately instead of waiting and +// if the timeout is max() the wait will not time out. +// The second argument of the return tuple indicates which wait handle caused +// the wait to be satisfied or abandoned. +inline std::pair WaitAny( + WaitHandle* wait_handles[], size_t wait_handle_count, bool is_alertable, + std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { + return WaitMultiple(wait_handles, wait_handle_count, false, is_alertable, + timeout); +} +inline std::pair WaitAny( + std::vector wait_handles, bool is_alertable, + std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) { + return WaitAny(wait_handles.data(), wait_handles.size(), is_alertable, + timeout); +} + // Models a Win32-like event object. // https://msdn.microsoft.com/en-us/library/windows/desktop/ms682396(v=vs.85).aspx class Event : public WaitHandle { diff --git a/src/xenia/base/threading_win.cc b/src/xenia/base/threading_win.cc index 609cb348e..3e7b18442 100644 --- a/src/xenia/base/threading_win.cc +++ b/src/xenia/base/threading_win.cc @@ -102,8 +102,8 @@ class Win32Handle : public T { HANDLE handle_ = nullptr; }; -WaitResult WaitHandle::Wait(WaitHandle* wait_handle, bool is_alertable, - std::chrono::milliseconds timeout) { +WaitResult Wait(WaitHandle* wait_handle, bool is_alertable, + std::chrono::milliseconds timeout) { HANDLE handle = wait_handle->native_handle(); DWORD result = WaitForSingleObjectEx(handle, DWORD(timeout.count()), is_alertable ? TRUE : FALSE); @@ -122,10 +122,9 @@ WaitResult WaitHandle::Wait(WaitHandle* wait_handle, bool is_alertable, } } -WaitResult WaitHandle::SignalAndWait(WaitHandle* wait_handle_to_signal, - WaitHandle* wait_handle_to_wait_on, - bool is_alertable, - std::chrono::milliseconds timeout) { +WaitResult SignalAndWait(WaitHandle* wait_handle_to_signal, + WaitHandle* wait_handle_to_wait_on, bool is_alertable, + std::chrono::milliseconds timeout) { HANDLE handle_to_signal = wait_handle_to_signal->native_handle(); HANDLE handle_to_wait_on = wait_handle_to_wait_on->native_handle(); DWORD result = @@ -146,9 +145,10 @@ WaitResult WaitHandle::SignalAndWait(WaitHandle* wait_handle_to_signal, } } -std::pair WaitHandle::WaitMultiple( - WaitHandle* wait_handles[], size_t wait_handle_count, bool wait_all, - bool is_alertable, std::chrono::milliseconds timeout) { +std::pair WaitMultiple(WaitHandle* wait_handles[], + size_t wait_handle_count, + bool wait_all, bool is_alertable, + std::chrono::milliseconds timeout) { std::vector handles(wait_handle_count); for (size_t i = 0; i < wait_handle_count; ++i) { handles[i] = wait_handles[i]->native_handle(); diff --git a/src/xenia/kernel/xboxkrnl_crypt.cc b/src/xenia/kernel/xboxkrnl_crypt.cc index 15dfb5021..c41914610 100644 --- a/src/xenia/kernel/xboxkrnl_crypt.cc +++ b/src/xenia/kernel/xboxkrnl_crypt.cc @@ -17,9 +17,9 @@ namespace xe { namespace kernel { typedef struct { - xe::be count; - xe::be state[5]; - xe::be buffer[64]; + xe::be count; + xe::be state[5]; + uint8_t buffer[64]; } XECRYPT_SHA_STATE; void XeCryptShaInit(pointer_t sha_state) { diff --git a/src/xenia/kernel/xboxkrnl_debug.cc b/src/xenia/kernel/xboxkrnl_debug.cc index 29b7ef1de..c6da0d890 100644 --- a/src/xenia/kernel/xboxkrnl_debug.cc +++ b/src/xenia/kernel/xboxkrnl_debug.cc @@ -7,6 +7,7 @@ ****************************************************************************** */ +#include "xenia/base/debugging.h" #include "xenia/base/logging.h" #include "xenia/kernel/kernel_state.h" #include "xenia/kernel/objects/xthread.h" @@ -17,7 +18,7 @@ namespace xe { namespace kernel { -void DbgBreakPoint() { DebugBreak(); } +void DbgBreakPoint() { xe::debugging::Break(); } DECLARE_XBOXKRNL_EXPORT(DbgBreakPoint, ExportTag::kImportant); // https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx @@ -79,13 +80,13 @@ void RtlRaiseException(pointer_t record) { if (record->exception_code == 0xE06D7363) { // C++ exception. // http://blogs.msdn.com/b/oldnewthing/archive/2010/07/30/10044061.aspx - DebugBreak(); + xe::debugging::Break(); return; } // TODO(benvanik): unwinding. // This is going to suck. - DebugBreak(); + xe::debugging::Break(); } DECLARE_XBOXKRNL_EXPORT(RtlRaiseException, ExportTag::kImportant); @@ -94,7 +95,7 @@ void KeBugCheckEx(dword_t code, dword_t param1, dword_t param2, dword_t param3, XELOGD("*** STOP: 0x%.8X (0x%.8X, 0x%.8X, 0x%.8X, 0x%.8X)", code, param1, param2, param3, param4); fflush(stdout); - DebugBreak(); + xe::debugging::Break(); assert_always(); } DECLARE_XBOXKRNL_EXPORT(KeBugCheckEx, ExportTag::kImportant); diff --git a/src/xenia/kernel/xobject.cc b/src/xenia/kernel/xobject.cc index 4d5a9f332..1b2735625 100644 --- a/src/xenia/kernel/xobject.cc +++ b/src/xenia/kernel/xobject.cc @@ -128,7 +128,8 @@ X_STATUS XObject::Wait(uint32_t wait_reason, uint32_t processor_mode, TimeoutTicksToMs(*opt_timeout))) : std::chrono::milliseconds::max(); - auto result = wait_handle->Wait(alertable ? true : false, timeout_ms); + auto result = + xe::threading::Wait(wait_handle, alertable ? true : false, timeout_ms); switch (result) { case xe::threading::WaitResult::kSuccess: return X_STATUS_SUCCESS; @@ -136,7 +137,7 @@ X_STATUS XObject::Wait(uint32_t wait_reason, uint32_t processor_mode, // Or X_STATUS_ALERTED? return X_STATUS_USER_APC; case xe::threading::WaitResult::kTimeout: - YieldProcessor(); + xe::threading::MaybeYield(); return X_STATUS_TIMEOUT; default: case xe::threading::WaitResult::kAbandoned: @@ -153,7 +154,7 @@ X_STATUS XObject::SignalAndWait(XObject* signal_object, XObject* wait_object, TimeoutTicksToMs(*opt_timeout))) : std::chrono::milliseconds::max(); - auto result = xe::threading::WaitHandle::SignalAndWait( + auto result = xe::threading::SignalAndWait( signal_object->GetWaitHandle(), wait_object->GetWaitHandle(), alertable ? true : false, timeout_ms); switch (result) { @@ -163,7 +164,7 @@ X_STATUS XObject::SignalAndWait(XObject* signal_object, XObject* wait_object, // Or X_STATUS_ALERTED? return X_STATUS_USER_APC; case xe::threading::WaitResult::kTimeout: - YieldProcessor(); + xe::threading::MaybeYield(); return X_STATUS_TIMEOUT; default: case xe::threading::WaitResult::kAbandoned: @@ -188,8 +189,8 @@ X_STATUS XObject::WaitMultiple(uint32_t count, XObject** objects, : std::chrono::milliseconds::max(); if (wait_type) { - auto result = xe::threading::WaitHandle::WaitAny( - std::move(wait_handles), alertable ? true : false, timeout_ms); + auto result = xe::threading::WaitAny(std::move(wait_handles), + alertable ? true : false, timeout_ms); switch (result.first) { case xe::threading::WaitResult::kSuccess: return X_STATUS(result.second); @@ -197,7 +198,7 @@ X_STATUS XObject::WaitMultiple(uint32_t count, XObject** objects, // Or X_STATUS_ALERTED? return X_STATUS_USER_APC; case xe::threading::WaitResult::kTimeout: - YieldProcessor(); + xe::threading::MaybeYield(); return X_STATUS_TIMEOUT; default: case xe::threading::WaitResult::kAbandoned: @@ -206,8 +207,8 @@ X_STATUS XObject::WaitMultiple(uint32_t count, XObject** objects, return X_STATUS_UNSUCCESSFUL; } } else { - auto result = xe::threading::WaitHandle::WaitAll( - std::move(wait_handles), alertable ? true : false, timeout_ms); + auto result = xe::threading::WaitAll(std::move(wait_handles), + alertable ? true : false, timeout_ms); switch (result) { case xe::threading::WaitResult::kSuccess: return X_STATUS_SUCCESS; @@ -215,7 +216,7 @@ X_STATUS XObject::WaitMultiple(uint32_t count, XObject** objects, // Or X_STATUS_ALERTED? return X_STATUS_USER_APC; case xe::threading::WaitResult::kTimeout: - YieldProcessor(); + xe::threading::MaybeYield(); return X_STATUS_TIMEOUT; default: case xe::threading::WaitResult::kAbandoned: