Fernando Sahmkow
6 years ago
19 changed files with 8 additions and 740 deletions
-
2src/core/CMakeLists.txt
-
1src/core/arm/dynarmic/arm_dynarmic_32.cpp
-
1src/core/arm/dynarmic/arm_dynarmic_64.cpp
-
51src/core/core_manager.cpp
-
63src/core/core_manager.h
-
1src/core/gdbstub/gdbstub.cpp
-
2src/core/hle/kernel/client_port.cpp
-
81src/core/hle/kernel/kernel.cpp
-
3src/core/hle/kernel/kernel.h
-
3src/core/hle/kernel/svc.cpp
-
64src/core/hle/kernel/synchronization_object.cpp
-
15src/core/hle/kernel/synchronization_object.h
-
34src/core/hle/kernel/thread.cpp
-
56src/core/hle/kernel/thread.h
-
2src/core/hle/service/sm/sm.cpp
-
206src/core/host_timing.cpp
-
160src/core/host_timing.h
-
1src/tests/core/core_timing.cpp
-
2src/yuzu/debugger/wait_tree.cpp
@ -1,51 +0,0 @@ |
|||||
// Copyright 2018 yuzu emulator team
|
|
||||
// Licensed under GPLv2 or any later version
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include <condition_variable>
|
|
||||
#include <mutex>
|
|
||||
|
|
||||
#include "common/logging/log.h"
|
|
||||
#include "core/arm/exclusive_monitor.h"
|
|
||||
#include "core/arm/unicorn/arm_unicorn.h"
|
|
||||
#include "core/core.h"
|
|
||||
#include "core/core_manager.h"
|
|
||||
#include "core/core_timing.h"
|
|
||||
#include "core/hle/kernel/kernel.h"
|
|
||||
#include "core/hle/kernel/physical_core.h"
|
|
||||
#include "core/hle/kernel/scheduler.h"
|
|
||||
#include "core/hle/kernel/thread.h"
|
|
||||
#include "core/hle/lock.h"
|
|
||||
#include "core/settings.h"
|
|
||||
|
|
||||
namespace Core { |
|
||||
|
|
||||
CoreManager::CoreManager(System& system, std::size_t core_index) |
|
||||
: global_scheduler{system.GlobalScheduler()}, physical_core{system.Kernel().PhysicalCore( |
|
||||
core_index)}, |
|
||||
core_timing{system.CoreTiming()}, core_index{core_index} {} |
|
||||
|
|
||||
CoreManager::~CoreManager() = default; |
|
||||
|
|
||||
void CoreManager::RunLoop(bool tight_loop) { |
|
||||
/// Deprecated
|
|
||||
} |
|
||||
|
|
||||
void CoreManager::SingleStep() { |
|
||||
return RunLoop(false); |
|
||||
} |
|
||||
|
|
||||
void CoreManager::PrepareReschedule() { |
|
||||
//physical_core.Stop();
|
|
||||
} |
|
||||
|
|
||||
void CoreManager::Reschedule() { |
|
||||
// Lock the global kernel mutex when we manipulate the HLE state
|
|
||||
std::lock_guard lock(HLE::g_hle_lock); |
|
||||
|
|
||||
// global_scheduler.SelectThread(core_index);
|
|
||||
|
|
||||
physical_core.Scheduler().TryDoContextSwitch(); |
|
||||
} |
|
||||
|
|
||||
} // namespace Core
|
|
||||
@ -1,63 +0,0 @@ |
|||||
// Copyright 2018 yuzu emulator team |
|
||||
// Licensed under GPLv2 or any later version |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <atomic> |
|
||||
#include <cstddef> |
|
||||
#include <memory> |
|
||||
#include "common/common_types.h" |
|
||||
|
|
||||
namespace Kernel { |
|
||||
class GlobalScheduler; |
|
||||
class PhysicalCore; |
|
||||
} // namespace Kernel |
|
||||
|
|
||||
namespace Core { |
|
||||
class System; |
|
||||
} |
|
||||
|
|
||||
namespace Core::Timing { |
|
||||
class CoreTiming; |
|
||||
} |
|
||||
|
|
||||
namespace Core::Memory { |
|
||||
class Memory; |
|
||||
} |
|
||||
|
|
||||
namespace Core { |
|
||||
|
|
||||
constexpr unsigned NUM_CPU_CORES{4}; |
|
||||
|
|
||||
class CoreManager { |
|
||||
public: |
|
||||
CoreManager(System& system, std::size_t core_index); |
|
||||
~CoreManager(); |
|
||||
|
|
||||
void RunLoop(bool tight_loop = true); |
|
||||
|
|
||||
void SingleStep(); |
|
||||
|
|
||||
void PrepareReschedule(); |
|
||||
|
|
||||
bool IsMainCore() const { |
|
||||
return core_index == 0; |
|
||||
} |
|
||||
|
|
||||
std::size_t CoreIndex() const { |
|
||||
return core_index; |
|
||||
} |
|
||||
|
|
||||
private: |
|
||||
void Reschedule(); |
|
||||
|
|
||||
Kernel::GlobalScheduler& global_scheduler; |
|
||||
Kernel::PhysicalCore& physical_core; |
|
||||
Timing::CoreTiming& core_timing; |
|
||||
|
|
||||
std::atomic<bool> reschedule_pending = false; |
|
||||
std::size_t core_index; |
|
||||
}; |
|
||||
|
|
||||
} // namespace Core |
|
||||
@ -1,206 +0,0 @@ |
|||||
// Copyright 2020 yuzu Emulator Project
|
|
||||
// Licensed under GPLv2 or any later version
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include "core/host_timing.h"
|
|
||||
|
|
||||
#include <algorithm>
|
|
||||
#include <mutex>
|
|
||||
#include <string>
|
|
||||
#include <tuple>
|
|
||||
|
|
||||
#include "common/assert.h"
|
|
||||
#include "core/core_timing_util.h"
|
|
||||
|
|
||||
namespace Core::HostTiming { |
|
||||
|
|
||||
std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback) { |
|
||||
return std::make_shared<EventType>(std::move(callback), std::move(name)); |
|
||||
} |
|
||||
|
|
||||
struct CoreTiming::Event { |
|
||||
u64 time; |
|
||||
u64 fifo_order; |
|
||||
u64 userdata; |
|
||||
std::weak_ptr<EventType> type; |
|
||||
|
|
||||
// Sort by time, unless the times are the same, in which case sort by
|
|
||||
// the order added to the queue
|
|
||||
friend bool operator>(const Event& left, const Event& right) { |
|
||||
return std::tie(left.time, left.fifo_order) > std::tie(right.time, right.fifo_order); |
|
||||
} |
|
||||
|
|
||||
friend bool operator<(const Event& left, const Event& right) { |
|
||||
return std::tie(left.time, left.fifo_order) < std::tie(right.time, right.fifo_order); |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
CoreTiming::CoreTiming() { |
|
||||
clock = |
|
||||
Common::CreateBestMatchingClock(Core::Hardware::BASE_CLOCK_RATE, Core::Hardware::CNTFREQ); |
|
||||
} |
|
||||
|
|
||||
CoreTiming::~CoreTiming() = default; |
|
||||
|
|
||||
void CoreTiming::ThreadEntry(CoreTiming& instance) { |
|
||||
instance.ThreadLoop(); |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::Initialize() { |
|
||||
event_fifo_id = 0; |
|
||||
const auto empty_timed_callback = [](u64, s64) {}; |
|
||||
ev_lost = CreateEvent("_lost_event", empty_timed_callback); |
|
||||
timer_thread = std::make_unique<std::thread>(ThreadEntry, std::ref(*this)); |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::Shutdown() { |
|
||||
paused = true; |
|
||||
shutting_down = true; |
|
||||
event.Set(); |
|
||||
timer_thread->join(); |
|
||||
ClearPendingEvents(); |
|
||||
timer_thread.reset(); |
|
||||
has_started = false; |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::Pause(bool is_paused) { |
|
||||
paused = is_paused; |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::SyncPause(bool is_paused) { |
|
||||
if (is_paused == paused && paused_set == paused) { |
|
||||
return; |
|
||||
} |
|
||||
Pause(is_paused); |
|
||||
event.Set(); |
|
||||
while (paused_set != is_paused) |
|
||||
; |
|
||||
} |
|
||||
|
|
||||
bool CoreTiming::IsRunning() const { |
|
||||
return !paused_set; |
|
||||
} |
|
||||
|
|
||||
bool CoreTiming::HasPendingEvents() const { |
|
||||
return !(wait_set && event_queue.empty()); |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::ScheduleEvent(s64 ns_into_future, const std::shared_ptr<EventType>& event_type, |
|
||||
u64 userdata) { |
|
||||
basic_lock.lock(); |
|
||||
const u64 timeout = static_cast<u64>(GetGlobalTimeNs().count() + ns_into_future); |
|
||||
|
|
||||
event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type}); |
|
||||
|
|
||||
std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>()); |
|
||||
basic_lock.unlock(); |
|
||||
event.Set(); |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata) { |
|
||||
basic_lock.lock(); |
|
||||
const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) { |
|
||||
return e.type.lock().get() == event_type.get() && e.userdata == userdata; |
|
||||
}); |
|
||||
|
|
||||
// Removing random items breaks the invariant so we have to re-establish it.
|
|
||||
if (itr != event_queue.end()) { |
|
||||
event_queue.erase(itr, event_queue.end()); |
|
||||
std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>()); |
|
||||
} |
|
||||
basic_lock.unlock(); |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::AddTicks(std::size_t core_index, u64 ticks) { |
|
||||
ticks_count[core_index] += ticks; |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::ResetTicks(std::size_t core_index) { |
|
||||
ticks_count[core_index] = 0; |
|
||||
} |
|
||||
|
|
||||
u64 CoreTiming::GetCPUTicks() const { |
|
||||
return clock->GetCPUCycles(); |
|
||||
} |
|
||||
|
|
||||
u64 CoreTiming::GetClockTicks() const { |
|
||||
return clock->GetClockCycles(); |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::ClearPendingEvents() { |
|
||||
event_queue.clear(); |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) { |
|
||||
basic_lock.lock(); |
|
||||
|
|
||||
const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) { |
|
||||
return e.type.lock().get() == event_type.get(); |
|
||||
}); |
|
||||
|
|
||||
// Removing random items breaks the invariant so we have to re-establish it.
|
|
||||
if (itr != event_queue.end()) { |
|
||||
event_queue.erase(itr, event_queue.end()); |
|
||||
std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>()); |
|
||||
} |
|
||||
basic_lock.unlock(); |
|
||||
} |
|
||||
|
|
||||
std::optional<u64> CoreTiming::Advance() { |
|
||||
advance_lock.lock(); |
|
||||
basic_lock.lock(); |
|
||||
global_timer = GetGlobalTimeNs().count(); |
|
||||
|
|
||||
while (!event_queue.empty() && event_queue.front().time <= global_timer) { |
|
||||
Event evt = std::move(event_queue.front()); |
|
||||
std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<>()); |
|
||||
event_queue.pop_back(); |
|
||||
basic_lock.unlock(); |
|
||||
|
|
||||
if (auto event_type{evt.type.lock()}) { |
|
||||
event_type->callback(evt.userdata, global_timer - evt.time); |
|
||||
} |
|
||||
|
|
||||
basic_lock.lock(); |
|
||||
} |
|
||||
|
|
||||
if (!event_queue.empty()) { |
|
||||
const u64 next_time = event_queue.front().time - global_timer; |
|
||||
basic_lock.unlock(); |
|
||||
advance_lock.unlock(); |
|
||||
return next_time; |
|
||||
} else { |
|
||||
basic_lock.unlock(); |
|
||||
advance_lock.unlock(); |
|
||||
return std::nullopt; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
void CoreTiming::ThreadLoop() { |
|
||||
has_started = true; |
|
||||
while (!shutting_down) { |
|
||||
while (!paused) { |
|
||||
paused_set = false; |
|
||||
const auto next_time = Advance(); |
|
||||
if (next_time) { |
|
||||
std::chrono::nanoseconds next_time_ns = std::chrono::nanoseconds(*next_time); |
|
||||
event.WaitFor(next_time_ns); |
|
||||
} else { |
|
||||
wait_set = true; |
|
||||
event.Wait(); |
|
||||
} |
|
||||
wait_set = false; |
|
||||
} |
|
||||
paused_set = true; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const { |
|
||||
return clock->GetTimeNS(); |
|
||||
} |
|
||||
|
|
||||
std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const { |
|
||||
return clock->GetTimeUS(); |
|
||||
} |
|
||||
|
|
||||
} // namespace Core::HostTiming
|
|
||||
@ -1,160 +0,0 @@ |
|||||
// Copyright 2020 yuzu Emulator Project |
|
||||
// Licensed under GPLv2 or any later version |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <atomic> |
|
||||
#include <chrono> |
|
||||
#include <functional> |
|
||||
#include <memory> |
|
||||
#include <mutex> |
|
||||
#include <optional> |
|
||||
#include <string> |
|
||||
#include <thread> |
|
||||
#include <vector> |
|
||||
|
|
||||
#include "common/common_types.h" |
|
||||
#include "common/spin_lock.h" |
|
||||
#include "common/thread.h" |
|
||||
#include "common/threadsafe_queue.h" |
|
||||
#include "common/wall_clock.h" |
|
||||
#include "core/hardware_properties.h" |
|
||||
|
|
||||
namespace Core::HostTiming { |
|
||||
|
|
||||
/// A callback that may be scheduled for a particular core timing event. |
|
||||
using TimedCallback = std::function<void(u64 userdata, s64 cycles_late)>; |
|
||||
|
|
||||
/// Contains the characteristics of a particular event. |
|
||||
struct EventType { |
|
||||
EventType(TimedCallback&& callback, std::string&& name) |
|
||||
: callback{std::move(callback)}, name{std::move(name)} {} |
|
||||
|
|
||||
/// The event's callback function. |
|
||||
TimedCallback callback; |
|
||||
/// A pointer to the name of the event. |
|
||||
const std::string name; |
|
||||
}; |
|
||||
|
|
||||
/** |
|
||||
* This is a system to schedule events into the emulated machine's future. Time is measured |
|
||||
* in main CPU clock cycles. |
|
||||
* |
|
||||
* To schedule an event, you first have to register its type. This is where you pass in the |
|
||||
* callback. You then schedule events using the type id you get back. |
|
||||
* |
|
||||
* The int cyclesLate that the callbacks get is how many cycles late it was. |
|
||||
* So to schedule a new event on a regular basis: |
|
||||
* inside callback: |
|
||||
* ScheduleEvent(periodInCycles - cyclesLate, callback, "whatever") |
|
||||
*/ |
|
||||
class CoreTiming { |
|
||||
public: |
|
||||
CoreTiming(); |
|
||||
~CoreTiming(); |
|
||||
|
|
||||
CoreTiming(const CoreTiming&) = delete; |
|
||||
CoreTiming(CoreTiming&&) = delete; |
|
||||
|
|
||||
CoreTiming& operator=(const CoreTiming&) = delete; |
|
||||
CoreTiming& operator=(CoreTiming&&) = delete; |
|
||||
|
|
||||
/// CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is |
|
||||
/// required to end slice - 1 and start slice 0 before the first cycle of code is executed. |
|
||||
void Initialize(); |
|
||||
|
|
||||
/// Tears down all timing related functionality. |
|
||||
void Shutdown(); |
|
||||
|
|
||||
/// Pauses/Unpauses the execution of the timer thread. |
|
||||
void Pause(bool is_paused); |
|
||||
|
|
||||
/// Pauses/Unpauses the execution of the timer thread and waits until paused. |
|
||||
void SyncPause(bool is_paused); |
|
||||
|
|
||||
/// Checks if core timing is running. |
|
||||
bool IsRunning() const; |
|
||||
|
|
||||
/// Checks if the timer thread has started. |
|
||||
bool HasStarted() const { |
|
||||
return has_started; |
|
||||
} |
|
||||
|
|
||||
/// Checks if there are any pending time events. |
|
||||
bool HasPendingEvents() const; |
|
||||
|
|
||||
/// Schedules an event in core timing |
|
||||
void ScheduleEvent(s64 ns_into_future, const std::shared_ptr<EventType>& event_type, |
|
||||
u64 userdata = 0); |
|
||||
|
|
||||
void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata); |
|
||||
|
|
||||
/// We only permit one event of each type in the queue at a time. |
|
||||
void RemoveEvent(const std::shared_ptr<EventType>& event_type); |
|
||||
|
|
||||
void AddTicks(std::size_t core_index, u64 ticks); |
|
||||
|
|
||||
void ResetTicks(std::size_t core_index); |
|
||||
|
|
||||
/// Returns current time in emulated CPU cycles |
|
||||
u64 GetCPUTicks() const; |
|
||||
|
|
||||
/// Returns current time in emulated in Clock cycles |
|
||||
u64 GetClockTicks() const; |
|
||||
|
|
||||
/// Returns current time in microseconds. |
|
||||
std::chrono::microseconds GetGlobalTimeUs() const; |
|
||||
|
|
||||
/// Returns current time in nanoseconds. |
|
||||
std::chrono::nanoseconds GetGlobalTimeNs() const; |
|
||||
|
|
||||
/// Checks for events manually and returns time in nanoseconds for next event, threadsafe. |
|
||||
std::optional<u64> Advance(); |
|
||||
|
|
||||
private: |
|
||||
struct Event; |
|
||||
|
|
||||
/// Clear all pending events. This should ONLY be done on exit. |
|
||||
void ClearPendingEvents(); |
|
||||
|
|
||||
static void ThreadEntry(CoreTiming& instance); |
|
||||
void ThreadLoop(); |
|
||||
|
|
||||
std::unique_ptr<Common::WallClock> clock; |
|
||||
|
|
||||
u64 global_timer = 0; |
|
||||
|
|
||||
std::chrono::nanoseconds start_point; |
|
||||
|
|
||||
// The queue is a min-heap using std::make_heap/push_heap/pop_heap. |
|
||||
// We don't use std::priority_queue because we need to be able to serialize, unserialize and |
|
||||
// erase arbitrary events (RemoveEvent()) regardless of the queue order. These aren't |
|
||||
// accomodated by the standard adaptor class. |
|
||||
std::vector<Event> event_queue; |
|
||||
u64 event_fifo_id = 0; |
|
||||
|
|
||||
std::shared_ptr<EventType> ev_lost; |
|
||||
Common::Event event{}; |
|
||||
Common::SpinLock basic_lock{}; |
|
||||
Common::SpinLock advance_lock{}; |
|
||||
std::unique_ptr<std::thread> timer_thread; |
|
||||
std::atomic<bool> paused{}; |
|
||||
std::atomic<bool> paused_set{}; |
|
||||
std::atomic<bool> wait_set{}; |
|
||||
std::atomic<bool> shutting_down{}; |
|
||||
std::atomic<bool> has_started{}; |
|
||||
|
|
||||
std::array<std::atomic<u64>, Core::Hardware::NUM_CPU_CORES> ticks_count{}; |
|
||||
}; |
|
||||
|
|
||||
/// Creates a core timing event with the given name and callback. |
|
||||
/// |
|
||||
/// @param name The name of the core timing event to create. |
|
||||
/// @param callback The callback to execute for the event. |
|
||||
/// |
|
||||
/// @returns An EventType instance representing the created event. |
|
||||
/// |
|
||||
std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback); |
|
||||
|
|
||||
} // namespace Core::HostTiming |
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue