pineapple-src/src/core/hle/kernel/service_thread.cpp

120 lines
3.6 KiB
C++
Raw Normal View History

2020-12-28 16:15:37 +01:00
// Copyright 2020 yuzu emulator team
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <condition_variable>
#include <functional>
#include <mutex>
#include <thread>
#include <vector>
#include <queue>
#include "common/assert.h"
#include "common/scope_exit.h"
2020-12-29 10:54:52 +01:00
#include "common/thread.h"
2020-12-28 16:15:37 +01:00
#include "core/core.h"
2021-05-02 08:03:43 +02:00
#include "core/hle/kernel/k_session.h"
2020-12-28 16:15:37 +01:00
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/service_thread.h"
#include "core/hle/lock.h"
#include "video_core/renderer_base.h"
namespace Kernel {
class ServiceThread::Impl final {
public:
2020-12-29 10:54:52 +01:00
explicit Impl(KernelCore& kernel, std::size_t num_threads, const std::string& name);
2020-12-28 16:15:37 +01:00
~Impl();
2021-05-02 08:03:43 +02:00
void QueueSyncRequest(KSession& session, std::shared_ptr<HLERequestContext>&& context);
2020-12-28 16:15:37 +01:00
private:
std::vector<std::thread> threads;
std::queue<std::function<void()>> requests;
std::mutex queue_mutex;
std::condition_variable condition;
2020-12-29 10:54:52 +01:00
const std::string service_name;
2020-12-28 16:15:37 +01:00
bool stop{};
};
2020-12-29 10:54:52 +01:00
ServiceThread::Impl::Impl(KernelCore& kernel, std::size_t num_threads, const std::string& name)
: service_name{name} {
2020-12-28 16:15:37 +01:00
for (std::size_t i = 0; i < num_threads; ++i)
2020-12-29 10:54:52 +01:00
threads.emplace_back([this, &kernel] {
2020-12-30 02:38:14 +01:00
Common::SetCurrentThreadName(std::string{"yuzu:HleService:" + service_name}.c_str());
2020-12-29 10:54:52 +01:00
2020-12-28 16:15:37 +01:00
// Wait for first request before trying to acquire a render context
{
std::unique_lock lock{queue_mutex};
condition.wait(lock, [this] { return stop || !requests.empty(); });
}
kernel.RegisterHostThread();
while (true) {
std::function<void()> task;
{
std::unique_lock lock{queue_mutex};
condition.wait(lock, [this] { return stop || !requests.empty(); });
2020-12-29 10:54:52 +01:00
if (stop || requests.empty()) {
2020-12-28 16:15:37 +01:00
return;
}
task = std::move(requests.front());
requests.pop();
}
task();
}
});
}
2021-05-02 08:03:43 +02:00
void ServiceThread::Impl::QueueSyncRequest(KSession& session,
2020-12-28 16:15:37 +01:00
std::shared_ptr<HLERequestContext>&& context) {
{
std::unique_lock lock{queue_mutex};
2020-12-29 10:54:52 +01:00
2021-05-02 08:03:43 +02:00
// Open a reference to the session to ensure it is not closes while the service request
// completes asynchronously.
session.Open();
requests.emplace([session_ptr{&session}, context{std::move(context)}]() {
// Close the reference.
SCOPE_EXIT({ session_ptr->Close(); });
// If the session has been closed, we are done.
if (session_ptr->IsServerClosed()) {
return;
2020-12-29 10:54:52 +01:00
}
2021-05-02 08:03:43 +02:00
// Complete the service request.
KScopedAutoObject server_session{&session_ptr->GetServerSession()};
server_session->CompleteSyncRequest(*context);
2020-12-28 16:15:37 +01:00
});
}
condition.notify_one();
}
ServiceThread::Impl::~Impl() {
{
std::unique_lock lock{queue_mutex};
stop = true;
}
condition.notify_all();
for (std::thread& thread : threads) {
thread.join();
}
}
2020-12-29 10:54:52 +01:00
ServiceThread::ServiceThread(KernelCore& kernel, std::size_t num_threads, const std::string& name)
: impl{std::make_unique<Impl>(kernel, num_threads, name)} {}
2020-12-28 16:15:37 +01:00
ServiceThread::~ServiceThread() = default;
2021-05-02 08:03:43 +02:00
void ServiceThread::QueueSyncRequest(KSession& session,
2020-12-28 16:15:37 +01:00
std::shared_ptr<HLERequestContext>&& context) {
impl->QueueSyncRequest(session, std::move(context));
}
} // namespace Kernel