am: Implement SetCpuBoostMode in terms of APM

8.0.0+ identical version of apm

.travis/linux-mingw/build.sh

@@ -1,3 +1,4 @@
 #!/bin/bash -ex
-mkdir "$HOME/.ccache" || true
-docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh
+
+mkdir -p "$HOME/.ccache"
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-mingw /bin/bash /yuzu/.travis/linux-mingw/docker.sh

CMakeLists.txt

@@ -7,6 +7,18 @@ include(CMakeDependentOption)
 
 project(yuzu)
 
+# Get Git submodule dependencies
+find_package(Git QUIET)
+if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
+    execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                    RESULT_VARIABLE GIT_SUBMOD_RESULT)
+    if(NOT GIT_SUBMOD_RESULT EQUAL "0")
+        message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, "
+                "please checkout submodules manually with \"git submodule update --init --recursive\"")
+    endif()
+endif()
+
 # Set bundled sdl2/qt as dependent options.
 # OFF by default, but if ENABLE_SDL2 and MSVC are true then ON
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
@@ -33,22 +45,6 @@ if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
         DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
 endif()
 
-# Sanity check : Check that all submodules are present
-# =======================================================================
-
-function(check_submodules_present)
-    file(READ "${PROJECT_SOURCE_DIR}/.gitmodules" gitmodules)
-    string(REGEX MATCHALL "path *= *[^ \t\r\n]*" gitmodules ${gitmodules})
-    foreach(module ${gitmodules})
-        string(REGEX REPLACE "path *= *" "" module ${module})
-        if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
-            message(FATAL_ERROR "Git submodule ${module} not found. "
-                    "Please run: git submodule update --init --recursive")
-        endif()
-    endforeach()
-endfunction()
-check_submodules_present()
-
 configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
                ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
                COPYONLY)

src/audio_core/audio_renderer.cpp

