From 095941bf3c3b4dc245110ce662de678c25387731 Mon Sep 17 00:00:00 2001 From: lizzie Date: Thu, 15 Jan 2026 08:54:51 +0000 Subject: [PATCH] inline hle kernel --- src/core/hle/kernel/kernel.cpp | 119 ++++++++++++++++----------------- src/video_core/macro.h | 4 +- 2 files changed, 59 insertions(+), 64 deletions(-) diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 062387a29b..6986a98e35 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -88,11 +88,11 @@ struct KernelCore::Impl { } void Initialize(KernelCore& kernel) { - hardware_timer = std::make_unique(kernel); + hardware_timer.emplace(kernel); hardware_timer->Initialize(); - global_object_list_container = std::make_unique(kernel); - global_scheduler_context = std::make_unique(kernel); + global_object_list_container.emplace(kernel); + global_scheduler_context.emplace(kernel); // Derive the initial memory layout from the emulated board Init::InitializeSlabResourceCounts(kernel); @@ -212,10 +212,9 @@ struct KernelCore::Impl { void InitializePhysicalCores() { for (u32 i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { - const s32 core{static_cast(i)}; - - schedulers[i] = std::make_unique(system.Kernel()); - cores[i] = std::make_unique(system.Kernel(), i); + auto const core = s32(i); + schedulers[i].emplace(system.Kernel()); + cores[i].emplace(system.Kernel(), i); auto* main_thread{Kernel::KThread::Create(system.Kernel())}; main_thread->SetCurrentCore(core); @@ -280,57 +279,56 @@ struct KernelCore::Impl { size -= rc_size; // Initialize the resource managers' shared page manager. - resource_manager_page_manager = std::make_unique(); + resource_manager_page_manager.emplace(); resource_manager_page_manager->Initialize(address, size, std::max(PageSize, KPageBufferSlabHeap::BufferSize)); // Initialize the KPageBuffer slab heap. page_buffer_slab_heap.Initialize(system); // Initialize the fixed-size slabheaps. - app_memory_block_heap = std::make_unique(); - sys_memory_block_heap = std::make_unique(); - block_info_heap = std::make_unique(); - app_memory_block_heap->Initialize(resource_manager_page_manager.get(), ApplicationMemoryBlockSlabHeapSize); - sys_memory_block_heap->Initialize(resource_manager_page_manager.get(), SystemMemoryBlockSlabHeapSize); - block_info_heap->Initialize(resource_manager_page_manager.get(), BlockInfoSlabHeapSize); + app_memory_block_heap.emplace(); + sys_memory_block_heap.emplace(); + block_info_heap.emplace(); + app_memory_block_heap->Initialize(std::addressof(*resource_manager_page_manager), ApplicationMemoryBlockSlabHeapSize); + sys_memory_block_heap->Initialize(std::addressof(*resource_manager_page_manager), SystemMemoryBlockSlabHeapSize); + block_info_heap->Initialize(std::addressof(*resource_manager_page_manager), BlockInfoSlabHeapSize); // Reserve all but a fixed number of remaining pages for the page table heap. const size_t num_pt_pages = resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() - ReservedDynamicPageCount; - page_table_heap = std::make_unique(); + page_table_heap.emplace(); // TODO(bunnei): Pass in address once we support kernel virtual memory allocations. page_table_heap->Initialize( - resource_manager_page_manager.get(), num_pt_pages, + std::addressof(*resource_manager_page_manager), num_pt_pages, /*GetPointer(address + size)*/ nullptr); // Setup the slab managers. KDynamicPageManager* const app_dynamic_page_manager = nullptr; KDynamicPageManager* const sys_dynamic_page_manager = /*KTargetSystem::IsDynamicResourceLimitsEnabled()*/ true - ? resource_manager_page_manager.get() - : nullptr; - app_memory_block_manager = std::make_unique(); - sys_memory_block_manager = std::make_unique(); - app_block_info_manager = std::make_unique(); - sys_block_info_manager = std::make_unique(); - app_page_table_manager = std::make_unique(); - sys_page_table_manager = std::make_unique(); + ? std::addressof(*resource_manager_page_manager) : nullptr; + app_memory_block_manager.emplace(); + sys_memory_block_manager.emplace(); + app_block_info_manager.emplace(); + sys_block_info_manager.emplace(); + app_page_table_manager.emplace(); + sys_page_table_manager.emplace(); - app_memory_block_manager->Initialize(app_dynamic_page_manager, app_memory_block_heap.get()); - sys_memory_block_manager->Initialize(sys_dynamic_page_manager, sys_memory_block_heap.get()); + app_memory_block_manager->Initialize(app_dynamic_page_manager, std::addressof(*app_memory_block_heap)); + sys_memory_block_manager->Initialize(sys_dynamic_page_manager, std::addressof(*sys_memory_block_heap)); - app_block_info_manager->Initialize(app_dynamic_page_manager, block_info_heap.get()); - sys_block_info_manager->Initialize(sys_dynamic_page_manager, block_info_heap.get()); + app_block_info_manager->Initialize(app_dynamic_page_manager, std::addressof(*block_info_heap)); + sys_block_info_manager->Initialize(sys_dynamic_page_manager, std::addressof(*block_info_heap)); - app_page_table_manager->Initialize(app_dynamic_page_manager, page_table_heap.get()); - sys_page_table_manager->Initialize(sys_dynamic_page_manager, page_table_heap.get()); + app_page_table_manager->Initialize(app_dynamic_page_manager, std::addressof(*page_table_heap)); + sys_page_table_manager->Initialize(sys_dynamic_page_manager, std::addressof(*page_table_heap)); // Check that we have the correct number of dynamic pages available. ASSERT(resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() == ReservedDynamicPageCount); // Create the system page table managers. - app_system_resource = std::make_unique(kernel); - sys_system_resource = std::make_unique(kernel); + app_system_resource.emplace(kernel); + sys_system_resource.emplace(kernel); KAutoObject::Create(std::addressof(*app_system_resource)); KAutoObject::Create(std::addressof(*sys_system_resource)); @@ -349,7 +347,7 @@ struct KernelCore::Impl { } void InitializeGlobalData(KernelCore& kernel) { - object_name_global_data = std::make_unique(kernel); + object_name_global_data.emplace(kernel); } void MakeApplicationProcess(KProcess* process) { @@ -431,7 +429,7 @@ struct KernelCore::Impl { } void DeriveInitialMemoryLayout() { - memory_layout = std::make_unique(); + memory_layout.emplace(); // Insert the root region for the virtual memory tree, from which all other regions will // derive. @@ -726,7 +724,7 @@ struct KernelCore::Impl { void InitializeMemoryLayout() { // Initialize the memory manager. - memory_manager = std::make_unique(system); + memory_manager.emplace(system); const auto& management_region = memory_layout->GetPoolManagementRegion(); ASSERT(management_region.GetEndAddress() != 0); memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize()); @@ -774,8 +772,8 @@ struct KernelCore::Impl { std::mutex process_list_lock; std::vector process_list; KProcess* application_process{}; - std::unique_ptr global_scheduler_context; - std::unique_ptr hardware_timer; + std::optional global_scheduler_context; + std::optional hardware_timer; Init::KSlabResourceCounts slab_resource_counts{}; KResourceLimit* system_resource_limit{}; @@ -784,9 +782,9 @@ struct KernelCore::Impl { std::shared_ptr preemption_event; - std::unique_ptr global_object_list_container; + std::optional global_object_list_container; - std::unique_ptr object_name_global_data; + std::optional object_name_global_data; std::unordered_set registered_objects; std::unordered_set registered_in_use_objects; @@ -794,28 +792,28 @@ struct KernelCore::Impl { std::mutex server_lock; std::vector> server_managers; - std::array, Core::Hardware::NUM_CPU_CORES> cores; + std::array, Core::Hardware::NUM_CPU_CORES> cores; // Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others std::atomic next_host_thread_id{Core::Hardware::NUM_CPU_CORES}; // Kernel memory management - std::unique_ptr memory_manager; + std::optional memory_manager; // Resource managers - std::unique_ptr resource_manager_page_manager; - std::unique_ptr page_table_heap; - std::unique_ptr app_memory_block_heap; - std::unique_ptr sys_memory_block_heap; - std::unique_ptr block_info_heap; - std::unique_ptr app_page_table_manager; - std::unique_ptr sys_page_table_manager; - std::unique_ptr app_memory_block_manager; - std::unique_ptr sys_memory_block_manager; - std::unique_ptr app_block_info_manager; - std::unique_ptr sys_block_info_manager; - std::unique_ptr app_system_resource; - std::unique_ptr sys_system_resource; + std::optional resource_manager_page_manager; + std::optional page_table_heap; + std::optional app_memory_block_heap; + std::optional sys_memory_block_heap; + std::optional block_info_heap; + std::optional app_page_table_manager; + std::optional sys_page_table_manager; + std::optional app_memory_block_manager; + std::optional sys_memory_block_manager; + std::optional app_block_info_manager; + std::optional sys_block_info_manager; + std::optional app_system_resource; + std::optional sys_system_resource; // Shared memory for services Kernel::KSharedMemory* hid_shared_mem{}; @@ -825,10 +823,10 @@ struct KernelCore::Impl { Kernel::KSharedMemory* hidbus_shared_mem{}; // Memory layout - std::unique_ptr memory_layout; + std::optional memory_layout; std::array shutdown_threads{}; - std::array, Core::Hardware::NUM_CPU_CORES> schedulers{}; + std::array, Core::Hardware::NUM_CPU_CORES> schedulers{}; bool is_multicore{}; std::atomic_bool is_shutting_down{}; @@ -948,12 +946,9 @@ const Kernel::PhysicalCore& KernelCore::CurrentPhysicalCore() const { } Kernel::KScheduler* KernelCore::CurrentScheduler() { - const u32 core_id = impl->GetCurrentHostThreadID(); - if (core_id >= Core::Hardware::NUM_CPU_CORES) { - // This is expected when called from not a guest thread - return {}; - } - return impl->schedulers[core_id].get(); + if (auto const core_id = impl->GetCurrentHostThreadID(); core_id < Core::Hardware::NUM_CPU_CORES) + return std::addressof(*impl->schedulers[core_id]); + return {}; // This is expected when called from not a guest thread } Kernel::KHardwareTimer& KernelCore::HardwareTimer() { diff --git a/src/video_core/macro.h b/src/video_core/macro.h index 88b9f80ae7..685097a693 100644 --- a/src/video_core/macro.h +++ b/src/video_core/macro.h @@ -100,8 +100,8 @@ union MethodAddress { class CachedMacro { public: - CachedMacro(Engines::Maxwell3D& maxwell3d) - : maxwell3d{maxwell3d} + CachedMacro(Engines::Maxwell3D& maxwell3d_) + : maxwell3d{maxwell3d_} {} virtual ~CachedMacro() = default; /// Executes the macro code with the specified input parameters.