blob: 5e97f51bfb39ca497121534cfa4467f29f445f6d (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <array>
#include <atomic>
#include <functional>
#include <memory>
#include <thread>
#include "common/fiber.h"
#include "common/polyfill_thread.h"
#include "common/thread.h"
#include "core/hardware_properties.h"
namespace Kernel {
class KernelCore;
}
namespace Common {
class Event;
class Fiber;
} // namespace Common
namespace Core {
class System;
class CpuManager {
public:
explicit CpuManager(System& system_);
CpuManager(const CpuManager&) = delete;
CpuManager(CpuManager&&) = delete;
~CpuManager();
CpuManager& operator=(const CpuManager&) = delete;
CpuManager& operator=(CpuManager&&) = delete;
/// Sets if emulation is multicore or single core, must be set before Initialize
void SetMulticore(bool is_multi) {
is_multicore = is_multi;
}
/// Sets if emulation is using an asynchronous GPU.
void SetAsyncGpu(bool is_async) {
is_async_gpu = is_async;
}
void OnGpuReady() {
gpu_barrier->Sync();
}
void Initialize();
void Shutdown();
std::function<void()> GetGuestActivateFunc(Kernel::KernelCore& kernel) {
return [this, &kernel] { GuestActivate(kernel); };
}
std::function<void()> GetGuestThreadFunc(Kernel::KernelCore& kernel) {
return [this, &kernel] { GuestThreadFunction(kernel); };
}
std::function<void()> GetIdleThreadStartFunc(Kernel::KernelCore& kernel) {
return [this, &kernel] { IdleThreadFunction(kernel); };
}
std::function<void()> GetShutdownThreadStartFunc(Kernel::KernelCore& kernel) {
return [this, &kernel] { ShutdownThreadFunction(kernel); };
}
void PreemptSingleCore(Kernel::KernelCore& kernel, bool from_running_environment = true);
std::size_t CurrentCore() const {
return current_core.load();
}
private:
void GuestThreadFunction(Kernel::KernelCore& kernel);
void IdleThreadFunction(Kernel::KernelCore& kernel);
void ShutdownThreadFunction(Kernel::KernelCore& kernel);
void MultiCoreRunGuestThread(Kernel::KernelCore& kernel);
void MultiCoreRunIdleThread(Kernel::KernelCore& kernel);
void SingleCoreRunGuestThread(Kernel::KernelCore& kernel);
void SingleCoreRunIdleThread(Kernel::KernelCore& kernel);
void GuestActivate(Kernel::KernelCore& kernel);
void HandleInterrupt(Kernel::KernelCore& kernel);
void ShutdownThread(Kernel::KernelCore& kernel);
void RunThread(std::stop_token stop_token, std::size_t core);
static constexpr std::size_t max_cycle_runs = 5;
std::optional<Common::Barrier> gpu_barrier{};
struct CoreData {
std::shared_ptr<Common::Fiber> host_context;
std::jthread host_thread;
};
std::array<CoreData, Core::Hardware::NUM_CPU_CORES> core_data{};
Core::System& system;
std::atomic<std::size_t> current_core{};
std::size_t idle_count{};
std::size_t num_cores{};
bool is_async_gpu{};
bool is_multicore{};
};
} // namespace Core
|