@@ -217,15 +217,13 @@ std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_co
     if (offset == samples.size()) {
         offset = 0;
 
-        if (!wave_buffer.is_looping && wave_buffer.buffer_sz) {
+        if (!wave_buffer.is_looping) {
             SetWaveIndex(wave_index + 1);
         }
 
-        if (wave_buffer.buffer_sz) {
-            out_status.wave_buffer_consumed++;
-        }
+        out_status.wave_buffer_consumed++;
 
-        if (wave_buffer.end_of_stream || wave_buffer.buffer_sz == 0) {
+        if (wave_buffer.end_of_stream) {
             info.play_state = PlayState::Paused;
         }
     }

src/audio_core/stream.cpp

@@ -105,7 +105,7 @@ void Stream::PlayNextBuffer() {
 
     sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
-    core_timing.ScheduleEvent(GetBufferReleaseCycles(*active_buffer), release_event, {});
+    core_timing.ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
 void Stream::ReleaseActiveBuffer() {

src/core/CMakeLists.txt

@@ -207,6 +207,8 @@ add_library(core STATIC
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
     hle/service/apm/apm.h
+    hle/service/apm/controller.cpp
+    hle/service/apm/controller.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
     hle/service/audio/audctl.cpp
@@ -476,8 +478,6 @@ add_library(core STATIC
     settings.h
     telemetry_session.cpp
     telemetry_session.h
-    tools/freezer.cpp
-    tools/freezer.h
 )
 
 create_target_directory_groups(core)

src/core/core.cpp

@@ -25,6 +25,7 @@
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/apm/controller.h"
 #include "core/hle/service/glue/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
@@ -33,7 +34,6 @@
 #include "core/reporter.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
-#include "core/tools/freezer.h"
 #include "file_sys/cheat_engine.h"
 #include "file_sys/patch_manager.h"
 #include "video_core/debug_utils/debug_utils.h"
@@ -301,11 +301,13 @@ struct System::Impl {
     bool is_powered_on = false;
 
     std::unique_ptr<FileSys::CheatEngine> cheat_engine;
-    std::unique_ptr<Tools::Freezer> memory_freezer;
 
     /// Frontend applets
     Service::AM::Applets::AppletManager applet_manager;
 
+    /// APM (Performance) services
+    Service::APM::Controller apm_controller{core_timing};
+
     /// Glue services
     Service::Glue::ARPManager arp_manager;
 
@@ -568,6 +570,14 @@ const Service::Glue::ARPManager& System::GetARPManager() const {
     return impl->arp_manager;
 }
 
+Service::APM::Controller& System::GetAPMController() {
+    return impl->apm_controller;
+}
+
+const Service::APM::Controller& System::GetAPMController() const {
+    return impl->apm_controller;
+}
+
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -43,6 +43,10 @@ struct AppletFrontendSet;
 class AppletManager;
 } // namespace AM::Applets
 
+namespace APM {
+class Controller;
+}
+
 namespace Glue {
 class ARPManager;
 }
@@ -296,6 +300,10 @@ public:
 
     const Service::Glue::ARPManager& GetARPManager() const;
 
+    Service::APM::Controller& GetAPMController();
+
+    const Service::APM::Controller& GetAPMController() const;
+
 private:
     System();
 

src/core/core_timing.cpp

@@ -56,12 +56,12 @@ void CoreTiming::Initialize() {
 }
 
 void CoreTiming::Shutdown() {
+    MoveEvents();
     ClearPendingEvents();
     UnregisterAllEvents();
 }
 
 EventType* CoreTiming::RegisterEvent(const std::string& name, TimedCallback callback) {
-    std::lock_guard guard{inner_mutex};
     // check for existing type with same name.
     // we want event type names to remain unique so that we can use them for serialization.
     ASSERT_MSG(event_types.find(name) == event_types.end(),
@@ -82,7 +82,6 @@ void CoreTiming::UnregisterAllEvents() {
 
 void CoreTiming::ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
     ASSERT(event_type != nullptr);
-    std::lock_guard guard{inner_mutex};
     const s64 timeout = GetTicks() + cycles_into_future;
 
     // If this event needs to be scheduled before the next advance(), force one early
@@ -94,8 +93,12 @@ void CoreTiming::ScheduleEvent(s64 cycles_into_future, const EventType* event_ty
     std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
 }
 
+void CoreTiming::ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type,
+                                         u64 userdata) {
+    ts_queue.Push(Event{global_timer + cycles_into_future, 0, userdata, event_type});
+}
+
 void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
-    std::lock_guard guard{inner_mutex};
     const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
         return e.type == event_type && e.userdata == userdata;
     });
@@ -107,6 +110,10 @@ void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
     }
 }
 
+void CoreTiming::UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata) {
+    unschedule_queue.Push(std::make_pair(event_type, userdata));
+}
+
 u64 CoreTiming::GetTicks() const {
     u64 ticks = static_cast<u64>(global_timer);
     if (!is_global_timer_sane) {
@@ -128,7 +135,6 @@ void CoreTiming::ClearPendingEvents() {
 }
 
 void CoreTiming::RemoveEvent(const EventType* event_type) {
-    std::lock_guard guard{inner_mutex};
     const auto itr = std::remove_if(event_queue.begin(), event_queue.end(),
                                     [&](const Event& e) { return e.type == event_type; });
 
@@ -139,6 +145,11 @@ void CoreTiming::RemoveEvent(const EventType* event_type) {
     }
 }
 
+void CoreTiming::RemoveNormalAndThreadsafeEvent(const EventType* event_type) {
+    MoveEvents();
+    RemoveEvent(event_type);
+}
+
 void CoreTiming::ForceExceptionCheck(s64 cycles) {
     cycles = std::max<s64>(0, cycles);
     if (downcount <= cycles) {
@@ -151,8 +162,19 @@ void CoreTiming::ForceExceptionCheck(s64 cycles) {
     downcount = static_cast<int>(cycles);
 }
 
+void CoreTiming::MoveEvents() {
+    for (Event ev; ts_queue.Pop(ev);) {
+        ev.fifo_order = event_fifo_id++;
+        event_queue.emplace_back(std::move(ev));
+        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+    }
+}
+
 void CoreTiming::Advance() {
-    std::unique_lock<std::mutex> guard(inner_mutex);
+    MoveEvents();
+    for (std::pair<const EventType*, u64> ev; unschedule_queue.Pop(ev);) {
+        UnscheduleEvent(ev.first, ev.second);
+    }
 
     const int cycles_executed = slice_length - downcount;
     global_timer += cycles_executed;
@@ -164,9 +186,7 @@ void CoreTiming::Advance() {
         Event evt = std::move(event_queue.front());
         std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<>());
         event_queue.pop_back();
-        inner_mutex.unlock();
         evt.type->callback(evt.userdata, global_timer - evt.time);
-        inner_mutex.lock();
     }
 
     is_global_timer_sane = false;

src/core/core_timing.h

@@ -6,7 +6,6 @@
 
 #include <chrono>
 #include <functional>
-#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -68,7 +67,7 @@ public:
     ///
     EventType* RegisterEvent(const std::string& name, TimedCallback callback);
 
-    /// Unregisters all registered events thus far. Note: not thread unsafe
+    /// Unregisters all registered events thus far.
     void UnregisterAllEvents();
 
     /// After the first Advance, the slice lengths and the downcount will be reduced whenever an
@@ -77,10 +76,20 @@ public:
     /// Scheduling from a callback will not update the downcount until the Advance() completes.
     void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata = 0);
 
+    /// This is to be called when outside of hle threads, such as the graphics thread, wants to
+    /// schedule things to be executed on the main thread.
+    ///
+    /// @note This doesn't change slice_length and thus events scheduled by this might be
+    /// called with a delay of up to MAX_SLICE_LENGTH
+    void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type,
+                                 u64 userdata = 0);
+
     void UnscheduleEvent(const EventType* event_type, u64 userdata);
+    void UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata);
 
     /// We only permit one event of each type in the queue at a time.
     void RemoveEvent(const EventType* event_type);
+    void RemoveNormalAndThreadsafeEvent(const EventType* event_type);
 
     void ForceExceptionCheck(s64 cycles);
 
@@ -111,6 +120,7 @@ private:
 
     /// Clear all pending events. This should ONLY be done on exit.
     void ClearPendingEvents();
+    void MoveEvents();
 
     s64 global_timer = 0;
     s64 idled_cycles = 0;
@@ -133,9 +143,14 @@ private:
     // remain stable regardless of rehashes/resizing.
     std::unordered_map<std::string, EventType> event_types;
 
-    EventType* ev_lost = nullptr;
+    // The queue for storing the events from other threads threadsafe until they will be added
+    // to the event_queue by the emu thread
+    Common::MPSCQueue<Event> ts_queue;
 
-    std::mutex inner_mutex;
+    // The queue for unscheduling the events from other threads threadsafe
+    Common::MPSCQueue<std::pair<const EventType*, u64>> unschedule_queue;
+
+    EventType* ev_lost = nullptr;
 };
 
 } // namespace Core::Timing

src/core/hle/kernel/thread.cpp

@@ -76,13 +76,13 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
     // This function might be called from any thread so we have to be cautious and use the
     // thread-safe version of ScheduleEvent.
     const s64 cycles = Core::Timing::nsToCycles(std::chrono::nanoseconds{nanoseconds});
-    Core::System::GetInstance().CoreTiming().ScheduleEvent(
+    Core::System::GetInstance().CoreTiming().ScheduleEventThreadsafe(
         cycles, kernel.ThreadWakeupCallbackEventType(), callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {
-    Core::System::GetInstance().CoreTiming().UnscheduleEvent(kernel.ThreadWakeupCallbackEventType(),
-                                                             callback_handle);
+    Core::System::GetInstance().CoreTiming().UnscheduleEventThreadsafe(
+        kernel.ThreadWakeupCallbackEventType(), callback_handle);
 }
 
 static std::optional<s32> GetNextProcessorId(u64 mask) {

src/core/hle/service/am/am.cpp

@@ -29,7 +29,8 @@
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
 #include "core/hle/service/am/tcap.h"
-#include "core/hle/service/apm/apm.h"
+#include "core/hle/service/apm/controller.h"
+#include "core/hle/service/apm/interface.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -508,8 +509,9 @@ void AppletMessageQueue::OperationModeChanged() {
     on_operation_mode_changed.writable->Signal();
 }
 
-ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue)
-    : ServiceFramework("ICommonStateGetter"), msg_queue(std::move(msg_queue)) {
+ICommonStateGetter::ICommonStateGetter(Core::System& system,
+                                       std::shared_ptr<AppletMessageQueue> msg_queue)
+    : ServiceFramework("ICommonStateGetter"), system(system), msg_queue(std::move(msg_queue)) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
@@ -542,7 +544,7 @@ ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_q
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
         {64, nullptr, "SetTvPowerStateMatchingMode"},
         {65, nullptr, "GetApplicationIdByContentActionName"},
-        {66, nullptr, "SetCpuBoostMode"},
+        {66, &ICommonStateGetter::SetCpuBoostMode, "SetCpuBoostMode"},
         {80, nullptr, "PerformSystemButtonPressingIfInFocus"},
         {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
         {91, nullptr, "GetCurrentPerformanceConfiguration"},
@@ -623,6 +625,16 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&
     }
 }
 
+void ICommonStateGetter::SetCpuBoostMode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called, forwarding to APM:SYS");
+
+    const auto& sm = system.ServiceManager();
+    const auto apm_sys = sm.GetService<APM::APM_Sys>("apm:sys");
+    ASSERT(apm_sys != nullptr);
+
+    apm_sys->SetCpuBoostMode(ctx);
+}
+
 IStorage::IStorage(std::vector<u8> buffer)
     : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
     // clang-format off
@@ -651,13 +663,11 @@ void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
 }
 
 void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
