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