cpu_manager.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374
  1. // Copyright 2018 yuzu emulator team
  2. // Licensed under GPLv2 or any later version
  3. // Refer to the license.txt file included.
  4. #include "common/fiber.h"
  5. #include "common/microprofile.h"
  6. #include "common/scope_exit.h"
  7. #include "common/thread.h"
  8. #include "core/arm/exclusive_monitor.h"
  9. #include "core/core.h"
  10. #include "core/core_timing.h"
  11. #include "core/cpu_manager.h"
  12. #include "core/hle/kernel/k_scheduler.h"
  13. #include "core/hle/kernel/k_thread.h"
  14. #include "core/hle/kernel/kernel.h"
  15. #include "core/hle/kernel/physical_core.h"
  16. #include "video_core/gpu.h"
  17. namespace Core {
  18. CpuManager::CpuManager(System& system) : system{system} {}
  19. CpuManager::~CpuManager() = default;
  20. void CpuManager::ThreadStart(CpuManager& cpu_manager, std::size_t core) {
  21. cpu_manager.RunThread(core);
  22. }
  23. void CpuManager::Initialize() {
  24. running_mode = true;
  25. if (is_multicore) {
  26. for (std::size_t core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) {
  27. core_data[core].host_thread =
  28. std::make_unique<std::thread>(ThreadStart, std::ref(*this), core);
  29. }
  30. } else {
  31. core_data[0].host_thread = std::make_unique<std::thread>(ThreadStart, std::ref(*this), 0);
  32. }
  33. }
  34. void CpuManager::Shutdown() {
  35. running_mode = false;
  36. Pause(false);
  37. if (is_multicore) {
  38. for (auto& data : core_data) {
  39. data.host_thread->join();
  40. data.host_thread.reset();
  41. }
  42. } else {
  43. core_data[0].host_thread->join();
  44. core_data[0].host_thread.reset();
  45. }
  46. }
  47. std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
  48. return GuestThreadFunction;
  49. }
  50. std::function<void(void*)> CpuManager::GetIdleThreadStartFunc() {
  51. return IdleThreadFunction;
  52. }
  53. std::function<void(void*)> CpuManager::GetSuspendThreadStartFunc() {
  54. return SuspendThreadFunction;
  55. }
  56. void CpuManager::GuestThreadFunction(void* cpu_manager_) {
  57. CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
  58. if (cpu_manager->is_multicore) {
  59. cpu_manager->MultiCoreRunGuestThread();
  60. } else {
  61. cpu_manager->SingleCoreRunGuestThread();
  62. }
  63. }
  64. void CpuManager::GuestRewindFunction(void* cpu_manager_) {
  65. CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
  66. if (cpu_manager->is_multicore) {
  67. cpu_manager->MultiCoreRunGuestLoop();
  68. } else {
  69. cpu_manager->SingleCoreRunGuestLoop();
  70. }
  71. }
  72. void CpuManager::IdleThreadFunction(void* cpu_manager_) {
  73. CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
  74. if (cpu_manager->is_multicore) {
  75. cpu_manager->MultiCoreRunIdleThread();
  76. } else {
  77. cpu_manager->SingleCoreRunIdleThread();
  78. }
  79. }
  80. void CpuManager::SuspendThreadFunction(void* cpu_manager_) {
  81. CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
  82. if (cpu_manager->is_multicore) {
  83. cpu_manager->MultiCoreRunSuspendThread();
  84. } else {
  85. cpu_manager->SingleCoreRunSuspendThread();
  86. }
  87. }
  88. void* CpuManager::GetStartFuncParamater() {
  89. return static_cast<void*>(this);
  90. }
  91. ///////////////////////////////////////////////////////////////////////////////
  92. /// MultiCore ///
  93. ///////////////////////////////////////////////////////////////////////////////
  94. void CpuManager::MultiCoreRunGuestThread() {
  95. auto& kernel = system.Kernel();
  96. kernel.CurrentScheduler()->OnThreadStart();
  97. auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
  98. auto& host_context = thread->GetHostContext();
  99. host_context->SetRewindPoint(GuestRewindFunction, this);
  100. MultiCoreRunGuestLoop();
  101. }
  102. void CpuManager::MultiCoreRunGuestLoop() {
  103. auto& kernel = system.Kernel();
  104. while (true) {
  105. auto* physical_core = &kernel.CurrentPhysicalCore();
  106. system.EnterDynarmicProfile();
  107. while (!physical_core->IsInterrupted()) {
  108. physical_core->Run();
  109. physical_core = &kernel.CurrentPhysicalCore();
  110. }
  111. system.ExitDynarmicProfile();
  112. physical_core->ArmInterface().ClearExclusiveState();
  113. kernel.CurrentScheduler()->RescheduleCurrentCore();
  114. }
  115. }
  116. void CpuManager::MultiCoreRunIdleThread() {
  117. auto& kernel = system.Kernel();
  118. while (true) {
  119. auto& physical_core = kernel.CurrentPhysicalCore();
  120. physical_core.Idle();
  121. kernel.CurrentScheduler()->RescheduleCurrentCore();
  122. }
  123. }
  124. void CpuManager::MultiCoreRunSuspendThread() {
  125. auto& kernel = system.Kernel();
  126. kernel.CurrentScheduler()->OnThreadStart();
  127. while (true) {
  128. auto core = kernel.GetCurrentHostThreadID();
  129. auto& scheduler = *kernel.CurrentScheduler();
  130. Kernel::KThread* current_thread = scheduler.GetCurrentThread();
  131. Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[core].host_context);
  132. ASSERT(scheduler.ContextSwitchPending());
  133. ASSERT(core == kernel.GetCurrentHostThreadID());
  134. scheduler.RescheduleCurrentCore();
  135. }
  136. }
  137. void CpuManager::MultiCorePause(bool paused) {
  138. if (!paused) {
  139. bool all_not_barrier = false;
  140. while (!all_not_barrier) {
  141. all_not_barrier = true;
  142. for (const auto& data : core_data) {
  143. all_not_barrier &= !data.is_running.load() && data.initialized.load();
  144. }
  145. }
  146. for (auto& data : core_data) {
  147. data.enter_barrier->Set();
  148. }
  149. if (paused_state.load()) {
  150. bool all_barrier = false;
  151. while (!all_barrier) {
  152. all_barrier = true;
  153. for (const auto& data : core_data) {
  154. all_barrier &= data.is_paused.load() && data.initialized.load();
  155. }
  156. }
  157. for (auto& data : core_data) {
  158. data.exit_barrier->Set();
  159. }
  160. }
  161. } else {
  162. /// Wait until all cores are paused.
  163. bool all_barrier = false;
  164. while (!all_barrier) {
  165. all_barrier = true;
  166. for (const auto& data : core_data) {
  167. all_barrier &= data.is_paused.load() && data.initialized.load();
  168. }
  169. }
  170. /// Don't release the barrier
  171. }
  172. paused_state = paused;
  173. }
  174. ///////////////////////////////////////////////////////////////////////////////
  175. /// SingleCore ///
  176. ///////////////////////////////////////////////////////////////////////////////
  177. void CpuManager::SingleCoreRunGuestThread() {
  178. auto& kernel = system.Kernel();
  179. kernel.CurrentScheduler()->OnThreadStart();
  180. auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
  181. auto& host_context = thread->GetHostContext();
  182. host_context->SetRewindPoint(GuestRewindFunction, this);
  183. SingleCoreRunGuestLoop();
  184. }
  185. void CpuManager::SingleCoreRunGuestLoop() {
  186. auto& kernel = system.Kernel();
  187. while (true) {
  188. auto* physical_core = &kernel.CurrentPhysicalCore();
  189. system.EnterDynarmicProfile();
  190. if (!physical_core->IsInterrupted()) {
  191. physical_core->Run();
  192. physical_core = &kernel.CurrentPhysicalCore();
  193. }
  194. system.ExitDynarmicProfile();
  195. kernel.SetIsPhantomModeForSingleCore(true);
  196. system.CoreTiming().Advance();
  197. kernel.SetIsPhantomModeForSingleCore(false);
  198. physical_core->ArmInterface().ClearExclusiveState();
  199. PreemptSingleCore();
  200. auto& scheduler = kernel.Scheduler(current_core);
  201. scheduler.RescheduleCurrentCore();
  202. }
  203. }
  204. void CpuManager::SingleCoreRunIdleThread() {
  205. auto& kernel = system.Kernel();
  206. while (true) {
  207. auto& physical_core = kernel.CurrentPhysicalCore();
  208. PreemptSingleCore(false);
  209. system.CoreTiming().AddTicks(1000U);
  210. idle_count++;
  211. auto& scheduler = physical_core.Scheduler();
  212. scheduler.RescheduleCurrentCore();
  213. }
  214. }
  215. void CpuManager::SingleCoreRunSuspendThread() {
  216. auto& kernel = system.Kernel();
  217. kernel.CurrentScheduler()->OnThreadStart();
  218. while (true) {
  219. auto core = kernel.GetCurrentHostThreadID();
  220. auto& scheduler = *kernel.CurrentScheduler();
  221. Kernel::KThread* current_thread = scheduler.GetCurrentThread();
  222. Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[0].host_context);
  223. ASSERT(scheduler.ContextSwitchPending());
  224. ASSERT(core == kernel.GetCurrentHostThreadID());
  225. scheduler.RescheduleCurrentCore();
  226. }
  227. }
  228. void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
  229. {
  230. auto& kernel = system.Kernel();
  231. auto& scheduler = kernel.Scheduler(current_core);
  232. Kernel::KThread* current_thread = scheduler.GetCurrentThread();
  233. if (idle_count >= 4 || from_running_enviroment) {
  234. if (!from_running_enviroment) {
  235. system.CoreTiming().Idle();
  236. idle_count = 0;
  237. }
  238. kernel.SetIsPhantomModeForSingleCore(true);
  239. system.CoreTiming().Advance();
  240. kernel.SetIsPhantomModeForSingleCore(false);
  241. }
  242. current_core.store((current_core + 1) % Core::Hardware::NUM_CPU_CORES);
  243. system.CoreTiming().ResetTicks();
  244. scheduler.Unload(scheduler.GetCurrentThread());
  245. auto& next_scheduler = kernel.Scheduler(current_core);
  246. Common::Fiber::YieldTo(current_thread->GetHostContext(), next_scheduler.ControlContext());
  247. }
  248. // May have changed scheduler
  249. {
  250. auto& scheduler = system.Kernel().Scheduler(current_core);
  251. scheduler.Reload(scheduler.GetCurrentThread());
  252. if (!scheduler.IsIdle()) {
  253. idle_count = 0;
  254. }
  255. }
  256. }
  257. void CpuManager::SingleCorePause(bool paused) {
  258. if (!paused) {
  259. bool all_not_barrier = false;
  260. while (!all_not_barrier) {
  261. all_not_barrier = !core_data[0].is_running.load() && core_data[0].initialized.load();
  262. }
  263. core_data[0].enter_barrier->Set();
  264. if (paused_state.load()) {
  265. bool all_barrier = false;
  266. while (!all_barrier) {
  267. all_barrier = core_data[0].is_paused.load() && core_data[0].initialized.load();
  268. }
  269. core_data[0].exit_barrier->Set();
  270. }
  271. } else {
  272. /// Wait until all cores are paused.
  273. bool all_barrier = false;
  274. while (!all_barrier) {
  275. all_barrier = core_data[0].is_paused.load() && core_data[0].initialized.load();
  276. }
  277. /// Don't release the barrier
  278. }
  279. paused_state = paused;
  280. }
  281. void CpuManager::Pause(bool paused) {
  282. if (is_multicore) {
  283. MultiCorePause(paused);
  284. } else {
  285. SingleCorePause(paused);
  286. }
  287. }
  288. void CpuManager::RunThread(std::size_t core) {
  289. /// Initialization
  290. system.RegisterCoreThread(core);
  291. std::string name;
  292. if (is_multicore) {
  293. name = "yuzu:CPUCore_" + std::to_string(core);
  294. } else {
  295. name = "yuzu:CPUThread";
  296. }
  297. MicroProfileOnThreadCreate(name.c_str());
  298. Common::SetCurrentThreadName(name.c_str());
  299. Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
  300. auto& data = core_data[core];
  301. data.enter_barrier = std::make_unique<Common::Event>();
  302. data.exit_barrier = std::make_unique<Common::Event>();
  303. data.host_context = Common::Fiber::ThreadToFiber();
  304. data.is_running = false;
  305. data.initialized = true;
  306. const bool sc_sync = !is_async_gpu && !is_multicore;
  307. bool sc_sync_first_use = sc_sync;
  308. // Cleanup
  309. SCOPE_EXIT({
  310. data.host_context->Exit();
  311. data.enter_barrier.reset();
  312. data.exit_barrier.reset();
  313. data.initialized = false;
  314. MicroProfileOnThreadExit();
  315. });
  316. /// Running
  317. while (running_mode) {
  318. data.is_running = false;
  319. data.enter_barrier->Wait();
  320. if (sc_sync_first_use) {
  321. system.GPU().ObtainContext();
  322. sc_sync_first_use = false;
  323. }
  324. // Abort if emulation was killed before the session really starts
  325. if (!system.IsPoweredOn()) {
  326. return;
  327. }
  328. auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
  329. data.is_running = true;
  330. Common::Fiber::YieldTo(data.host_context, current_thread->GetHostContext());
  331. data.is_running = false;
  332. data.is_paused = true;
  333. data.exit_barrier->Wait();
  334. data.is_paused = false;
  335. }
  336. }
  337. } // namespace Core