-    const bool use_docked_mode{Settings::values.use_docked_mode};
-    LOG_DEBUG(Service_AM, "called, use_docked_mode={}", use_docked_mode);
+    LOG_DEBUG(Service_AM, "called");
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u32>(use_docked_mode ? APM::PerformanceMode::Docked
-                                             : APM::PerformanceMode::Handheld));
+    rb.PushEnum(system.GetAPMController().GetCurrentPerformanceMode());
 }
 
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {

src/core/hle/service/am/am.h

@@ -145,7 +145,8 @@ private:
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
 public:
-    explicit ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue);
+    explicit ICommonStateGetter(Core::System& system,
+                                std::shared_ptr<AppletMessageQueue> msg_queue);
     ~ICommonStateGetter() override;
 
 private:
@@ -167,7 +168,9 @@ private:
     void GetPerformanceMode(Kernel::HLERequestContext& ctx);
     void GetBootMode(Kernel::HLERequestContext& ctx);
     void GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx);
+    void SetCpuBoostMode(Kernel::HLERequestContext& ctx);
 
+    Core::System& system;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 

src/core/hle/service/am/applet_ae.cpp

@@ -42,7 +42,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
     }
 
     void GetSelfController(Kernel::HLERequestContext& ctx) {
@@ -146,7 +146,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
     }
 
     void GetSelfController(Kernel::HLERequestContext& ctx) {

src/core/hle/service/am/applet_oe.cpp

@@ -80,7 +80,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
     }
 
     void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {

src/core/hle/service/apm/apm.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/apm/interface.h"
@@ -12,11 +11,15 @@ namespace Service::APM {
 Module::Module() = default;
 Module::~Module() = default;
 
-void InstallInterfaces(SM::ServiceManager& service_manager) {
+void InstallInterfaces(Core::System& system) {
     auto module_ = std::make_shared<Module>();
-    std::make_shared<APM>(module_, "apm")->InstallAsService(service_manager);
-    std::make_shared<APM>(module_, "apm:p")->InstallAsService(service_manager);
-    std::make_shared<APM_Sys>()->InstallAsService(service_manager);
+    std::make_shared<APM>(module_, system.GetAPMController(), "apm")
+        ->InstallAsService(system.ServiceManager());
+    std::make_shared<APM>(module_, system.GetAPMController(), "apm:p")
+        ->InstallAsService(system.ServiceManager());
+    std::make_shared<APM>(module_, system.GetAPMController(), "apm:am")
+        ->InstallAsService(system.ServiceManager());
+    std::make_shared<APM_Sys>(system.GetAPMController())->InstallAsService(system.ServiceManager());
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/apm.h

@@ -8,11 +8,6 @@
 
 namespace Service::APM {
 
-enum class PerformanceMode : u8 {
-    Handheld = 0,
-    Docked = 1,
-};
-
 class Module final {
 public:
     Module();
@@ -20,6 +15,6 @@ public:
 };
 
 /// Registers all AM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager);
+void InstallInterfaces(Core::System& system);
 
 } // namespace Service::APM

src/core/hle/service/apm/controller.cpp

@@ -0,0 +1,68 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/core_timing.h"
+#include "core/hle/service/apm/controller.h"
+#include "core/settings.h"
+
+namespace Service::APM {
+
+constexpr PerformanceConfiguration DEFAULT_PERFORMANCE_CONFIGURATION =
+    PerformanceConfiguration::Config7;
+
+Controller::Controller(Core::Timing::CoreTiming& core_timing)
+    : core_timing(core_timing), configs{
+                                    {PerformanceMode::Handheld, DEFAULT_PERFORMANCE_CONFIGURATION},
+                                    {PerformanceMode::Docked, DEFAULT_PERFORMANCE_CONFIGURATION},
+                                } {}
+
+Controller::~Controller() = default;
+
+void Controller::SetPerformanceConfiguration(PerformanceMode mode,
+                                             PerformanceConfiguration config) {
+    static const std::map<PerformanceConfiguration, u32> PCONFIG_TO_SPEED_MAP{
+        {PerformanceConfiguration::Config1, 1020},  {PerformanceConfiguration::Config2, 1020},
+        {PerformanceConfiguration::Config3, 1224},  {PerformanceConfiguration::Config4, 1020},
+        {PerformanceConfiguration::Config5, 1020},  {PerformanceConfiguration::Config6, 1224},
+        {PerformanceConfiguration::Config7, 1020},  {PerformanceConfiguration::Config8, 1020},
+        {PerformanceConfiguration::Config9, 1020},  {PerformanceConfiguration::Config10, 1020},
+        {PerformanceConfiguration::Config11, 1020}, {PerformanceConfiguration::Config12, 1020},
+        {PerformanceConfiguration::Config13, 1785}, {PerformanceConfiguration::Config14, 1785},
+        {PerformanceConfiguration::Config15, 1020}, {PerformanceConfiguration::Config16, 1020},
+    };
+
+    SetClockSpeed(PCONFIG_TO_SPEED_MAP.find(config)->second);
+    configs.insert_or_assign(mode, config);
+}
+
+void Controller::SetFromCpuBoostMode(CpuBoostMode mode) {
+    constexpr std::array<PerformanceConfiguration, 3> BOOST_MODE_TO_CONFIG_MAP{{
+        PerformanceConfiguration::Config7,
+        PerformanceConfiguration::Config13,
+        PerformanceConfiguration::Config15,
+    }};
+
+    SetPerformanceConfiguration(PerformanceMode::Docked,
+                                BOOST_MODE_TO_CONFIG_MAP.at(static_cast<u32>(mode)));
+}
+
+PerformanceMode Controller::GetCurrentPerformanceMode() {
+    return Settings::values.use_docked_mode ? PerformanceMode::Docked : PerformanceMode::Handheld;
+}
+
+PerformanceConfiguration Controller::GetCurrentPerformanceConfiguration(PerformanceMode mode) {
+    if (configs.find(mode) == configs.end()) {
+        configs.insert_or_assign(mode, DEFAULT_PERFORMANCE_CONFIGURATION);
+    }
+
+    return configs[mode];
+}
+
+void Controller::SetClockSpeed(u32 mhz) {
+    LOG_INFO(Service_APM, "called, mhz={:08X}", mhz);
+    // TODO(DarkLordZach): Actually signal core_timing to change clock speed.
+}
+
+} // namespace Service::APM

src/core/hle/service/apm/controller.h

@@ -0,0 +1,70 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <map>
+#include "common/common_types.h"
+
+namespace Core::Timing {
+class CoreTiming;
+}
+
+namespace Service::APM {
+
+enum class PerformanceConfiguration : u32 {
+    Config1 = 0x00010000,
+    Config2 = 0x00010001,
+    Config3 = 0x00010002,
+    Config4 = 0x00020000,
+    Config5 = 0x00020001,
+    Config6 = 0x00020002,
+    Config7 = 0x00020003,
+    Config8 = 0x00020004,
+    Config9 = 0x00020005,
+    Config10 = 0x00020006,
+    Config11 = 0x92220007,
+    Config12 = 0x92220008,
+    Config13 = 0x92220009,
+    Config14 = 0x9222000A,
+    Config15 = 0x9222000B,
+    Config16 = 0x9222000C,
+};
+
+enum class CpuBoostMode : u32 {
+    Disabled = 0,
+    Full = 1,    // CPU + GPU -> Config 13, 14, 15, or 16
+    Partial = 2, // GPU Only -> Config 15 or 16
+};
+
+enum class PerformanceMode : u8 {
+    Handheld = 0,
+    Docked = 1,
+};
+
+// Class to manage the state and change of the emulated system performance.
+// Specifically, this deals with PerformanceMode, which corresponds to the system being docked or
+// undocked, and PerformanceConfig which specifies the exact CPU, GPU, and Memory clocks to operate
+// at. Additionally, this manages 'Boost Mode', which allows games to temporarily overclock the
+// system during times of high load -- this simply maps to different PerformanceConfigs to use.
+class Controller {
+public:
+    Controller(Core::Timing::CoreTiming& core_timing);
+    ~Controller();
+
+    void SetPerformanceConfiguration(PerformanceMode mode, PerformanceConfiguration config);
+    void SetFromCpuBoostMode(CpuBoostMode mode);
+
+    PerformanceMode GetCurrentPerformanceMode();
+    PerformanceConfiguration GetCurrentPerformanceConfiguration(PerformanceMode mode);
+
+private:
+    void SetClockSpeed(u32 mhz);
+
+    std::map<PerformanceMode, PerformanceConfiguration> configs;
+
+    Core::Timing::CoreTiming& core_timing;
+};
+
+} // namespace Service::APM

src/core/hle/service/apm/interface.cpp

@@ -5,43 +5,32 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/apm/apm.h"
+#include "core/hle/service/apm/controller.h"
 #include "core/hle/service/apm/interface.h"
 
 namespace Service::APM {
 
 class ISession final : public ServiceFramework<ISession> {
 public:
-    ISession() : ServiceFramework("ISession") {
+    ISession(Controller& controller) : ServiceFramework("ISession"), controller(controller) {
         static const FunctionInfo functions[] = {
             {0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
             {1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
+            {2, nullptr, "SetCpuOverclockEnabled"},
         };
         RegisterHandlers(functions);
     }
 
 private:
-    enum class PerformanceConfiguration : u32 {
-        Config1 = 0x00010000,
-        Config2 = 0x00010001,
-        Config3 = 0x00010002,
-        Config4 = 0x00020000,
-        Config5 = 0x00020001,
-        Config6 = 0x00020002,
-        Config7 = 0x00020003,
-        Config8 = 0x00020004,
-        Config9 = 0x00020005,
-        Config10 = 0x00020006,
-        Config11 = 0x92220007,
-        Config12 = 0x92220008,
-    };
-
     void SetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
-        auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
-        u32 config = rp.Pop<u32>();
-        LOG_WARNING(Service_APM, "(STUBBED) called mode={} config={}", static_cast<u32>(mode),
-                    config);
+        const auto mode = rp.PopEnum<PerformanceMode>();
+        const auto config = rp.PopEnum<PerformanceConfiguration>();
+        LOG_DEBUG(Service_APM, "called mode={} config={}", static_cast<u32>(mode),
+                  static_cast<u32>(config));
+
+        controller.SetPerformanceConfiguration(mode, config);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -50,20 +39,23 @@ private:
     void GetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
-        auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
-        LOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
+        const auto mode = rp.PopEnum<PerformanceMode>();
+        LOG_DEBUG(Service_APM, "called mode={}", static_cast<u32>(mode));
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(static_cast<u32>(PerformanceConfiguration::Config1));
+        rb.PushEnum(controller.GetCurrentPerformanceConfiguration(mode));
     }
+
+    Controller& controller;
 };
 
-APM::APM(std::shared_ptr<Module> apm, const char* name)
-    : ServiceFramework(name), apm(std::move(apm)) {
+APM::APM(std::shared_ptr<Module> apm, Controller& controller, const char* name)
+    : ServiceFramework(name), apm(std::move(apm)), controller(controller) {
     static const FunctionInfo functions[] = {
         {0, &APM::OpenSession, "OpenSession"},
-        {1, nullptr, "GetPerformanceMode"},
+        {1, &APM::GetPerformanceMode, "GetPerformanceMode"},
+        {6, nullptr, "IsCpuOverclockEnabled"},
     };
     RegisterHandlers(functions);
 }
@@ -75,10 +67,17 @@ void APM::OpenSession(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISession>();
+    rb.PushIpcInterface<ISession>(controller);
 }
 
-APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
+void APM::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_APM, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.PushEnum(controller.GetCurrentPerformanceMode());
+}
+
+APM_Sys::APM_Sys(Controller& controller) : ServiceFramework{"apm:sys"}, controller(controller) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "RequestPerformanceMode"},
@@ -87,8 +86,8 @@ APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
         {3, nullptr, "GetLastThrottlingState"},
         {4, nullptr, "ClearLastThrottlingState"},
         {5, nullptr, "LoadAndApplySettings"},
-        {6, nullptr, "SetCpuBoostMode"},
-        {7, nullptr, "GetCurrentPerformanceConfiguration"},
+        {6, &APM_Sys::SetCpuBoostMode, "SetCpuBoostMode"},
+        {7, &APM_Sys::GetCurrentPerformanceConfiguration, "GetCurrentPerformanceConfiguration"},
     };
     // clang-format on
 
@@ -102,7 +101,28 @@ void APM_Sys::GetPerformanceEvent(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISession>();
+    rb.PushIpcInterface<ISession>(controller);
+}
+
+void APM_Sys::SetCpuBoostMode(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto mode = rp.PopEnum<CpuBoostMode>();
+
+    LOG_DEBUG(Service_APM, "called, mode={:08X}", static_cast<u32>(mode));
+
+    controller.SetFromCpuBoostMode(mode);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void APM_Sys::GetCurrentPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_APM, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushEnum(
+        controller.GetCurrentPerformanceConfiguration(controller.GetCurrentPerformanceMode()));
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/interface.h

@@ -8,24 +8,34 @@
 
 namespace Service::APM {
 
+class Controller;
+class Module;
+
 class APM final : public ServiceFramework<APM> {
 public:
-    explicit APM(std::shared_ptr<Module> apm, const char* name);
+    explicit APM(std::shared_ptr<Module> apm, Controller& controller, const char* name);
     ~APM() override;
 
 private:
     void OpenSession(Kernel::HLERequestContext& ctx);
+    void GetPerformanceMode(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<Module> apm;
+    Controller& controller;
 };
 
 class APM_Sys final : public ServiceFramework<APM_Sys> {
 public:
-    explicit APM_Sys();
+    explicit APM_Sys(Controller& controller);
     ~APM_Sys() override;
 
+    void SetCpuBoostMode(Kernel::HLERequestContext& ctx);
+
 private:
     void GetPerformanceEvent(Kernel::HLERequestContext& ctx);
+    void GetCurrentPerformanceConfiguration(Kernel::HLERequestContext& ctx);
+
+    Controller& controller;
 };
 
 } // namespace Service::APM

src/core/hle/service/service.cpp

@@ -206,7 +206,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system,
     Account::InstallInterfaces(system);
     AM::InstallInterfaces(*sm, nv_flinger, system);
     AOC::InstallInterfaces(*sm);
-    APM::InstallInterfaces(*sm);
+    APM::InstallInterfaces(system);
     Audio::InstallInterfaces(*sm);
     BCAT::InstallInterfaces(*sm);
     BPC::InstallInterfaces(*sm);

src/core/tools/freezer.cpp

@@ -1,188 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"
-#include "core/memory.h"
-#include "core/tools/freezer.h"
-
-namespace Tools {
-
-namespace {
-
-constexpr s64 MEMORY_FREEZER_TICKS = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 60);
-
-u64 MemoryReadWidth(u32 width, VAddr addr) {
-    switch (width) {
-    case 1:
-        return Memory::Read8(addr);
-    case 2:
-        return Memory::Read16(addr);
-    case 4:
-        return Memory::Read32(addr);
-    case 8:
-        return Memory::Read64(addr);
-    default:
-        UNREACHABLE();
-        return 0;
-    }
-}
-
-void MemoryWriteWidth(u32 width, VAddr addr, u64 value) {
-    switch (width) {
-    case 1:
-        Memory::Write8(addr, static_cast<u8>(value));
-        break;
-    case 2:
-        Memory::Write16(addr, static_cast<u16>(value));
-        break;
-    case 4:
-        Memory::Write32(addr, static_cast<u32>(value));
-        break;
-    case 8:
-        Memory::Write64(addr, value);
-        break;
-    default:
-        UNREACHABLE();
-    }
-}
-
-} // Anonymous namespace
-
-Freezer::Freezer(Core::Timing::CoreTiming& core_timing) : core_timing(core_timing) {
-    event = core_timing.RegisterEvent(
-        "MemoryFreezer::FrameCallback",
-        [this](u64 userdata, s64 cycles_late) { FrameCallback(userdata, cycles_late); });
-    core_timing.ScheduleEvent(MEMORY_FREEZER_TICKS, event);
-}
-
-Freezer::~Freezer() {
-    core_timing.UnscheduleEvent(event, 0);
-}
-
-void Freezer::SetActive(bool active) {
-    if (!this->active.exchange(active)) {
-        FillEntryReads();
-        core_timing.ScheduleEvent(MEMORY_FREEZER_TICKS, event);
-        LOG_DEBUG(Common_Memory, "Memory freezer activated!");
-    } else {
-        LOG_DEBUG(Common_Memory, "Memory freezer deactivated!");
-    }
-}
-
-bool Freezer::IsActive() const {
-    return active.load(std::memory_order_relaxed);
-}
-
-void Freezer::Clear() {
-    std::lock_guard lock{entries_mutex};
-
-    LOG_DEBUG(Common_Memory, "Clearing all frozen memory values.");
-
-    entries.clear();
-}
-
-u64 Freezer::Freeze(VAddr address, u32 width) {
-    std::lock_guard lock{entries_mutex};
-
-    const auto current_value = MemoryReadWidth(width, address);
-    entries.push_back({address, width, current_value});
-
-    LOG_DEBUG(Common_Memory,
-              "Freezing memory for address={:016X}, width={:02X}, current_value={:016X}", address,
-              width, current_value);
-
-    return current_value;
-}
-
-void Freezer::Unfreeze(VAddr address) {
-    std::lock_guard lock{entries_mutex};
-
-    LOG_DEBUG(Common_Memory, "Unfreezing memory for address={:016X}", address);
-
-    entries.erase(
-        std::remove_if(entries.begin(), entries.end(),
-                       [&address](const Entry& entry) { return entry.address == address; }),
-        entries.end());
-}
-
-bool Freezer::IsFrozen(VAddr address) const {
-    std::lock_guard lock{entries_mutex};
-
-    return std::find_if(entries.begin(), entries.end(), [&address](const Entry& entry) {
-               return entry.address == address;
-           }) != entries.end();
-}
-
-void Freezer::SetFrozenValue(VAddr address, u64 value) {
-    std::lock_guard lock{entries_mutex};
-
-    const auto iter = std::find_if(entries.begin(), entries.end(), [&address](const Entry& entry) {
-        return entry.address == address;
-    });
-
-    if (iter == entries.end()) {
-        LOG_ERROR(Common_Memory,
-                  "Tried to set freeze value for address={:016X} that is not frozen!", address);
-        return;
-    }
-
-    LOG_DEBUG(Common_Memory,
-              "Manually overridden freeze value for address={:016X}, width={:02X} to value={:016X}",
-              iter->address, iter->width, value);
-    iter->value = value;
-}
-
-std::optional<Freezer::Entry> Freezer::GetEntry(VAddr address) const {
-    std::lock_guard lock{entries_mutex};
-
-    const auto iter = std::find_if(entries.begin(), entries.end(), [&address](const Entry& entry) {
-        return entry.address == address;
-    });
-
-    if (iter == entries.end()) {
-        return std::nullopt;
-    }
-
-    return *iter;
-}
-
-std::vector<Freezer::Entry> Freezer::GetEntries() const {
-    std::lock_guard lock{entries_mutex};
-
-    return entries;
-}
-
-void Freezer::FrameCallback(u64 userdata, s64 cycles_late) {
-    if (!IsActive()) {
-        LOG_DEBUG(Common_Memory, "Memory freezer has been deactivated, ending callback events.");
-        return;
-    }
-
-    std::lock_guard lock{entries_mutex};
-
-    for (const auto& entry : entries) {
-        LOG_DEBUG(Common_Memory,
-                  "Enforcing memory freeze at address={:016X}, value={:016X}, width={:02X}",
-                  entry.address, entry.value, entry.width);
-        MemoryWriteWidth(entry.width, entry.address, entry.value);
-    }
-
-    core_timing.ScheduleEvent(MEMORY_FREEZER_TICKS - cycles_late, event);
-}
-
-void Freezer::FillEntryReads() {
-    std::lock_guard lock{entries_mutex};
-
-    LOG_DEBUG(Common_Memory, "Updating memory freeze entries to current values.");
-
-    for (auto& entry : entries) {
-        entry.value = MemoryReadWidth(entry.width, entry.address);
-    }
-}
-
-} // namespace Tools

src/core/tools/freezer.h

@@ -1,82 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <atomic>
-#include <mutex>
-#include <optional>
-#include <vector>
-#include "common/common_types.h"
-
-namespace Core::Timing {
-class CoreTiming;
-struct EventType;
-} // namespace Core::Timing
-
-namespace Tools {
-
-/**
- * This class allows the user to prevent an application from writing new values to certain memory
- * locations. This has a variety of uses when attempting to reverse a game.
- *
- * One example could be a cheat to prevent Mario from taking damage in SMO. One could freeze the
- * memory address that the game uses to store Mario's health so when he takes damage (and the game
- * tries to write the new health value to memory), the value won't change.
- */
-class Freezer {
-public:
-    struct Entry {
-        VAddr address;
-        u32 width;
-        u64 value;
-    };
-
-    explicit Freezer(Core::Timing::CoreTiming& core_timing);
-    ~Freezer();
-
-    // Enables or disables the entire memory freezer.
-    void SetActive(bool active);
-
-    // Returns whether or not the freezer is active.
-    bool IsActive() const;
-
-    // Removes all entries from the freezer.
-    void Clear();
-
-    // Freezes a value to its current memory address. The value the memory is kept at will be the
-    // value that is read during this function. Width can be 1, 2, 4, or 8 (in bytes).
-    u64 Freeze(VAddr address, u32 width);
-
-    // Unfreezes the memory value at address. If the address isn't frozen, this is a no-op.
-    void Unfreeze(VAddr address);
-
-    // Returns whether or not the address is frozen.
-    bool IsFrozen(VAddr address) const;
-
-    // Sets the value that address should be frozen to. This doesn't change the width set by using
-    // Freeze(). If the value isn't frozen, this will not freeze it and is thus a no-op.
-    void SetFrozenValue(VAddr address, u64 value);
-
-    // Returns the entry corresponding to the address if the address is frozen, otherwise
-    // std::nullopt.
-    std::optional<Entry> GetEntry(VAddr address) const;
-
-    // Returns all the entries in the freezer, an empty vector means nothing is frozen.
-    std::vector<Entry> GetEntries() const;
-
-private:
-    void FrameCallback(u64 userdata, s64 cycles_late);
-    void FillEntryReads();
-
-    std::atomic_bool active{false};
-
-    mutable std::mutex entries_mutex;
-    std::vector<Entry> entries;
-
-    Core::Timing::EventType* event;
-    Core::Timing::CoreTiming& core_timing;
-};
-
-} // namespace Tools

src/tests/core/core_timing.cpp

@@ -99,24 +99,24 @@ TEST_CASE("CoreTiming[Threadsave]", "[core]") {
     core_timing.Advance();
 
     // D -> B -> C -> A -> E
-    core_timing.ScheduleEvent(1000, cb_a, CB_IDS[0]);
-    // Manually force since ScheduleEvent doesn't call it
+    core_timing.ScheduleEventThreadsafe(1000, cb_a, CB_IDS[0]);
+    // Manually force since ScheduleEventThreadsafe doesn't call it
     core_timing.ForceExceptionCheck(1000);
     REQUIRE(1000 == core_timing.GetDowncount());
-    core_timing.ScheduleEvent(500, cb_b, CB_IDS[1]);
-    // Manually force since ScheduleEvent doesn't call it
+    core_timing.ScheduleEventThreadsafe(500, cb_b, CB_IDS[1]);
+    // Manually force since ScheduleEventThreadsafe doesn't call it
     core_timing.ForceExceptionCheck(500);
     REQUIRE(500 == core_timing.GetDowncount());
-    core_timing.ScheduleEvent(800, cb_c, CB_IDS[2]);
-    // Manually force since ScheduleEvent doesn't call it
+    core_timing.ScheduleEventThreadsafe(800, cb_c, CB_IDS[2]);
+    // Manually force since ScheduleEventThreadsafe doesn't call it
     core_timing.ForceExceptionCheck(800);
     REQUIRE(500 == core_timing.GetDowncount());
-    core_timing.ScheduleEvent(100, cb_d, CB_IDS[3]);
-    // Manually force since ScheduleEvent doesn't call it
+    core_timing.ScheduleEventThreadsafe(100, cb_d, CB_IDS[3]);
+    // Manually force since ScheduleEventThreadsafe doesn't call it
     core_timing.ForceExceptionCheck(100);
     REQUIRE(100 == core_timing.GetDowncount());
-    core_timing.ScheduleEvent(1200, cb_e, CB_IDS[4]);
-    // Manually force since ScheduleEvent doesn't call it
+    core_timing.ScheduleEventThreadsafe(1200, cb_e, CB_IDS[4]);
+    // Manually force since ScheduleEventThreadsafe doesn't call it
     core_timing.ForceExceptionCheck(1200);
     REQUIRE(100 == core_timing.GetDowncount());