diff options
| author | 2018-10-23 18:43:45 -0400 | |
|---|---|---|
| committer | 2018-10-23 18:43:45 -0400 | |
| commit | a5106fb9f52cffab3e526d68f930678900abd692 (patch) | |
| tree | ab0f70b87bd486e26a3660cdee8e9fefa923f1c7 /src | |
| parent | Merge pull request #1540 from lioncash/handle (diff) | |
| parent | CMakeLists: Remove EMU_ARCH_BITS definition (diff) | |
| download | yuzu-a5106fb9f52cffab3e526d68f930678900abd692.tar.gz yuzu-a5106fb9f52cffab3e526d68f930678900abd692.tar.xz yuzu-a5106fb9f52cffab3e526d68f930678900abd692.zip | |
Merge pull request #1553 from lioncash/mem
common: Remove memory_util.h/.cpp
Diffstat (limited to 'src')
| -rw-r--r-- | src/common/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | src/common/memory_util.cpp | 177 | ||||
| -rw-r--r-- | src/common/memory_util.h | 21 |
3 files changed, 0 insertions, 200 deletions
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index d0e506689..eccd8f64a 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt | |||
| @@ -64,8 +64,6 @@ add_library(common STATIC | |||
| 64 | logging/text_formatter.cpp | 64 | logging/text_formatter.cpp |
| 65 | logging/text_formatter.h | 65 | logging/text_formatter.h |
| 66 | math_util.h | 66 | math_util.h |
| 67 | memory_util.cpp | ||
| 68 | memory_util.h | ||
| 69 | microprofile.cpp | 67 | microprofile.cpp |
| 70 | microprofile.h | 68 | microprofile.h |
| 71 | microprofileui.h | 69 | microprofileui.h |
diff --git a/src/common/memory_util.cpp b/src/common/memory_util.cpp deleted file mode 100644 index 9736fb12a..000000000 --- a/src/common/memory_util.cpp +++ /dev/null | |||
| @@ -1,177 +0,0 @@ | |||
| 1 | // Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project | ||
| 2 | // Licensed under GPLv2 or any later version | ||
| 3 | // Refer to the license.txt file included. | ||
| 4 | |||
| 5 | #include "common/logging/log.h" | ||
| 6 | #include "common/memory_util.h" | ||
| 7 | |||
| 8 | #ifdef _WIN32 | ||
| 9 | #include <windows.h> | ||
| 10 | // Windows.h needs to be included before psapi.h | ||
| 11 | #include <psapi.h> | ||
| 12 | #include "common/common_funcs.h" | ||
| 13 | #include "common/string_util.h" | ||
| 14 | #else | ||
| 15 | #include <cstdlib> | ||
| 16 | #include <sys/mman.h> | ||
| 17 | #endif | ||
| 18 | |||
| 19 | #if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT) | ||
| 20 | #include <unistd.h> | ||
| 21 | #define PAGE_MASK (getpagesize() - 1) | ||
| 22 | #define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK)) | ||
| 23 | #endif | ||
| 24 | |||
| 25 | // This is purposely not a full wrapper for virtualalloc/mmap, but it | ||
| 26 | // provides exactly the primitive operations that Dolphin needs. | ||
| 27 | |||
| 28 | void* AllocateExecutableMemory(std::size_t size, bool low) { | ||
| 29 | #if defined(_WIN32) | ||
| 30 | void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE); | ||
| 31 | #else | ||
| 32 | static char* map_hint = nullptr; | ||
| 33 | #if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT) | ||
| 34 | // This OS has no flag to enforce allocation below the 4 GB boundary, | ||
| 35 | // but if we hint that we want a low address it is very likely we will | ||
| 36 | // get one. | ||
| 37 | // An older version of this code used MAP_FIXED, but that has the side | ||
| 38 | // effect of discarding already mapped pages that happen to be in the | ||
| 39 | // requested virtual memory range (such as the emulated RAM, sometimes). | ||
| 40 | if (low && (!map_hint)) | ||
| 41 | map_hint = (char*)round_page(512 * 1024 * 1024); /* 0.5 GB rounded up to the next page */ | ||
| 42 | #endif | ||
| 43 | void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC, | ||
| 44 | MAP_ANON | MAP_PRIVATE | ||
| 45 | #if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT) | ||
| 46 | | (low ? MAP_32BIT : 0) | ||
| 47 | #endif | ||
| 48 | , | ||
| 49 | -1, 0); | ||
| 50 | #endif /* defined(_WIN32) */ | ||
| 51 | |||
| 52 | #ifdef _WIN32 | ||
| 53 | if (ptr == nullptr) { | ||
| 54 | #else | ||
| 55 | if (ptr == MAP_FAILED) { | ||
| 56 | ptr = nullptr; | ||
| 57 | #endif | ||
| 58 | LOG_ERROR(Common_Memory, "Failed to allocate executable memory"); | ||
| 59 | } | ||
| 60 | #if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT) | ||
| 61 | else { | ||
| 62 | if (low) { | ||
| 63 | map_hint += size; | ||
| 64 | map_hint = (char*)round_page(map_hint); /* round up to the next page */ | ||
| 65 | } | ||
| 66 | } | ||
| 67 | #endif | ||
| 68 | |||
| 69 | #if EMU_ARCH_BITS == 64 | ||
| 70 | if ((u64)ptr >= 0x80000000 && low == true) | ||
| 71 | LOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!"); | ||
| 72 | #endif | ||
| 73 | |||
| 74 | return ptr; | ||
| 75 | } | ||
| 76 | |||
| 77 | void* AllocateMemoryPages(std::size_t size) { | ||
| 78 | #ifdef _WIN32 | ||
| 79 | void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE); | ||
| 80 | #else | ||
| 81 | void* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0); | ||
| 82 | |||
| 83 | if (ptr == MAP_FAILED) | ||
| 84 | ptr = nullptr; | ||
| 85 | #endif | ||
| 86 | |||
| 87 | if (ptr == nullptr) | ||
| 88 | LOG_ERROR(Common_Memory, "Failed to allocate raw memory"); | ||
| 89 | |||
| 90 | return ptr; | ||
| 91 | } | ||
| 92 | |||
| 93 | void* AllocateAlignedMemory(std::size_t size, std::size_t alignment) { | ||
| 94 | #ifdef _WIN32 | ||
| 95 | void* ptr = _aligned_malloc(size, alignment); | ||
| 96 | #else | ||
| 97 | void* ptr = nullptr; | ||
| 98 | #ifdef ANDROID | ||
| 99 | ptr = memalign(alignment, size); | ||
| 100 | #else | ||
| 101 | if (posix_memalign(&ptr, alignment, size) != 0) | ||
| 102 | LOG_ERROR(Common_Memory, "Failed to allocate aligned memory"); | ||
| 103 | #endif | ||
| 104 | #endif | ||
| 105 | |||
| 106 | if (ptr == nullptr) | ||
| 107 | LOG_ERROR(Common_Memory, "Failed to allocate aligned memory"); | ||
| 108 | |||
| 109 | return ptr; | ||
| 110 | } | ||
| 111 | |||
| 112 | void FreeMemoryPages(void* ptr, std::size_t size) { | ||
| 113 | if (ptr) { | ||
| 114 | #ifdef _WIN32 | ||
| 115 | if (!VirtualFree(ptr, 0, MEM_RELEASE)) | ||
| 116 | LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg()); | ||
| 117 | #else | ||
| 118 | munmap(ptr, size); | ||
| 119 | #endif | ||
| 120 | } | ||
| 121 | } | ||
| 122 | |||
| 123 | void FreeAlignedMemory(void* ptr) { | ||
| 124 | if (ptr) { | ||
| 125 | #ifdef _WIN32 | ||
| 126 | _aligned_free(ptr); | ||
| 127 | #else | ||
| 128 | free(ptr); | ||
| 129 | #endif | ||
| 130 | } | ||
| 131 | } | ||
| 132 | |||
| 133 | void WriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) { | ||
| 134 | #ifdef _WIN32 | ||
| 135 | DWORD oldValue; | ||
| 136 | if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue)) | ||
| 137 | LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg()); | ||
| 138 | #else | ||
| 139 | mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ); | ||
| 140 | #endif | ||
| 141 | } | ||
| 142 | |||
| 143 | void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) { | ||
| 144 | #ifdef _WIN32 | ||
| 145 | DWORD oldValue; | ||
| 146 | if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE, | ||
| 147 | &oldValue)) | ||
| 148 | LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg()); | ||
| 149 | #else | ||
| 150 | mprotect(ptr, size, | ||
| 151 | allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ); | ||
| 152 | #endif | ||
| 153 | } | ||
| 154 | |||
| 155 | std::string MemUsage() { | ||
| 156 | #ifdef _WIN32 | ||
| 157 | #pragma comment(lib, "psapi") | ||
| 158 | DWORD processID = GetCurrentProcessId(); | ||
| 159 | HANDLE hProcess; | ||
| 160 | PROCESS_MEMORY_COUNTERS pmc; | ||
| 161 | std::string Ret; | ||
| 162 | |||
| 163 | // Print information about the memory usage of the process. | ||
| 164 | |||
| 165 | hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID); | ||
| 166 | if (nullptr == hProcess) | ||
| 167 | return "MemUsage Error"; | ||
| 168 | |||
| 169 | if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) | ||
| 170 | Ret = fmt::format("{} K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7)); | ||
| 171 | |||
| 172 | CloseHandle(hProcess); | ||
| 173 | return Ret; | ||
| 174 | #else | ||
| 175 | return ""; | ||
| 176 | #endif | ||
| 177 | } | ||
diff --git a/src/common/memory_util.h b/src/common/memory_util.h deleted file mode 100644 index aad071979..000000000 --- a/src/common/memory_util.h +++ /dev/null | |||
| @@ -1,21 +0,0 @@ | |||
| 1 | // Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project | ||
| 2 | // Licensed under GPLv2 or any later version | ||
| 3 | // Refer to the license.txt file included. | ||
| 4 | |||
| 5 | #pragma once | ||
| 6 | |||
| 7 | #include <cstddef> | ||
| 8 | #include <string> | ||
| 9 | |||
| 10 | void* AllocateExecutableMemory(std::size_t size, bool low = true); | ||
| 11 | void* AllocateMemoryPages(std::size_t size); | ||
| 12 | void FreeMemoryPages(void* ptr, std::size_t size); | ||
| 13 | void* AllocateAlignedMemory(std::size_t size, std::size_t alignment); | ||
| 14 | void FreeAlignedMemory(void* ptr); | ||
| 15 | void WriteProtectMemory(void* ptr, std::size_t size, bool executable = false); | ||
| 16 | void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute = false); | ||
| 17 | std::string MemUsage(); | ||
| 18 | |||
| 19 | inline int GetPageSize() { | ||
| 20 | return 4096; | ||
| 21 | } | ||