citra-emu
/
citra-nightly
Archived
1
0
Fork 0
Code

Merge pull request #3455 from citra-emu/revert-2968-hle_thread_pause 

Revert "Kernel/Threads: Add a new thread status that will allow using a Kernel::Event to put a guest thread to sleep inside an HLE handler until said event is signaled"
This commit is contained in:
Weiyi Wang 2018-02-22 23:41:54 +02:00 committed by GitHub
parent e2eab46535 26a9c5832d
commit e51a642a13
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 0 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/core/hle/service/service.cpp
View File

@ -9,7 +9,6 @@
#include "common/string_util.h"
#include "core/hle/ipc.h"
#include "core/hle/kernel/client_port.h"
#include "core/hle/kernel/event.h"
#include "core/hle/kernel/process.h"
#include "core/hle/kernel/server_port.h"
#include "core/hle/kernel/server_session.h"
@ -220,47 +219,6 @@ void AddService(Interface* interface_) {
server_port->SetHleHandler(std::shared_ptr<Interface>(interface_));
}
bool ThreadContinuationToken::IsValid() {
return thread != nullptr && event != nullptr;
}
ThreadContinuationToken SleepClientThread(const std::string& reason,
ThreadContinuationToken::Callback callback) {
auto thread = Kernel::GetCurrentThread();
ASSERT(thread->status == THREADSTATUS_RUNNING);
ThreadContinuationToken token;
token.event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
token.thread = thread;
token.callback = std::move(callback);
token.pause_reason = std::move(reason);
// Make the thread wait on our newly created event, it will be signaled when
// ContinueClientThread is called.
thread->status = THREADSTATUS_WAIT_HLE_EVENT;
thread->wait_objects = {token.event};
token.event->AddWaitingThread(thread);
return token;
}
void ContinueClientThread(ThreadContinuationToken& token) {
ASSERT_MSG(token.IsValid(), "Invalid continuation token");
ASSERT(token.thread->status == THREADSTATUS_WAIT_HLE_EVENT);
// Signal the event to wake up the thread
token.event->Signal();
ASSERT(token.thread->status == THREADSTATUS_READY);
token.callback(token.thread);
token.event = nullptr;
token.thread = nullptr;
token.callback = nullptr;
}
/// Initialize ServiceManager
void Init() {
SM::g_service_manager = std::make_shared<SM::ServiceManager>();

40
src/core/hle/service/service.h
View File

@ -20,7 +20,6 @@ namespace Kernel {
class ClientPort;
class ServerPort;
class ServerSession;
class Event;
} // namespace Kernel
namespace Service {
@ -262,45 +261,6 @@ private:
}
};
/*
* Token representing a pause request for a guest thread from an HLE service function.
* Using this token a function can put a guest thread to sleep to defer returning a result from
* SendSyncRequest until an async operation completes on the host. To use it, call SleepClientThread
* to create a specific continuation token for the current thread, perform your async operation, and
* then call ContinueClientThread passing in the returned token as a parameter.
*/
class ThreadContinuationToken {
public:
using Callback = std::function<void(Kernel::SharedPtr<Kernel::Thread> thread)>;
friend ThreadContinuationToken SleepClientThread(const std::string& reason, Callback callback);
friend void ContinueClientThread(ThreadContinuationToken& token);
bool IsValid();
private:
Kernel::SharedPtr<Kernel::Event> event;
Kernel::SharedPtr<Kernel::Thread> thread;
Callback callback;
std::string pause_reason;
};
/*
* Puts the current guest thread to sleep and returns a ThreadContinuationToken to be used with
* ContinueClientThread.
* @param reason Reason for pausing the thread, to be used for debugging purposes.
* @param callback Callback to be invoked when the thread is resumed by ContinueClientThread.
* @returns ThreadContinuationToken representing the pause request.
*/
ThreadContinuationToken SleepClientThread(const std::string& reason,
ThreadContinuationToken::Callback callback);
/*
* Completes a continuation request and resumes the associated guest thread.
* This function invalidates the token.
* @param token The continuation token associated with the continuation request.
*/
void ContinueClientThread(ThreadContinuationToken& token);
/// Initialize ServiceManager
void Init();