diff --git a/CMakeLists.txt b/CMakeLists.txt index 4e01d2efa6..5c52c117b8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -792,7 +792,6 @@ add_library(native STATIC ext/native/base/display.h ext/native/base/linked_ptr.h ext/native/base/logging.h - ext/native/base/mutex.h ext/native/base/stringutil.cpp ext/native/base/stringutil.h ext/native/base/timeutil.cpp diff --git a/Common/LogManager.cpp b/Common/LogManager.cpp index ee1e52417a..b1321eba86 100644 --- a/Common/LogManager.cpp +++ b/Common/LogManager.cpp @@ -184,7 +184,7 @@ void LogManager::Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, const if (level > log->GetLevel() || !log->IsEnabled() || !log->HasListeners()) return; - lock_guard lk(log_lock_); + std::lock_guard lk(log_lock_); static const char level_to_char[8] = "-NEWIDV"; char formattedTime[13]; Common::Timer::GetTimeFormatted(formattedTime); @@ -263,19 +263,19 @@ LogChannel::LogChannel(const char* shortName, const char* fullName, bool enable) // LogContainer void LogChannel::AddListener(LogListener *listener) { - lock_guard lk(m_listeners_lock); + std::lock_guard lk(m_listeners_lock); m_listeners.insert(listener); m_hasListeners = true; } void LogChannel::RemoveListener(LogListener *listener) { - lock_guard lk(m_listeners_lock); + std::lock_guard lk(m_listeners_lock); m_listeners.erase(listener); m_hasListeners = !m_listeners.empty(); } void LogChannel::Trigger(LogTypes::LOG_LEVELS level, const char *msg) { - lock_guard lk(m_listeners_lock); + std::lock_guard lk(m_listeners_lock); std::set::const_iterator i; for (i = m_listeners.begin(); i != m_listeners.end(); ++i) { @@ -296,7 +296,7 @@ void FileLogListener::Log(LogTypes::LOG_LEVELS, const char *msg) { if (!IsEnabled() || !IsValid()) return; - lock_guard lk(m_log_lock); + std::lock_guard lk(m_log_lock); m_logfile << msg << std::flush; } diff --git a/Common/LogManager.h b/Common/LogManager.h index d6a0785718..9278404081 100644 --- a/Common/LogManager.h +++ b/Common/LogManager.h @@ -18,7 +18,7 @@ #pragma once #include -#include "base/mutex.h" +#include #include "file/ini_file.h" #include "Log.h" #include "StringUtils.h" @@ -50,7 +50,7 @@ public: const char* GetName() const { return "file"; } private: - recursive_mutex m_log_lock; + std::mutex m_log_lock; std::ofstream m_logfile; bool m_enable; }; @@ -112,7 +112,7 @@ public: private: char m_fullName[128]; char m_shortName[32]; - recursive_mutex m_listeners_lock; + std::mutex m_listeners_lock; std::set m_listeners; bool m_hasListeners; }; @@ -127,7 +127,7 @@ private: DebuggerLogListener *debuggerLog_; RingbufferLogListener *ringLog_; static LogManager *logManager_; // Singleton. Ugh. - recursive_mutex log_lock_; + std::mutex log_lock_; LogManager(); ~LogManager(); diff --git a/Common/ThreadSafeList.h b/Common/ThreadSafeList.h index 5df49b033d..37389286ba 100644 --- a/Common/ThreadSafeList.h +++ b/Common/ThreadSafeList.h @@ -26,7 +26,7 @@ public: explicit ThreadSafeList(std::size_t n, const T &v = T(), const Alloc &a = Alloc()) : list(n, v, a) {} ThreadSafeList(const std::list &other) : list(other) {} ThreadSafeList(const ThreadSafeList &other) { - lock_guard guard(other.lock); + std::lock_guard guard(other.lock); list.assign(other.list); } @@ -34,52 +34,52 @@ public: ThreadSafeList(Iter first, Iter last, const Alloc &a = Alloc()) : list(first, last, a) {} inline T front() const { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.front(); } inline void pop_front() { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.pop_front(); } inline void push_front(const T &v) { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.push_front(v); } inline T back() const { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.back(); } inline void pop_back() { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.pop_back(); } inline void push_back(const T &v) { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.push_back(v); } bool empty() const { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.empty(); } inline void clear() { - lock_guard guard(lock); + std::lock_guard guard(lock); return list.clear(); } void DoState(PointerWrap &p) { - lock_guard guard(lock); + std::lock_guard guard(lock); p.Do(list); } private: - mutable recursive_mutex lock; + mutable std::mutex lock; std::list list; }; diff --git a/Core/Core.cpp b/Core/Core.cpp index afc4b698f1..e7078fe062 100644 --- a/Core/Core.cpp +++ b/Core/Core.cpp @@ -18,12 +18,13 @@ #include "ppsspp_config.h" #include +#include #include "base/NativeApp.h" #include "base/display.h" -#include "base/mutex.h" #include "base/timeutil.h" #include "input/input_state.h" +#include "thread/threadutil.h" #include "profiler/profiler.h" #include "Core/Core.h" @@ -47,9 +48,9 @@ static const double ACTIVITY_IDLE_TIMEOUT = 2.0 * 3600.0; static event m_hStepEvent; -static recursive_mutex m_hStepMutex; +static std::mutex m_hStepMutex; static event m_hInactiveEvent; -static recursive_mutex m_hInactiveMutex; +static std::mutex m_hInactiveMutex; static bool singleStepPending = false; static std::set shutdownFuncs; static bool windowHidden = false; @@ -198,7 +199,7 @@ void UpdateRunLoop(InputState *input_state) { NativeUpdate(*input_state); { - lock_guard guard(input_state->lock); + std::lock_guard guard(input_state->lock); EndInputState(input_state); } diff --git a/Core/CoreTiming.cpp b/Core/CoreTiming.cpp index 7999cb18ad..a84e479a51 100644 --- a/Core/CoreTiming.cpp +++ b/Core/CoreTiming.cpp @@ -18,9 +18,9 @@ #include #include +#include #include "base/logging.h" -#include "base/mutex.h" #include "profiler/profiler.h" #include "Common/MsgHandler.h" @@ -86,7 +86,7 @@ s64 idledCycles; s64 lastGlobalTimeTicks; s64 lastGlobalTimeUs; -static recursive_mutex externalEventSection; +static std::mutex externalEventLock; std::vector mhzChangeCallbacks; @@ -226,7 +226,7 @@ void Shutdown() delete ev; } - lock_guard lk(externalEventSection); + std::lock_guard lk(externalEventLock); while(eventTsPool) { Event *ev = eventTsPool; @@ -250,7 +250,7 @@ u64 GetIdleTicks() // schedule things to be executed on the main thread. void ScheduleEvent_Threadsafe(s64 cyclesIntoFuture, int event_type, u64 userdata) { - lock_guard lk(externalEventSection); + std::lock_guard lk(externalEventLock); Event *ne = GetNewTsEvent(); ne->time = GetTicks() + cyclesIntoFuture; ne->type = event_type; @@ -271,7 +271,7 @@ void ScheduleEvent_Threadsafe_Immediate(int event_type, u64 userdata) { if(false) //Core::IsCPUThread()) { - lock_guard lk(externalEventSection); + std::lock_guard lk(externalEventLock); event_types[event_type].callback(userdata, 0); } else @@ -366,7 +366,7 @@ s64 UnscheduleEvent(int event_type, u64 userdata) s64 UnscheduleThreadsafeEvent(int event_type, u64 userdata) { s64 result = 0; - lock_guard lk(externalEventSection); + std::lock_guard lk(externalEventLock); if (!tsFirst) return result; while(tsFirst) @@ -470,7 +470,7 @@ void RemoveEvent(int event_type) void RemoveThreadsafeEvent(int event_type) { - lock_guard lk(externalEventSection); + std::lock_guard lk(externalEventLock); if (!tsFirst) { return; @@ -544,7 +544,7 @@ void MoveEvents() { Common::AtomicStoreRelease(hasTsEvents, 0); - lock_guard lk(externalEventSection); + std::lock_guard lk(externalEventLock); // Move events from async queue into main queue while (tsFirst) { @@ -682,7 +682,7 @@ void Event_DoStateOld(PointerWrap &p, BaseEvent *ev) void DoState(PointerWrap &p) { - lock_guard lk(externalEventSection); + std::lock_guard lk(externalEventLock); auto s = p.Section("CoreTiming", 1, 3); if (!s) diff --git a/Core/Debugger/SymbolMap.cpp b/Core/Debugger/SymbolMap.cpp index 80935a9db6..1cadac5323 100644 --- a/Core/Debugger/SymbolMap.cpp +++ b/Core/Debugger/SymbolMap.cpp @@ -42,13 +42,13 @@ SymbolMap *g_symbolMap; void SymbolMap::SortSymbols() { - lock_guard guard(lock_); + std::lock_guard guard(lock_); AssignFunctionIndices(); } void SymbolMap::Clear() { - lock_guard guard(lock_); + std::lock_guard guard(lock_); functions.clear(); labels.clear(); data.clear(); @@ -62,7 +62,7 @@ void SymbolMap::Clear() { bool SymbolMap::LoadSymbolMap(const char *filename) { Clear(); // let's not recurse the lock - lock_guard guard(lock_); + std::lock_guard guard(lock_); #if defined(_WIN32) && defined(UNICODE) gzFile f = gzopen_w(ConvertUTF8ToWString(filename).c_str(), "r"); @@ -181,7 +181,7 @@ bool SymbolMap::LoadSymbolMap(const char *filename) { } void SymbolMap::SaveSymbolMap(const char *filename) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); // Don't bother writing a blank file. if (!File::Exists(filename) && functions.empty() && data.empty()) { @@ -217,7 +217,7 @@ void SymbolMap::SaveSymbolMap(const char *filename) const { } bool SymbolMap::LoadNocashSym(const char *filename) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); FILE *f = File::OpenCFile(filename, "r"); if (!f) return false; @@ -275,7 +275,7 @@ bool SymbolMap::LoadNocashSym(const char *filename) { } void SymbolMap::SaveNocashSym(const char *filename) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); // Don't bother writing a blank file. if (!File::Exists(filename) && functions.empty() && data.empty()) { @@ -296,7 +296,7 @@ void SymbolMap::SaveNocashSym(const char *filename) const { } SymbolType SymbolMap::GetSymbolType(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); if (activeFunctions.find(address) != activeFunctions.end()) return ST_FUNCTION; if (activeData.find(address) != activeData.end()) @@ -343,7 +343,7 @@ bool SymbolMap::GetSymbolInfo(SymbolInfo *info, u32 address, SymbolType symmask) } u32 SymbolMap::GetNextSymbolAddress(u32 address, SymbolType symmask) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); const auto functionEntry = symmask & ST_FUNCTION ? activeFunctions.upper_bound(address) : activeFunctions.end(); const auto dataEntry = symmask & ST_DATA ? activeData.upper_bound(address) : activeData.end(); @@ -360,7 +360,7 @@ u32 SymbolMap::GetNextSymbolAddress(u32 address, SymbolType symmask) { } std::string SymbolMap::GetDescription(unsigned int address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); const char* labelName = NULL; u32 funcStart = GetFunctionStart(address); @@ -384,7 +384,7 @@ std::vector SymbolMap::GetAllSymbols(SymbolType symmask) { std::vector result; if (symmask & ST_FUNCTION) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); for (auto it = activeFunctions.begin(); it != activeFunctions.end(); it++) { SymbolEntry entry; entry.address = it->first; @@ -397,7 +397,7 @@ std::vector SymbolMap::GetAllSymbols(SymbolType symmask) { } if (symmask & ST_DATA) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); for (auto it = activeData.begin(); it != activeData.end(); it++) { SymbolEntry entry; entry.address = it->first; @@ -413,7 +413,7 @@ std::vector SymbolMap::GetAllSymbols(SymbolType symmask) { } void SymbolMap::AddModule(const char *name, u32 address, u32 size) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); for (auto it = modules.begin(), end = modules.end(); it != end; ++it) { if (!strcmp(it->name, name)) { @@ -439,13 +439,13 @@ void SymbolMap::AddModule(const char *name, u32 address, u32 size) { } void SymbolMap::UnloadModule(u32 address, u32 size) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); activeModuleEnds.erase(address + size); UpdateActiveSymbols(); } u32 SymbolMap::GetModuleRelativeAddr(u32 address, int moduleIndex) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); if (moduleIndex == -1) { moduleIndex = GetModuleIndex(address); } @@ -459,7 +459,7 @@ u32 SymbolMap::GetModuleRelativeAddr(u32 address, int moduleIndex) const { } u32 SymbolMap::GetModuleAbsoluteAddr(u32 relative, int moduleIndex) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); for (auto it = modules.begin(), end = modules.end(); it != end; ++it) { if (it->index == moduleIndex) { return it->start + relative; @@ -469,7 +469,7 @@ u32 SymbolMap::GetModuleAbsoluteAddr(u32 relative, int moduleIndex) const { } int SymbolMap::GetModuleIndex(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto iter = activeModuleEnds.upper_bound(address); if (iter == activeModuleEnds.end()) return -1; @@ -481,7 +481,7 @@ bool SymbolMap::IsModuleActive(int moduleIndex) const { return true; } - lock_guard guard(lock_); + std::lock_guard guard(lock_); for (auto it = activeModuleEnds.begin(), end = activeModuleEnds.end(); it != end; ++it) { if (it->second.index == moduleIndex) { return true; @@ -491,7 +491,7 @@ bool SymbolMap::IsModuleActive(int moduleIndex) const { } std::vector SymbolMap::getAllModules() const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); std::vector result; for (size_t i = 0; i < modules.size(); i++) { @@ -510,7 +510,7 @@ std::vector SymbolMap::getAllModules() const { } void SymbolMap::AddFunction(const char* name, u32 address, u32 size, int moduleIndex) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); if (moduleIndex == -1) { moduleIndex = GetModuleIndex(address); @@ -560,7 +560,7 @@ void SymbolMap::AddFunction(const char* name, u32 address, u32 size, int moduleI } u32 SymbolMap::GetFunctionStart(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeFunctions.upper_bound(address); if (it == activeFunctions.end()) { // check last element @@ -587,7 +587,7 @@ u32 SymbolMap::GetFunctionStart(u32 address) const { } u32 SymbolMap::FindPossibleFunctionAtAfter(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeFunctions.lower_bound(address); if (it == activeFunctions.end()) { return (u32)-1; @@ -596,7 +596,7 @@ u32 SymbolMap::FindPossibleFunctionAtAfter(u32 address) const { } u32 SymbolMap::GetFunctionSize(u32 startAddress) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeFunctions.find(startAddress); if (it == activeFunctions.end()) return INVALID_ADDRESS; @@ -605,7 +605,7 @@ u32 SymbolMap::GetFunctionSize(u32 startAddress) const { } u32 SymbolMap::GetFunctionModuleAddress(u32 startAddress) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeFunctions.find(startAddress); if (it == activeFunctions.end()) return INVALID_ADDRESS; @@ -614,7 +614,7 @@ u32 SymbolMap::GetFunctionModuleAddress(u32 startAddress) const { } int SymbolMap::GetFunctionNum(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); u32 start = GetFunctionStart(address); if (start == INVALID_ADDRESS) return INVALID_ADDRESS; @@ -627,7 +627,7 @@ int SymbolMap::GetFunctionNum(u32 address) const { } void SymbolMap::AssignFunctionIndices() { - lock_guard guard(lock_); + std::lock_guard guard(lock_); int index = 0; for (auto mod = activeModuleEnds.begin(), modend = activeModuleEnds.end(); mod != modend; ++mod) { int moduleIndex = mod->second.index; @@ -641,7 +641,7 @@ void SymbolMap::AssignFunctionIndices() { void SymbolMap::UpdateActiveSymbols() { // return; (slow in debug mode) - lock_guard guard(lock_); + std::lock_guard guard(lock_); activeFunctions.clear(); activeLabels.clear(); @@ -688,7 +688,7 @@ void SymbolMap::UpdateActiveSymbols() { } bool SymbolMap::SetFunctionSize(u32 startAddress, u32 newSize) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto funcInfo = activeFunctions.find(startAddress); if (funcInfo != activeFunctions.end()) { @@ -705,7 +705,7 @@ bool SymbolMap::SetFunctionSize(u32 startAddress, u32 newSize) { } bool SymbolMap::RemoveFunction(u32 startAddress, bool removeName) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeFunctions.find(startAddress); if (it == activeFunctions.end()) @@ -734,7 +734,7 @@ bool SymbolMap::RemoveFunction(u32 startAddress, bool removeName) { } void SymbolMap::AddLabel(const char* name, u32 address, int moduleIndex) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); if (moduleIndex == -1) { moduleIndex = GetModuleIndex(address); @@ -783,7 +783,7 @@ void SymbolMap::AddLabel(const char* name, u32 address, int moduleIndex) { } void SymbolMap::SetLabelName(const char* name, u32 address) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto labelInfo = activeLabels.find(address); if (labelInfo == activeLabels.end()) { AddLabel(name, address); @@ -805,7 +805,7 @@ void SymbolMap::SetLabelName(const char* name, u32 address) { } const char *SymbolMap::GetLabelName(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeLabels.find(address); if (it == activeLabels.end()) return NULL; @@ -814,7 +814,7 @@ const char *SymbolMap::GetLabelName(u32 address) const { } const char *SymbolMap::GetLabelNameRel(u32 relAddress, int moduleIndex) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = labels.find(std::make_pair(moduleIndex, relAddress)); if (it == labels.end()) return NULL; @@ -823,7 +823,7 @@ const char *SymbolMap::GetLabelNameRel(u32 relAddress, int moduleIndex) const { } std::string SymbolMap::GetLabelString(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); const char *label = GetLabelName(address); if (label == NULL) return ""; @@ -831,7 +831,7 @@ std::string SymbolMap::GetLabelString(u32 address) const { } bool SymbolMap::GetLabelValue(const char* name, u32& dest) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); for (auto it = activeLabels.begin(); it != activeLabels.end(); it++) { if (strcasecmp(name, it->second.name) == 0) { dest = it->first; @@ -843,7 +843,7 @@ bool SymbolMap::GetLabelValue(const char* name, u32& dest) { } void SymbolMap::AddData(u32 address, u32 size, DataType type, int moduleIndex) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); if (moduleIndex == -1) { moduleIndex = GetModuleIndex(address); @@ -892,7 +892,7 @@ void SymbolMap::AddData(u32 address, u32 size, DataType type, int moduleIndex) { } u32 SymbolMap::GetDataStart(u32 address) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeData.upper_bound(address); if (it == activeData.end()) { @@ -922,7 +922,7 @@ u32 SymbolMap::GetDataStart(u32 address) const { } u32 SymbolMap::GetDataSize(u32 startAddress) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeData.find(startAddress); if (it == activeData.end()) return INVALID_ADDRESS; @@ -930,7 +930,7 @@ u32 SymbolMap::GetDataSize(u32 startAddress) const { } u32 SymbolMap::GetDataModuleAddress(u32 startAddress) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeData.find(startAddress); if (it == activeData.end()) return INVALID_ADDRESS; @@ -938,7 +938,7 @@ u32 SymbolMap::GetDataModuleAddress(u32 startAddress) const { } DataType SymbolMap::GetDataType(u32 startAddress) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); auto it = activeData.find(startAddress); if (it == activeData.end()) return DATATYPE_NONE; @@ -947,7 +947,7 @@ DataType SymbolMap::GetDataType(u32 startAddress) const { void SymbolMap::GetLabels(std::vector &dest) const { - lock_guard guard(lock_); + std::lock_guard guard(lock_); for (auto it = activeLabels.begin(); it != activeLabels.end(); it++) { LabelDefinition entry; entry.value = it->first; @@ -973,7 +973,7 @@ static const DefaultSymbol defaultSymbols[]= { void SymbolMap::FillSymbolListBox(HWND listbox,SymbolType symType) const { wchar_t temp[256]; - lock_guard guard(lock_); + std::lock_guard guard(lock_); SendMessage(listbox, WM_SETREDRAW, FALSE, 0); ListBox_ResetContent(listbox); diff --git a/Core/Debugger/SymbolMap.h b/Core/Debugger/SymbolMap.h index f40e38e7b2..88d03a0f8e 100644 --- a/Core/Debugger/SymbolMap.h +++ b/Core/Debugger/SymbolMap.h @@ -21,8 +21,7 @@ #include #include #include - -#include "base/mutex.h" +#include #include "Common/CommonTypes.h" @@ -169,7 +168,7 @@ private: std::map data; std::vector modules; - mutable recursive_mutex lock_; + mutable std::recursive_mutex lock_; bool sawUnknownModule; }; diff --git a/Core/Dialog/PSPSaveDialog.cpp b/Core/Dialog/PSPSaveDialog.cpp index d9e0d2da00..5d998bbc57 100755 --- a/Core/Dialog/PSPSaveDialog.cpp +++ b/Core/Dialog/PSPSaveDialog.cpp @@ -299,9 +299,8 @@ void PSPSaveDialog::DisplayBanner(int which) PPGeDrawText(title, 30, 11, PPGE_ALIGN_VCENTER, 0.6f, CalcFadedColor(0xFFFFFFFF)); } -void PSPSaveDialog::DisplaySaveList(bool canMove) -{ - lock_guard guard(paramLock); +void PSPSaveDialog::DisplaySaveList(bool canMove) { + std::lock_guard guard(paramLock); static int upFramesHeld = 0; static int downFramesHeld = 0; @@ -361,7 +360,7 @@ void PSPSaveDialog::DisplaySaveList(bool canMove) void PSPSaveDialog::DisplaySaveIcon() { - lock_guard guard(paramLock); + std::lock_guard guard(paramLock); int textureColor = CalcFadedColor(0xFFFFFFFF); auto curSave = param.GetFileInfo(currentSelectedSave); @@ -390,7 +389,7 @@ void PSPSaveDialog::DisplaySaveIcon() void PSPSaveDialog::DisplaySaveDataInfo1() { - lock_guard guard(paramLock); + std::lock_guard guard(paramLock); if (param.GetFileInfo(currentSelectedSave).size == 0) { I18NCategory *di = GetI18NCategory("Dialog"); PPGeDrawText(di->T("NEW DATA"), 180, 136, PPGE_ALIGN_VCENTER, 0.6f, CalcFadedColor(0xFFFFFFFF)); @@ -463,7 +462,7 @@ void PSPSaveDialog::DisplaySaveDataInfo1() void PSPSaveDialog::DisplaySaveDataInfo2() { - lock_guard guard(paramLock); + std::lock_guard guard(paramLock); if (param.GetFileInfo(currentSelectedSave).size == 0) { } else { char txt[1024]; @@ -589,7 +588,7 @@ int PSPSaveDialog::Update(int animSpeed) memset(&request, 0, sizeof(request)); Memory::Memcpy(&request, requestAddr, size); Memory::Memcpy(&originalRequest, requestAddr, size); - lock_guard guard(paramLock); + std::lock_guard guard(paramLock); param.SetPspParam(&request); } @@ -1002,7 +1001,7 @@ int PSPSaveDialog::Update(int animSpeed) } void PSPSaveDialog::ExecuteIOAction() { - lock_guard guard(paramLock); + std::lock_guard guard(paramLock); switch (display) { case DS_LOAD_LOADING: if (param.Load(param.GetPspParam(), GetSelectedSaveDirName(), currentSelectedSave)) { diff --git a/Core/Dialog/PSPSaveDialog.h b/Core/Dialog/PSPSaveDialog.h index 460549347b..128616f520 100644 --- a/Core/Dialog/PSPSaveDialog.h +++ b/Core/Dialog/PSPSaveDialog.h @@ -18,8 +18,8 @@ #pragma once #include +#include -#include "base/mutex.h" #include "Core/Dialog/PSPDialog.h" #include "Core/Dialog/SavedataParam.h" @@ -154,7 +154,7 @@ private: }; std::thread *ioThread; - recursive_mutex paramLock; + std::mutex paramLock; volatile SaveIOStatus ioThreadStatus; }; diff --git a/Core/FileLoaders/CachingFileLoader.cpp b/Core/FileLoaders/CachingFileLoader.cpp index 7b8fbcd1c5..1e34008565 100644 --- a/Core/FileLoaders/CachingFileLoader.cpp +++ b/Core/FileLoaders/CachingFileLoader.cpp @@ -50,7 +50,7 @@ CachingFileLoader::~CachingFileLoader() { bool CachingFileLoader::Exists() { if (exists_ == -1) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); exists_ = backend_->Exists() ? 1 : 0; } return exists_ == 1; @@ -58,7 +58,7 @@ bool CachingFileLoader::Exists() { bool CachingFileLoader::ExistsFast() { if (exists_ == -1) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); return backend_->ExistsFast(); } return exists_ == 1; @@ -66,7 +66,7 @@ bool CachingFileLoader::ExistsFast() { bool CachingFileLoader::IsDirectory() { if (isDirectory_ == -1) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); isDirectory_ = backend_->IsDirectory() ? 1 : 0; } return isDirectory_ == 1; @@ -78,7 +78,7 @@ s64 CachingFileLoader::FileSize() { } std::string CachingFileLoader::Path() const { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); return backend_->Path(); } @@ -96,7 +96,7 @@ size_t CachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, Flag size_t readSize = 0; if ((flags & Flags::HINT_UNCACHED) != 0) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); readSize = backend_->ReadAt(absolutePos, bytes, data, flags); } else { readSize = ReadFromCache(absolutePos, bytes, data); @@ -132,7 +132,7 @@ void CachingFileLoader::ShutdownCache() { sleep_ms(1); } - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); for (auto block : blocks_) { delete [] block.second.ptr; } @@ -148,7 +148,7 @@ size_t CachingFileLoader::ReadFromCache(s64 pos, size_t bytes, void *data) { size_t offset = (size_t)(pos - (cacheStartPos << BLOCK_SHIFT)); u8 *p = (u8 *)data; - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); for (s64 i = cacheStartPos; i <= cacheEndPos; ++i) { auto block = blocks_.find(i); if (block == blocks_.end()) { @@ -170,7 +170,7 @@ void CachingFileLoader::SaveIntoCache(s64 pos, size_t bytes, Flags flags, bool r s64 cacheStartPos = pos >> BLOCK_SHIFT; s64 cacheEndPos = (pos + bytes - 1) >> BLOCK_SHIFT; - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); size_t blocksToRead = 0; for (s64 i = cacheStartPos; i <= cacheEndPos; ++i) { auto block = blocks_.find(i); @@ -235,7 +235,7 @@ bool CachingFileLoader::MakeCacheSpaceFor(size_t blocks, bool readingAhead) { return false; } - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); while (cacheSize_ > goal) { u64 minGeneration = generation_; @@ -274,7 +274,7 @@ bool CachingFileLoader::MakeCacheSpaceFor(size_t blocks, bool readingAhead) { } void CachingFileLoader::StartReadAhead(s64 pos) { - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); if (aheadThread_) { // Already going. return; @@ -288,7 +288,7 @@ void CachingFileLoader::StartReadAhead(s64 pos) { std::thread th([this, pos] { setCurrentThreadName("FileLoaderReadAhead"); - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); s64 cacheStartPos = pos >> BLOCK_SHIFT; s64 cacheEndPos = cacheStartPos + BLOCK_READAHEAD - 1; diff --git a/Core/FileLoaders/CachingFileLoader.h b/Core/FileLoaders/CachingFileLoader.h index 5ff12b2d89..e77773be54 100644 --- a/Core/FileLoaders/CachingFileLoader.h +++ b/Core/FileLoaders/CachingFileLoader.h @@ -18,7 +18,8 @@ #pragma once #include -#include "base/mutex.h" +#include + #include "Common/CommonTypes.h" #include "Core/Loaders.h" @@ -83,8 +84,8 @@ private: }; std::map blocks_; - recursive_mutex blocksMutex_; - mutable recursive_mutex backendMutex_; + std::mutex blocksMutex_; + mutable std::mutex backendMutex_; bool aheadThread_; bool prepared_; }; diff --git a/Core/FileLoaders/DiskCachingFileLoader.cpp b/Core/FileLoaders/DiskCachingFileLoader.cpp index 749b7fefe9..a677bbc8c2 100644 --- a/Core/FileLoaders/DiskCachingFileLoader.cpp +++ b/Core/FileLoaders/DiskCachingFileLoader.cpp @@ -18,11 +18,14 @@ #include #include #include -#include +#include +#include + #include "file/file_util.h" #include "file/free.h" #include "util/text/utf8.h" #include "Common/FileUtil.h" +#include "Common/CommonWindows.h" #include "Core/FileLoaders/DiskCachingFileLoader.h" #include "Core/System.h" @@ -34,7 +37,7 @@ static const u32 CACHE_SPACE_FLEX = 4; std::string DiskCachingFileLoaderCache::cacheDir_; std::map DiskCachingFileLoader::caches_; -recursive_mutex DiskCachingFileLoader::cachesMutex_; +std::mutex DiskCachingFileLoader::cachesMutex_; // Takes ownership of backend. DiskCachingFileLoader::DiskCachingFileLoader(FileLoader *backend) @@ -121,7 +124,7 @@ size_t DiskCachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, } std::vector DiskCachingFileLoader::GetCachedPathsInUse() { - lock_guard guard(cachesMutex_); + std::lock_guard guard(cachesMutex_); // This is on the file loader so that it can manage the caches_. std::vector files; @@ -134,7 +137,7 @@ std::vector DiskCachingFileLoader::GetCachedPathsInUse() { } void DiskCachingFileLoader::InitCache() { - lock_guard guard(cachesMutex_); + std::lock_guard guard(cachesMutex_); std::string path = backend_->Path(); auto &entry = caches_[path]; @@ -147,7 +150,7 @@ void DiskCachingFileLoader::InitCache() { } void DiskCachingFileLoader::ShutdownCache() { - lock_guard guard(cachesMutex_); + std::lock_guard guard(cachesMutex_); if (cache_->Release()) { // If it ran out of counts, delete it. @@ -222,7 +225,7 @@ void DiskCachingFileLoaderCache::ShutdownCache() { } size_t DiskCachingFileLoaderCache::ReadFromCache(s64 pos, size_t bytes, void *data) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); if (!f_) { return 0; @@ -257,7 +260,7 @@ size_t DiskCachingFileLoaderCache::ReadFromCache(s64 pos, size_t bytes, void *da } size_t DiskCachingFileLoaderCache::SaveIntoCache(FileLoader *backend, s64 pos, size_t bytes, void *data, FileLoader::Flags flags) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); if (!f_) { // Just to keep things working. diff --git a/Core/FileLoaders/DiskCachingFileLoader.h b/Core/FileLoaders/DiskCachingFileLoader.h index 8c845c8146..f0d5150ec1 100644 --- a/Core/FileLoaders/DiskCachingFileLoader.h +++ b/Core/FileLoaders/DiskCachingFileLoader.h @@ -19,7 +19,8 @@ #include #include -#include "base/mutex.h" +#include + #include "Common/Common.h" #include "Core/Loaders.h" @@ -64,7 +65,7 @@ private: // We don't support concurrent disk cache access (we use memory cached indexes.) // So we have to ensure there's only one of these per. static std::map caches_; - static recursive_mutex cachesMutex_; + static std::mutex cachesMutex_; }; class DiskCachingFileLoaderCache { @@ -154,7 +155,7 @@ private: u32 flags_; size_t cacheSize_; size_t indexCount_; - recursive_mutex lock_; + std::mutex lock_; std::string origPath_; struct FileHeader { diff --git a/Core/FileLoaders/RamCachingFileLoader.cpp b/Core/FileLoaders/RamCachingFileLoader.cpp index ab6f435af9..b793684da7 100644 --- a/Core/FileLoaders/RamCachingFileLoader.cpp +++ b/Core/FileLoaders/RamCachingFileLoader.cpp @@ -18,6 +18,8 @@ #include #include #include +#include + #include "base/timeutil.h" #include "thread/threadutil.h" #include "Core/FileLoaders/RamCachingFileLoader.h" @@ -43,7 +45,7 @@ RamCachingFileLoader::~RamCachingFileLoader() { bool RamCachingFileLoader::Exists() { if (exists_ == -1) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); exists_ = backend_->Exists() ? 1 : 0; } return exists_ == 1; @@ -51,7 +53,7 @@ bool RamCachingFileLoader::Exists() { bool RamCachingFileLoader::ExistsFast() { if (exists_ == -1) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); return backend_->ExistsFast(); } return exists_ == 1; @@ -59,7 +61,7 @@ bool RamCachingFileLoader::ExistsFast() { bool RamCachingFileLoader::IsDirectory() { if (isDirectory_ == -1) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); isDirectory_ = backend_->IsDirectory() ? 1 : 0; } return isDirectory_ == 1; @@ -70,7 +72,7 @@ s64 RamCachingFileLoader::FileSize() { } std::string RamCachingFileLoader::Path() const { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); return backend_->Path(); } @@ -81,7 +83,7 @@ void RamCachingFileLoader::Seek(s64 absolutePos) { size_t RamCachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags) { size_t readSize = 0; if (cache_ == nullptr || (flags & Flags::HINT_UNCACHED) != 0) { - lock_guard guard(backendMutex_); + std::lock_guard guard(backendMutex_); readSize = backend_->ReadAt(absolutePos, bytes, data, flags); } else { readSize = ReadFromCache(absolutePos, bytes, data); @@ -104,7 +106,7 @@ size_t RamCachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, F } void RamCachingFileLoader::InitCache() { - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); u32 blockCount = (u32)((filesize_ + BLOCK_SIZE - 1) >> BLOCK_SHIFT); // Overallocate for the last block. cache_ = (u8 *)malloc((size_t)blockCount << BLOCK_SHIFT); @@ -117,7 +119,7 @@ void RamCachingFileLoader::InitCache() { void RamCachingFileLoader::ShutdownCache() { { - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); // Try to have the thread stop. aheadRemaining_ = 0; } @@ -128,7 +130,7 @@ void RamCachingFileLoader::ShutdownCache() { sleep_ms(1); } - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); blocks_.clear(); if (cache_ != nullptr) { free(cache_); @@ -156,7 +158,7 @@ size_t RamCachingFileLoader::ReadFromCache(s64 pos, size_t bytes, void *data) { bytes = filesize_ - pos; } - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); for (s64 i = cacheStartPos; i <= cacheEndPos; ++i) { if (blocks_[i] == 0) { return readSize; @@ -182,7 +184,7 @@ void RamCachingFileLoader::SaveIntoCache(s64 pos, size_t bytes, Flags flags) { size_t blocksToRead = 0; { - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); for (s64 i = cacheStartPos; i <= cacheEndPos; ++i) { if (blocks_[i] == 0) { ++blocksToRead; @@ -201,7 +203,7 @@ void RamCachingFileLoader::SaveIntoCache(s64 pos, size_t bytes, Flags flags) { // In case there was an error, let's not mark blocks that failed to read as read. u32 blocksActuallyRead = (u32)((bytesRead + BLOCK_SIZE - 1) >> BLOCK_SHIFT); { - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); // In case they were simultaneously read. u32 blocksRead = 0; @@ -223,7 +225,7 @@ void RamCachingFileLoader::StartReadAhead(s64 pos) { return; } - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); aheadPos_ = pos; if (aheadThread_) { // Already going. @@ -260,7 +262,7 @@ void RamCachingFileLoader::StartReadAhead(s64 pos) { } u32 RamCachingFileLoader::NextAheadBlock() { - lock_guard guard(blocksMutex_); + std::lock_guard guard(blocksMutex_); // If we had an aheadPos_ set, start reading from there and go forward. u32 startFrom = (u32)(aheadPos_ >> BLOCK_SHIFT); diff --git a/Core/FileLoaders/RamCachingFileLoader.h b/Core/FileLoaders/RamCachingFileLoader.h index fd25a68edf..a1e6743d39 100644 --- a/Core/FileLoaders/RamCachingFileLoader.h +++ b/Core/FileLoaders/RamCachingFileLoader.h @@ -18,7 +18,8 @@ #pragma once #include -#include "base/mutex.h" +#include + #include "Common/CommonTypes.h" #include "Core/Loaders.h" @@ -69,8 +70,8 @@ private: int isDirectory_; std::vector blocks_; - recursive_mutex blocksMutex_; - mutable recursive_mutex backendMutex_; + std::mutex blocksMutex_; + mutable std::mutex backendMutex_; u32 aheadRemaining_; s64 aheadPos_; bool aheadThread_; diff --git a/Core/FileSystems/BlockDevices.cpp b/Core/FileSystems/BlockDevices.cpp index ac50efb5f7..b1f913001e 100644 --- a/Core/FileSystems/BlockDevices.cpp +++ b/Core/FileSystems/BlockDevices.cpp @@ -360,13 +360,10 @@ bool CISOFileBlockDevice::ReadBlocks(u32 minBlock, int count, u8 *outPtr) { return true; } - -recursive_mutex NPDRMDemoBlockDevice::mutex_; - NPDRMDemoBlockDevice::NPDRMDemoBlockDevice(FileLoader *fileLoader) : fileLoader_(fileLoader) { - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); MAC_KEY mkey; CIPHER_KEY ckey; u8 np_header[256]; @@ -432,7 +429,7 @@ NPDRMDemoBlockDevice::NPDRMDemoBlockDevice(FileLoader *fileLoader) NPDRMDemoBlockDevice::~NPDRMDemoBlockDevice() { - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); delete [] table; delete [] tempBuf; delete [] blockBuf; @@ -443,7 +440,7 @@ int lzrc_decompress(void *out, int out_len, void *in, int in_len); bool NPDRMDemoBlockDevice::ReadBlock(int blockNumber, u8 *outPtr, bool uncached) { FileLoader::Flags flags = uncached ? FileLoader::Flags::HINT_UNCACHED : FileLoader::Flags::NONE; - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); CIPHER_KEY ckey; int block, lba, lzsize; size_t readSize; diff --git a/Core/FileSystems/BlockDevices.h b/Core/FileSystems/BlockDevices.h index 81f5465515..235ea89f8b 100644 --- a/Core/FileSystems/BlockDevices.h +++ b/Core/FileSystems/BlockDevices.h @@ -23,14 +23,14 @@ // The ISOFileSystemReader reads from a BlockDevice, so it automatically works // with CISO images. +#include + #include "Common/CommonTypes.h" #include "Core/ELF/PBPReader.h" -#include "base/mutex.h" class FileLoader; -class BlockDevice -{ +class BlockDevice { public: virtual ~BlockDevice() {} virtual bool ReadBlock(int blockNumber, u8 *outPtr, bool uncached = false) = 0; @@ -49,9 +49,7 @@ public: u32 CalculateCRC(); }; - -class CISOFileBlockDevice : public BlockDevice -{ +class CISOFileBlockDevice : public BlockDevice { public: CISOFileBlockDevice(FileLoader *fileLoader); ~CISOFileBlockDevice(); @@ -73,8 +71,7 @@ private: }; -class FileBlockDevice : public BlockDevice -{ +class FileBlockDevice : public BlockDevice { public: FileBlockDevice(FileLoader *fileLoader); ~FileBlockDevice(); @@ -98,8 +95,7 @@ struct table_info { int unk_1c; }; -class NPDRMDemoBlockDevice : public BlockDevice -{ +class NPDRMDemoBlockDevice : public BlockDevice { public: NPDRMDemoBlockDevice(FileLoader *fileLoader); ~NPDRMDemoBlockDevice(); @@ -109,7 +105,7 @@ public: private: FileLoader *fileLoader_; - static recursive_mutex mutex_; + std::mutex mutex_; u32 lbaSize; u32 psarOffset; diff --git a/Core/FileSystems/MetaFileSystem.cpp b/Core/FileSystems/MetaFileSystem.cpp index 18dc1448b1..e85c514231 100644 --- a/Core/FileSystems/MetaFileSystem.cpp +++ b/Core/FileSystems/MetaFileSystem.cpp @@ -166,7 +166,7 @@ static bool RealPath(const std::string ¤tDirectory, const std::string &inP IFileSystem *MetaFileSystem::GetHandleOwner(u32 handle) { - lock_guard guard(lock); + std::lock_guard guard(lock); for (size_t i = 0; i < fileSystems.size(); i++) { if (fileSystems[i].system->OwnsHandle(handle)) @@ -178,7 +178,7 @@ IFileSystem *MetaFileSystem::GetHandleOwner(u32 handle) bool MetaFileSystem::MapFilePath(const std::string &_inpath, std::string &outpath, MountPoint **system) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string realpath; std::string inpath = _inpath; @@ -271,7 +271,7 @@ std::string MetaFileSystem::NormalizePrefix(std::string prefix) const { void MetaFileSystem::Mount(std::string prefix, IFileSystem *system) { - lock_guard guard(lock); + std::lock_guard guard(lock); MountPoint x; x.prefix = prefix; x.system = system; @@ -280,7 +280,7 @@ void MetaFileSystem::Mount(std::string prefix, IFileSystem *system) void MetaFileSystem::Unmount(std::string prefix, IFileSystem *system) { - lock_guard guard(lock); + std::lock_guard guard(lock); MountPoint x; x.prefix = prefix; x.system = system; @@ -312,7 +312,7 @@ IFileSystem *MetaFileSystem::GetSystem(const std::string &prefix) { void MetaFileSystem::Shutdown() { - lock_guard guard(lock); + std::lock_guard guard(lock); current = 6; // Ownership is a bit convoluted. Let's just delete everything once. @@ -334,7 +334,7 @@ void MetaFileSystem::Shutdown() u32 MetaFileSystem::OpenWithError(int &error, std::string filename, FileAccess access, const char *devicename) { - lock_guard guard(lock); + std::lock_guard guard(lock); u32 h = OpenFile(filename, access, devicename); error = lastOpenError; return h; @@ -342,7 +342,7 @@ u32 MetaFileSystem::OpenWithError(int &error, std::string filename, FileAccess a u32 MetaFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) { - lock_guard guard(lock); + std::lock_guard guard(lock); lastOpenError = 0; std::string of; MountPoint *mount; @@ -364,7 +364,7 @@ u32 MetaFileSystem::OpenFile(std::string filename, FileAccess access, const char PSPFileInfo MetaFileSystem::GetFileInfo(std::string filename) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; IFileSystem *system; if (MapFilePath(filename, of, &system)) @@ -380,7 +380,7 @@ PSPFileInfo MetaFileSystem::GetFileInfo(std::string filename) bool MetaFileSystem::GetHostPath(const std::string &inpath, std::string &outpath) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; IFileSystem *system; if (MapFilePath(inpath, of, &system)) { @@ -392,7 +392,7 @@ bool MetaFileSystem::GetHostPath(const std::string &inpath, std::string &outpath std::vector MetaFileSystem::GetDirListing(std::string path) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; IFileSystem *system; if (MapFilePath(path, of, &system)) @@ -408,13 +408,13 @@ std::vector MetaFileSystem::GetDirListing(std::string path) void MetaFileSystem::ThreadEnded(int threadID) { - lock_guard guard(lock); + std::lock_guard guard(lock); currentDir.erase(threadID); } int MetaFileSystem::ChDir(const std::string &dir) { - lock_guard guard(lock); + std::lock_guard guard(lock); // Retain the old path and fail if the arg is 1023 bytes or longer. if (dir.size() >= 1023) return SCE_KERNEL_ERROR_NAMETOOLONG; @@ -449,7 +449,7 @@ int MetaFileSystem::ChDir(const std::string &dir) bool MetaFileSystem::MkDir(const std::string &dirname) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; IFileSystem *system; if (MapFilePath(dirname, of, &system)) @@ -464,7 +464,7 @@ bool MetaFileSystem::MkDir(const std::string &dirname) bool MetaFileSystem::RmDir(const std::string &dirname) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; IFileSystem *system; if (MapFilePath(dirname, of, &system)) @@ -479,7 +479,7 @@ bool MetaFileSystem::RmDir(const std::string &dirname) int MetaFileSystem::RenameFile(const std::string &from, const std::string &to) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; std::string rf; IFileSystem *osystem; @@ -511,7 +511,7 @@ int MetaFileSystem::RenameFile(const std::string &from, const std::string &to) bool MetaFileSystem::RemoveFile(const std::string &filename) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; IFileSystem *system; if (MapFilePath(filename, of, &system)) @@ -526,7 +526,7 @@ bool MetaFileSystem::RemoveFile(const std::string &filename) int MetaFileSystem::Ioctl(u32 handle, u32 cmd, u32 indataPtr, u32 inlen, u32 outdataPtr, u32 outlen, int &usec) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) return sys->Ioctl(handle, cmd, indataPtr, inlen, outdataPtr, outlen, usec); @@ -535,7 +535,7 @@ int MetaFileSystem::Ioctl(u32 handle, u32 cmd, u32 indataPtr, u32 inlen, u32 out int MetaFileSystem::DevType(u32 handle) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) return sys->DevType(handle); @@ -544,7 +544,7 @@ int MetaFileSystem::DevType(u32 handle) void MetaFileSystem::CloseFile(u32 handle) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) sys->CloseFile(handle); @@ -552,7 +552,7 @@ void MetaFileSystem::CloseFile(u32 handle) size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) return sys->ReadFile(handle, pointer, size); @@ -562,7 +562,7 @@ size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) size_t MetaFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) return sys->WriteFile(handle, pointer, size); @@ -572,7 +572,7 @@ size_t MetaFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size, int &usec) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) return sys->ReadFile(handle, pointer, size, usec); @@ -582,7 +582,7 @@ size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size, int &usec) size_t MetaFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size, int &usec) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) return sys->WriteFile(handle, pointer, size, usec); @@ -592,7 +592,7 @@ size_t MetaFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size, int &u size_t MetaFileSystem::SeekFile(u32 handle, s32 position, FileMove type) { - lock_guard guard(lock); + std::lock_guard guard(lock); IFileSystem *sys = GetHandleOwner(handle); if (sys) return sys->SeekFile(handle,position,type); @@ -619,7 +619,7 @@ int MetaFileSystem::ReadEntireFile(const std::string &filename, std::vector u64 MetaFileSystem::FreeSpace(const std::string &path) { - lock_guard guard(lock); + std::lock_guard guard(lock); std::string of; IFileSystem *system; if (MapFilePath(path, of, &system)) @@ -630,7 +630,7 @@ u64 MetaFileSystem::FreeSpace(const std::string &path) void MetaFileSystem::DoState(PointerWrap &p) { - lock_guard guard(lock); + std::lock_guard guard(lock); auto s = p.Section("MetaFileSystem", 1); if (!s) diff --git a/Core/FileSystems/MetaFileSystem.h b/Core/FileSystems/MetaFileSystem.h index 91bafa396d..c4fcee560a 100644 --- a/Core/FileSystems/MetaFileSystem.h +++ b/Core/FileSystems/MetaFileSystem.h @@ -19,8 +19,8 @@ #include #include +#include -#include "base/mutex.h" #include "Core/FileSystems/FileSystem.h" class MetaFileSystem : public IHandleAllocator, public IFileSystem { @@ -42,7 +42,7 @@ private: std::string startingDirectory; int lastOpenError; - recursive_mutex lock; + std::recursive_mutex lock; // must be recursive public: MetaFileSystem() { @@ -120,7 +120,7 @@ public: int ReadEntireFile(const std::string &filename, std::vector &data); void SetStartingDirectory(const std::string &dir) { - lock_guard guard(lock); + std::lock_guard guard(lock); startingDirectory = dir; } }; diff --git a/Core/HLE/__sceAudio.cpp b/Core/HLE/__sceAudio.cpp index a41772ec3e..f0c7051d78 100644 --- a/Core/HLE/__sceAudio.cpp +++ b/Core/HLE/__sceAudio.cpp @@ -15,7 +15,8 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. -#include "base/mutex.h" +#include +#include #include "Globals.h" // only for clamp_s16 #include "Common/CommonTypes.h" @@ -48,8 +49,7 @@ AudioDebugStats g_AudioDebugStats; // Should be used to lock anything related to the outAudioQueue. // atomic locks are used on the lock. TODO: make this lock-free -atomic_flag atomicLock_; -recursive_mutex mutex_; +std::atomic_flag atomicLock_; enum latency { LOW_LATENCY = 0, diff --git a/Core/HLE/proAdhoc.cpp b/Core/HLE/proAdhoc.cpp index 61621b0d98..c470b40e1b 100644 --- a/Core/HLE/proAdhoc.cpp +++ b/Core/HLE/proAdhoc.cpp @@ -51,7 +51,7 @@ int metasocket; SceNetAdhocctlParameter parameter; SceNetAdhocctlAdhocId product_code; std::thread friendFinderThread; -recursive_mutex peerlock; +std::mutex peerlock; SceNetAdhocPdpStat * pdp[255]; SceNetAdhocPtpStat * ptp[255]; uint32_t localip; @@ -104,7 +104,7 @@ void addFriend(SceNetAdhocctlConnectPacketS2C * packet) { if (packet == NULL) return; // Multithreading Lock - peerlock.lock(); + std::lock_guard guard(peerlock); SceNetAdhocctlPeerInfo * peer = findFriend(&packet->mac); // Already existed @@ -143,9 +143,6 @@ void addFriend(SceNetAdhocctlConnectPacketS2C * packet) { friends = peer; } } - - // Multithreading Unlock - peerlock.unlock(); } SceNetAdhocctlPeerInfo * findFriend(SceNetEtherAddr * MAC) { @@ -1528,7 +1525,7 @@ bool resolveMAC(SceNetEtherAddr * mac, uint32_t * ip) { } // Multithreading Lock - peerlock.lock(); + std::lock_guard guard(peerlock); // Peer Reference SceNetAdhocctlPeerInfo * peer = friends; @@ -1540,17 +1537,11 @@ bool resolveMAC(SceNetEtherAddr * mac, uint32_t * ip) { // Copy Data *ip = peer->ip_addr; - // Multithreading Unlock - peerlock.unlock(); - // Return Success return true; } } - // Multithreading Unlock - peerlock.unlock(); - // Peer not found return false; } diff --git a/Core/HLE/proAdhoc.h b/Core/HLE/proAdhoc.h index 1ef7071c0e..d907446ba9 100644 --- a/Core/HLE/proAdhoc.h +++ b/Core/HLE/proAdhoc.h @@ -18,9 +18,9 @@ #pragma once #include +#include #include "base/timeutil.h" -#include "base/mutex.h" #include "net/resolve.h" #include "Common/ChunkFile.h" @@ -412,7 +412,7 @@ typedef struct SceNetAdhocMatchingContext { // Local PDP Socket s32_le socket; // Socket Lock - recursive_mutex *socketlock; + std::recursive_mutex *socketlock; // Receive Buffer Length s32_le rxbuflen; @@ -468,11 +468,11 @@ typedef struct SceNetAdhocMatchingContext { bool inputRunning = false; // Event Caller Thread Message Stack - recursive_mutex *eventlock; // s32_le event_stack_lock; + std::recursive_mutex *eventlock; // s32_le event_stack_lock; ThreadMessage *event_stack; // IO Handler Thread Message Stack - recursive_mutex *inputlock; // s32_le input_stack_lock; + std::recursive_mutex *inputlock; // s32_le input_stack_lock; ThreadMessage *input_stack; // Socket Connectivity @@ -788,7 +788,7 @@ extern int metasocket; extern SceNetAdhocctlParameter parameter; extern SceNetAdhocctlAdhocId product_code; extern std::thread friendFinderThread; -extern recursive_mutex peerlock; +extern std::mutex peerlock; extern SceNetAdhocPdpStat * pdp[255]; extern SceNetAdhocPtpStat * ptp[255]; extern std::map adhocctlHandlers; diff --git a/Core/HLE/sceCtrl.cpp b/Core/HLE/sceCtrl.cpp index 95d41e9e8c..705bf6590a 100644 --- a/Core/HLE/sceCtrl.cpp +++ b/Core/HLE/sceCtrl.cpp @@ -16,8 +16,9 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. -#include -#include "base/mutex.h" +#include +#include + #include "Globals.h" #include "Core/HLE/HLE.h" #include "Core/HLE/FunctionWrappers.h" @@ -84,7 +85,7 @@ static int ctrlIdleBack = -1; static int ctrlCycle = 0; static std::vector waitingThreads; -static recursive_mutex ctrlMutex; +static std::mutex ctrlMutex; static int ctrlTimer = -1; @@ -101,7 +102,7 @@ const u32 CTRL_EMU_RAPIDFIRE_MASK = CTRL_UP | CTRL_DOWN | CTRL_LEFT | CTRL_RIGHT static void __CtrlUpdateLatch() { - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); // Copy in the current data to the current buffer. ctrlBufs[ctrlBuf] = ctrlCurrent; @@ -144,14 +145,14 @@ static int __CtrlResetLatch() u32 __CtrlPeekButtons() { - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); return ctrlCurrent.buttons; } void __CtrlPeekAnalog(int stick, float *x, float *y) { - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); *x = (ctrlCurrent.analog[stick][CTRL_ANALOG_X] - 127.5f) / 127.5f; *y = -(ctrlCurrent.analog[stick][CTRL_ANALOG_Y] - 127.5f) / 127.5f; @@ -170,27 +171,27 @@ u32 __CtrlReadLatch() void __CtrlButtonDown(u32 buttonBit) { - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); ctrlCurrent.buttons |= buttonBit; } void __CtrlButtonUp(u32 buttonBit) { - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); ctrlCurrent.buttons &= ~buttonBit; } void __CtrlSetAnalogX(float x, int stick) { u8 scaled = clamp_u8((int)ceilf(x * 127.5f + 127.5f)); - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); ctrlCurrent.analog[stick][CTRL_ANALOG_X] = scaled; } void __CtrlSetAnalogY(float y, int stick) { u8 scaled = clamp_u8((int)ceilf(-y * 127.5f + 127.5f)); - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); ctrlCurrent.analog[stick][CTRL_ANALOG_Y] = scaled; } @@ -304,7 +305,7 @@ void __CtrlInit() ctrlIdleBack = -1; ctrlCycle = 0; - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); ctrlBuf = 1; ctrlBufRead = 0; @@ -326,7 +327,7 @@ void __CtrlInit() void __CtrlDoState(PointerWrap &p) { - lock_guard guard(ctrlMutex); + std::lock_guard guard(ctrlMutex); auto s = p.Section("sceCtrl", 1, 3); if (!s) diff --git a/Core/HLE/sceGe.cpp b/Core/HLE/sceGe.cpp index 1876d9d23d..25aaa6848a 100644 --- a/Core/HLE/sceGe.cpp +++ b/Core/HLE/sceGe.cpp @@ -17,8 +17,8 @@ #include #include +#include -#include "base/mutex.h" #include "Common/ChunkFile.h" #include "Common/ThreadSafeList.h" #include "Core/HLE/HLE.h" diff --git a/Core/HLE/sceNetAdhoc.cpp b/Core/HLE/sceNetAdhoc.cpp index c9ac32d22a..a3fce16ab7 100644 --- a/Core/HLE/sceNetAdhoc.cpp +++ b/Core/HLE/sceNetAdhoc.cpp @@ -15,7 +15,7 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. - +#include // sceNetAdhoc // This is a direct port of Coldbird's code from http://code.google.com/p/aemu/ @@ -37,8 +37,6 @@ #include "Core/HLE/sceNet.h" #include "Core/HLE/proAdhocServer.h" -#include "base/mutex.h" - // shared in sceNetAdhoc.h since it need to be used from sceNet.cpp also // TODO: Make accessor functions instead, and throw all this state in a struct. bool netAdhocInited; @@ -50,7 +48,7 @@ int netAdhocMatchingStarted = 0; SceUID threadAdhocID; -recursive_mutex adhocEvtMtx; +std::mutex adhocEvtMtx; std::vector> adhocctlEvents; std::vector matchingEvents; u32 dummyThreadHackAddr = 0; @@ -121,13 +119,13 @@ void __NetAdhocDoState(PointerWrap &p) { } void __UpdateAdhocctlHandlers(u32 flag, u32 error) { - lock_guard adhocGuard(adhocEvtMtx); + std::lock_guard adhocGuard(adhocEvtMtx); adhocctlEvents.push_back({ flag, error }); } // TODO: MipsCall needs to be called from it's own PSP Thread instead of from any random PSP Thread void __UpdateMatchingHandler(u64 ArgsPtr) { - lock_guard adhocGuard(adhocEvtMtx); + std::lock_guard adhocGuard(adhocEvtMtx); matchingEvents.push_back(ArgsPtr); } @@ -1100,7 +1098,7 @@ static u32 sceNetAdhocctlDisconnect() { // Notify Event Handlers (even if we weren't connected, not doing this will freeze games like God Eater, which expect this behaviour) { - lock_guard adhocGuard(adhocEvtMtx); + std::lock_guard adhocGuard(adhocEvtMtx); adhocctlEvents.push_back({ ADHOCCTL_EVENT_DISCONNECT, 0 }); } // Return Success, some games might ignore returned value and always treat it as success, otherwise repeatedly calling this function @@ -2668,9 +2666,9 @@ static int sceNetAdhocMatchingCreate(int mode, int maxnum, int port, int rxbufle context->mac = localmac; // Create locks - context->socketlock = new recursive_mutex; - context->eventlock = new recursive_mutex; - context->inputlock = new recursive_mutex; + context->socketlock = new std::recursive_mutex; + context->eventlock = new std::recursive_mutex; + context->inputlock = new std::recursive_mutex; // Create fake thread //#define PSP_THREAD_ATTR_KERNEL 0x00001000 // PSP_THREAD_ATTR_KERNEL is located in sceKernelThread.cpp instead of sceKernelThread.h :( @@ -3472,7 +3470,7 @@ int sceNetAdhocMatchingGetPoolStat(u32 poolstatPtr) { void __NetTriggerCallbacks() { { - lock_guard adhocGuard(adhocEvtMtx); + std::lock_guard adhocGuard(adhocEvtMtx); for (auto ¶ms : adhocctlEvents) { diff --git a/Core/HLE/sceSas.cpp b/Core/HLE/sceSas.cpp index ed85847fc6..c6666beb55 100644 --- a/Core/HLE/sceSas.cpp +++ b/Core/HLE/sceSas.cpp @@ -29,9 +29,9 @@ #include #include #include +#include #include "base/basictypes.h" -#include "base/mutex.h" #include "profiler/profiler.h" #include "thread/threadutil.h" #include "Common/Log.h" @@ -91,10 +91,10 @@ struct SasThreadParams { }; static std::thread *sasThread; -static recursive_mutex sasWakeMutex; -static recursive_mutex sasDoneMutex; -static condition_variable sasWake; -static condition_variable sasDone; +static std::mutex sasWakeMutex; +static std::mutex sasDoneMutex; +static std::condition_variable sasWake; +static std::condition_variable sasDone; static volatile int sasThreadState = SasThreadState::DISABLED; static SasThreadParams sasThreadParams; static int sasMixEvent = -1; @@ -102,9 +102,9 @@ static int sasMixEvent = -1; int __SasThread() { setCurrentThreadName("SAS"); - lock_guard guard(sasWakeMutex); + std::unique_lock guard(sasWakeMutex); while (sasThreadState != SasThreadState::DISABLED) { - sasWake.wait(sasWakeMutex); + sasWake.wait(guard); if (sasThreadState == SasThreadState::QUEUED) { sas->Mix(sasThreadParams.outAddr, sasThreadParams.inAddr, sasThreadParams.leftVol, sasThreadParams.rightVol); @@ -118,10 +118,9 @@ int __SasThread() { } static void __SasDrain() { - sasDoneMutex.lock(); + std::unique_lock guard(sasDoneMutex); while (sasThreadState == SasThreadState::QUEUED) - sasDone.wait(sasDoneMutex); - sasDoneMutex.unlock(); + sasDone.wait(guard); } static void __SasEnqueueMix(u32 outAddr, u32 inAddr = 0, int leftVol = 0, int rightVol = 0) { diff --git a/Core/HW/AsyncIOManager.cpp b/Core/HW/AsyncIOManager.cpp index 5e1702668c..b2a99805e4 100644 --- a/Core/HW/AsyncIOManager.cpp +++ b/Core/HW/AsyncIOManager.cpp @@ -15,6 +15,9 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. +#include +#include + #include "Common/ChunkFile.h" #include "Core/MIPS/MIPS.h" #include "Core/Reporting.h" @@ -34,7 +37,7 @@ bool AsyncIOManager::HasOperation(u32 handle) { void AsyncIOManager::ScheduleOperation(AsyncIOEvent ev) { { - lock_guard guard(resultsLock_); + std::lock_guard guard(resultsLock_); if (!resultsPending_.insert(ev.handle).second) { ERROR_LOG_REPORT(SCEIO, "Scheduling operation for file %d while one is pending (type %d)", ev.handle, ev.type); } @@ -43,18 +46,17 @@ void AsyncIOManager::ScheduleOperation(AsyncIOEvent ev) { } void AsyncIOManager::Shutdown() { - lock_guard guard(resultsLock_); + std::lock_guard guard(resultsLock_); resultsPending_.clear(); results_.clear(); } bool AsyncIOManager::HasResult(u32 handle) { - lock_guard guard(resultsLock_); + std::lock_guard guard(resultsLock_); return results_.find(handle) != results_.end(); } bool AsyncIOManager::PopResult(u32 handle, AsyncIOResult &result) { - lock_guard guard(resultsLock_); if (results_.find(handle) != results_.end()) { result = results_[handle]; results_.erase(handle); @@ -70,7 +72,6 @@ bool AsyncIOManager::PopResult(u32 handle, AsyncIOResult &result) { } bool AsyncIOManager::ReadResult(u32 handle, AsyncIOResult &result) { - lock_guard guard(resultsLock_); if (results_.find(handle) != results_.end()) { result = results_[handle]; return true; @@ -80,31 +81,27 @@ bool AsyncIOManager::ReadResult(u32 handle, AsyncIOResult &result) { } bool AsyncIOManager::WaitResult(u32 handle, AsyncIOResult &result) { - lock_guard guard(resultsLock_); + std::unique_lock guard(resultsLock_); ScheduleEvent(IO_EVENT_SYNC); while (HasEvents() && ThreadEnabled() && resultsPending_.find(handle) != resultsPending_.end()) { if (PopResult(handle, result)) { return true; } - resultsWait_.wait_for(resultsLock_, 16); + resultsWait_.wait_for(guard, std::chrono::milliseconds(16)); } - if (PopResult(handle, result)) { - return true; - } - - return false; + return PopResult(handle, result); } u64 AsyncIOManager::ResultFinishTicks(u32 handle) { AsyncIOResult result; - lock_guard guard(resultsLock_); + std::unique_lock guard(resultsLock_); ScheduleEvent(IO_EVENT_SYNC); while (HasEvents() && ThreadEnabled() && resultsPending_.find(handle) != resultsPending_.end()) { if (ReadResult(handle, result)) { return result.finishTicks; } - resultsWait_.wait_for(resultsLock_, 16); + resultsWait_.wait_for(guard, std::chrono::milliseconds(16)); } if (ReadResult(handle, result)) { return result.finishTicks; @@ -141,7 +138,7 @@ void AsyncIOManager::Write(u32 handle, u8 *buf, size_t bytes) { } void AsyncIOManager::EventResult(u32 handle, AsyncIOResult result) { - lock_guard guard(resultsLock_); + std::lock_guard guard(resultsLock_); if (results_.find(handle) != results_.end()) { ERROR_LOG_REPORT(SCEIO, "Overwriting previous result for file action on handle %d", handle); } @@ -155,7 +152,7 @@ void AsyncIOManager::DoState(PointerWrap &p) { return; SyncThread(); - lock_guard guard(resultsLock_); + std::lock_guard guard(resultsLock_); p.Do(resultsPending_); if (s >= 2) { p.Do(results_); diff --git a/Core/HW/AsyncIOManager.h b/Core/HW/AsyncIOManager.h index a64a2a38da..41b997b089 100644 --- a/Core/HW/AsyncIOManager.h +++ b/Core/HW/AsyncIOManager.h @@ -17,7 +17,8 @@ #include #include -#include "base/mutex.h" +#include + #include "Core/ThreadEventQueue.h" class NoBase { @@ -84,8 +85,6 @@ public: void Shutdown(); bool HasResult(u32 handle); - bool PopResult(u32 handle, AsyncIOResult &result); - bool ReadResult(u32 handle, AsyncIOResult &result); bool WaitResult(u32 handle, AsyncIOResult &result); u64 ResultFinishTicks(u32 handle); @@ -96,13 +95,15 @@ protected: } private: + bool PopResult(u32 handle, AsyncIOResult &result); + bool ReadResult(u32 handle, AsyncIOResult &result); void Read(u32 handle, u8 *buf, size_t bytes, u32 invalidateAddr); void Write(u32 handle, u8 *buf, size_t bytes); void EventResult(u32 handle, AsyncIOResult result); - recursive_mutex resultsLock_; - condition_variable resultsWait_; + std::mutex resultsLock_; + std::condition_variable resultsWait_; std::set resultsPending_; std::map results_; }; \ No newline at end of file diff --git a/Core/HW/StereoResampler.h b/Core/HW/StereoResampler.h index 77fc5bee02..57dbe37773 100644 --- a/Core/HW/StereoResampler.h +++ b/Core/HW/StereoResampler.h @@ -21,8 +21,6 @@ #include -#include "base/mutex.h" - #include "Common/ChunkFile.h" #include "Common/CommonTypes.h" diff --git a/Core/MIPS/MIPSAnalyst.cpp b/Core/MIPS/MIPSAnalyst.cpp index 7af8f6fc11..7c5a213d5b 100644 --- a/Core/MIPS/MIPSAnalyst.cpp +++ b/Core/MIPS/MIPSAnalyst.cpp @@ -16,10 +16,11 @@ // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. #include -#include #include +#include #include -#include "base/mutex.h" +#include + #include "ext/cityhash/city.h" #include "Common/FileUtil.h" #include "Core/Config.h" @@ -40,7 +41,7 @@ using namespace MIPSCodeUtils; // Not in a namespace because MSVC's debugger doesn't like it typedef std::vector FunctionsVector; static FunctionsVector functions; -recursive_mutex functions_lock; +std::recursive_mutex functions_lock; // One function can appear in multiple copies in memory, and they will all have // the same hash and should all be replaced if possible. @@ -741,13 +742,13 @@ namespace MIPSAnalyst { } void Reset() { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); functions.clear(); hashToFunction.clear(); } void UpdateHashToFunctionMap() { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); hashToFunction.clear(); // Really need to detect C++11 features with better defines. #if !defined(IOS) @@ -869,7 +870,7 @@ namespace MIPSAnalyst { } void HashFunctions() { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); std::vector buffer; for (auto iter = functions.begin(), end = functions.end(); iter != end; iter++) { @@ -986,7 +987,7 @@ skip: } void ScanForFunctions(u32 startAddr, u32 endAddr, bool insertSymbols) { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); AnalyzedFunction currentFunction = {startAddr}; @@ -1151,7 +1152,7 @@ skip: } void RegisterFunction(u32 startAddr, u32 size, const char *name) { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); // Check if we have this already for (auto iter = functions.begin(); iter != functions.end(); iter++) { @@ -1184,7 +1185,7 @@ skip: } void ForgetFunctions(u32 startAddr, u32 endAddr) { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); // It makes sense to forget functions as modules are unloaded but it breaks // the easy way of saving a hashmap by unloading and loading a game. I added @@ -1221,7 +1222,7 @@ skip: } void ReplaceFunctions() { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); for (size_t i = 0; i < functions.size(); i++) { WriteReplaceInstructions(functions[i].start, functions[i].hash, functions[i].size); @@ -1229,7 +1230,7 @@ skip: } void UpdateHashMap() { - lock_guard guard(functions_lock); + std::lock_guard guard(functions_lock); for (auto it = functions.begin(), end = functions.end(); it != end; ++it) { const AnalyzedFunction &f = *it; diff --git a/Core/MemMap.cpp b/Core/MemMap.cpp index be7e7d0e57..2ba4bf74de 100644 --- a/Core/MemMap.cpp +++ b/Core/MemMap.cpp @@ -15,10 +15,11 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. -#include - #include "ppsspp_config.h" -#include "base/mutex.h" + +#include +#include + #include "Common/Common.h" #include "Common/MemoryUtil.h" #include "Common/MemArena.h" @@ -77,7 +78,7 @@ u32 g_MemorySize; // Used to store the PSP model on game startup. u32 g_PSPModel; -recursive_mutex g_shutdownLock; +std::mutex g_shutdownLock; // We don't declare the IO region in here since its handled by other means. static MemoryView views[] = @@ -315,7 +316,7 @@ void DoState(PointerWrap &p) { } void Shutdown() { - lock_guard guard(g_shutdownLock); + std::lock_guard guard(g_shutdownLock); u32 flags = 0; MemoryMap_Shutdown(flags); base = nullptr; diff --git a/Core/PSPLoaders.cpp b/Core/PSPLoaders.cpp index 1985949faa..d94a102fb8 100644 --- a/Core/PSPLoaders.cpp +++ b/Core/PSPLoaders.cpp @@ -19,6 +19,9 @@ #include "util/text/utf8.h" #include "Common/StringUtils.h" +#ifdef _WIN32 +#include "Common/CommonWindows.h" +#endif #include "Core/ELF/ElfReader.h" #include "Core/ELF/ParamSFO.h" diff --git a/Core/Reporting.cpp b/Core/Reporting.cpp index 2afd721dae..ccd9f937e0 100644 --- a/Core/Reporting.cpp +++ b/Core/Reporting.cpp @@ -85,8 +85,8 @@ namespace Reporting static Payload payloadBuffer[PAYLOAD_BUFFER_SIZE]; static int payloadBufferPos = 0; - static recursive_mutex crcLock; - static condition_variable crcCond; + static std::mutex crcLock; + static std::condition_variable crcCond; static std::string crcFilename; static std::map crcResults; @@ -105,7 +105,7 @@ namespace Reporting delete blockDevice; delete fileLoader; - lock_guard guard(crcLock); + std::lock_guard guard(crcLock); crcResults[crcFilename] = crc; crcCond.notify_one(); @@ -113,7 +113,7 @@ namespace Reporting } void QueueCRC() { - lock_guard guard(crcLock); + std::lock_guard guard(crcLock); const std::string &gamePath = PSP_CoreParameter().fileToStart; auto it = crcResults.find(gamePath); @@ -137,10 +137,10 @@ namespace Reporting const std::string &gamePath = PSP_CoreParameter().fileToStart; QueueCRC(); - lock_guard guard(crcLock); + std::unique_lock guard(crcLock); auto it = crcResults.find(gamePath); while (it == crcResults.end()) { - crcCond.wait(crcLock); + crcCond.wait(guard); it = crcResults.find(gamePath); } diff --git a/Core/SaveState.cpp b/Core/SaveState.cpp index 8c9a1d71d5..5332469ab8 100644 --- a/Core/SaveState.cpp +++ b/Core/SaveState.cpp @@ -18,8 +18,8 @@ #include #include #include +#include -#include "base/mutex.h" #include "base/timeutil.h" #include "i18n/i18n.h" #include "thread/threadutil.h" @@ -98,7 +98,7 @@ namespace SaveState CChunkFileReader::Error Save() { - lock_guard guard(lock_); + std::lock_guard guard(lock_); int n = next_++ % size_; if ((next_ % size_) == first_) @@ -129,7 +129,7 @@ namespace SaveState CChunkFileReader::Error Restore() { - lock_guard guard(lock_); + std::lock_guard guard(lock_); // No valid states left. if (Empty()) @@ -155,7 +155,7 @@ namespace SaveState void Compress(std::vector &result, const std::vector &state, const std::vector &base) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); // Bail if we were cleared before locking. if (first_ == 0 && next_ == 0) return; @@ -176,7 +176,7 @@ namespace SaveState void Decompress(std::vector &result, const std::vector &compressed, const std::vector &base) { - lock_guard guard(lock_); + std::lock_guard guard(lock_); result.clear(); result.reserve(base.size()); auto basePos = base.begin(); @@ -203,7 +203,7 @@ namespace SaveState void Clear() { // This lock is mainly for shutdown. - lock_guard guard(lock_); + std::lock_guard guard(lock_); first_ = 0; next_ = 0; } @@ -226,7 +226,7 @@ namespace SaveState std::vector states_; StateBuffer bases_[2]; std::vector baseMapping_; - recursive_mutex lock_; + std::mutex lock_; int base_; int baseUsage_; @@ -234,7 +234,7 @@ namespace SaveState static bool needsProcess = false; static std::vector pending; - static recursive_mutex mutex; + static std::mutex mutex; static bool hasLoadedState = false; // TODO: Should this be configurable? @@ -278,7 +278,7 @@ namespace SaveState void Enqueue(SaveState::Operation op) { - lock_guard guard(mutex); + std::lock_guard guard(mutex); pending.push_back(op); // Don't actually run it until next frame. @@ -508,7 +508,7 @@ namespace SaveState std::vector Flush() { - lock_guard guard(mutex); + std::lock_guard guard(mutex); std::vector copy = pending; pending.clear(); @@ -697,7 +697,7 @@ namespace SaveState // Make sure there's a directory for save slots pspFileSystem.MkDir("ms0:/PSP/PPSSPP_STATE"); - lock_guard guard(mutex); + std::lock_guard guard(mutex); rewindStates.Clear(); hasLoadedState = false; @@ -705,7 +705,7 @@ namespace SaveState void Shutdown() { - lock_guard guard(mutex); + std::lock_guard guard(mutex); rewindStates.Clear(); } } diff --git a/Core/System.cpp b/Core/System.cpp index 6c9751995c..2338fc39b7 100644 --- a/Core/System.cpp +++ b/Core/System.cpp @@ -25,10 +25,10 @@ #include #endif #include +#include #include "math/math_util.h" #include "thread/threadutil.h" -#include "base/mutex.h" #include "util/text/utf8.h" #include "Core/MemMap.h" @@ -80,9 +80,9 @@ static CoreParameter coreParameter; static FileLoader *loadedFile; static std::thread *cpuThread = nullptr; static std::thread::id cpuThreadID; -static recursive_mutex cpuThreadLock; -static condition_variable cpuThreadCond; -static condition_variable cpuThreadReplyCond; +static std::mutex cpuThreadLock; +static std::condition_variable cpuThreadCond; +static std::condition_variable cpuThreadReplyCond; static u64 cpuThreadUntil; bool audioInitialized; @@ -133,17 +133,21 @@ bool IsOnSeparateCPUThread() { } } -void CPU_SetState(CPUThreadState to) { - lock_guard guard(cpuThreadLock); +void CPU_SetStateNoLock(CPUThreadState to) { cpuThreadState = to; cpuThreadCond.notify_one(); cpuThreadReplyCond.notify_one(); } +void CPU_SetState(CPUThreadState to) { + std::lock_guard guard(cpuThreadLock); + CPU_SetStateNoLock(to); +} + bool CPU_NextState(CPUThreadState from, CPUThreadState to) { - lock_guard guard(cpuThreadLock); + std::lock_guard guard(cpuThreadLock); if (cpuThreadState == from) { - CPU_SetState(to); + CPU_SetStateNoLock(to); return true; } else { return false; @@ -151,9 +155,9 @@ bool CPU_NextState(CPUThreadState from, CPUThreadState to) { } bool CPU_NextStateNot(CPUThreadState from, CPUThreadState to) { - lock_guard guard(cpuThreadLock); + std::lock_guard guard(cpuThreadLock); if (cpuThreadState != from) { - CPU_SetState(to); + CPU_SetStateNoLock(to); return true; } else { return false; @@ -172,10 +176,10 @@ bool CPU_HasPendingAction() { return cpuThreadState != CPU_THREAD_RUNNING; } -void CPU_WaitStatus(condition_variable &cond, bool (*pred)()) { - lock_guard guard(cpuThreadLock); +void CPU_WaitStatus(std::condition_variable &cond, bool (*pred)()) { + std::unique_lock guard(cpuThreadLock); while (!pred()) { - cond.wait(cpuThreadLock); + cond.wait(guard); } } diff --git a/Core/ThreadEventQueue.h b/Core/ThreadEventQueue.h index d6d6737975..66f442cdfd 100644 --- a/Core/ThreadEventQueue.h +++ b/Core/ThreadEventQueue.h @@ -17,10 +17,12 @@ #pragma once -#include "base/mutex.h" +#include +#include +#include + #include "Core/System.h" #include "Core/CoreTiming.h" -#include template struct ThreadEventQueue : public B { @@ -37,7 +39,7 @@ struct ThreadEventQueue : public B { void ScheduleEvent(Event ev) { if (threadEnabled_) { - lock_guard guard(eventsLock_); + std::lock_guard guard(eventsLock_); events_.push_back(ev); eventsWait_.notify_one(); } else { @@ -51,7 +53,7 @@ struct ThreadEventQueue : public B { bool HasEvents() { if (threadEnabled_) { - lock_guard guard(eventsLock_); + std::lock_guard guard(eventsLock_); return !events_.empty(); } else { return !events_.empty(); @@ -60,14 +62,14 @@ struct ThreadEventQueue : public B { void NotifyDrain() { if (threadEnabled_) { - lock_guard guard(eventsLock_); + std::lock_guard guard(eventsLock_); eventsDrain_.notify_one(); } } Event GetNextEvent() { if (threadEnabled_) { - lock_guard guard(eventsLock_); + std::lock_guard guard(eventsLock_); if (events_.empty()) { NotifyDrain(); return EVENT_INVALID; @@ -96,22 +98,22 @@ struct ThreadEventQueue : public B { return; } - lock_guard guard(eventsLock_); + std::unique_lock guard(eventsLock_); eventsRunning_ = true; eventsHaveRun_ = true; do { - while (!HasEvents() && !ShouldExitEventLoop()) { - eventsWait_.wait(eventsLock_); + while (events_.empty() && !ShouldExitEventLoop()) { + eventsWait_.wait(guard); } // Quit the loop if the queue is drained and coreState has tripped, or threading is disabled. - if (!HasEvents()) { + if (events_.empty()) { break; } for (Event ev = GetNextEvent(); EventType(ev) != EVENT_INVALID; ev = GetNextEvent()) { - eventsLock_.unlock(); + guard.unlock(); ProcessEventIfApplicable(ev, globalticks); - eventsLock_.lock(); + guard.lock(); } } while (CoreTiming::GetTicks() < globalticks); @@ -122,7 +124,7 @@ struct ThreadEventQueue : public B { void SyncBeginFrame() { if (threadEnabled_) { - lock_guard guard(eventsLock_); + std::lock_guard guard(eventsLock_); eventsHaveRun_ = false; } else { eventsHaveRun_ = false; @@ -151,12 +153,12 @@ struct ThreadEventQueue : public B { return; } - lock_guard guard(eventsLock_); + std::unique_lock guard(eventsLock_); // While processing the last event, HasEvents() will be false even while not done. // So we schedule a nothing event and wait for that to finish. ScheduleEvent(EVENT_SYNC); while (ShouldSyncThread(force)) { - eventsDrain_.wait(eventsLock_); + eventsDrain_.wait(guard); } } @@ -165,7 +167,7 @@ struct ThreadEventQueue : public B { return; } - lock_guard guard(eventsLock_); + std::lock_guard guard(eventsLock_); // Don't schedule a finish if it's not even running. if (eventsRunning_) { ScheduleEvent(EVENT_FINISH); @@ -197,7 +199,7 @@ private: bool eventsRunning_; bool eventsHaveRun_; std::deque events_; - recursive_mutex eventsLock_; - condition_variable eventsWait_; - condition_variable eventsDrain_; + std::recursive_mutex eventsLock_; // TODO: Should really make this non-recursive - condition_variable_any is dangerous + std::condition_variable_any eventsWait_; + std::condition_variable_any eventsDrain_; }; diff --git a/GPU/D3D11/DrawEngineD3D11.cpp b/GPU/D3D11/DrawEngineD3D11.cpp index eabee0b7f5..e822408af8 100644 --- a/GPU/D3D11/DrawEngineD3D11.cpp +++ b/GPU/D3D11/DrawEngineD3D11.cpp @@ -15,6 +15,8 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. +#include + #include "base/logging.h" #include "base/timeutil.h" @@ -32,6 +34,7 @@ #include "GPU/Common/TextureDecoder.h" #include "GPU/Common/SplineCommon.h" + #include "GPU/Common/TransformCommon.h" #include "GPU/Common/VertexDecoderCommon.h" #include "GPU/Common/SoftwareTransformCommon.h" diff --git a/GPU/D3D11/TextureCacheD3D11.h b/GPU/D3D11/TextureCacheD3D11.h index d4232e20c6..0d10c012f8 100644 --- a/GPU/D3D11/TextureCacheD3D11.h +++ b/GPU/D3D11/TextureCacheD3D11.h @@ -17,9 +17,10 @@ #pragma once +#include "Common/CommonWindows.h" + #include -#include "../Globals.h" #include "GPU/GPU.h" #include "GPU/GPUInterface.h" #include "GPU/D3D11/TextureScalerD3D11.h" diff --git a/GPU/Debugger/Breakpoints.cpp b/GPU/Debugger/Breakpoints.cpp index 8c3e9c5e28..1e1effafc6 100644 --- a/GPU/Debugger/Breakpoints.cpp +++ b/GPU/Debugger/Breakpoints.cpp @@ -17,13 +17,15 @@ #include #include -#include "base/mutex.h" +#include + +#include "base/basictypes.h" #include "GPU/Debugger/Breakpoints.h" #include "GPU/GPUState.h" namespace GPUBreakpoints { -static recursive_mutex breaksLock; +static std::mutex breaksLock; static std::vector breakCmds; static std::set breakPCs; static std::set breakTextures; @@ -175,7 +177,7 @@ bool IsAddressBreakpoint(u32 addr, bool &temp) { return false; } - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); temp = breakPCsTemp.find(addr) != breakPCsTemp.end(); return breakPCs.find(addr) != breakPCs.end(); } @@ -185,7 +187,7 @@ bool IsAddressBreakpoint(u32 addr) { return false; } - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); return breakPCs.find(addr) != breakPCs.end(); } @@ -195,7 +197,7 @@ bool IsTextureBreakpoint(u32 addr, bool &temp) { return false; } - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); temp = breakTexturesTemp.find(addr) != breakTexturesTemp.end(); return breakTextures.find(addr) != breakTextures.end(); } @@ -205,7 +207,7 @@ bool IsTextureBreakpoint(u32 addr) { return false; } - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); return breakTextures.find(addr) != breakTextures.end(); } @@ -217,7 +219,7 @@ bool IsRenderTargetBreakpoint(u32 addr, bool &temp) { addr &= 0x003FFFF0; - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); temp = breakRenderTargetsTemp.find(addr) != breakRenderTargetsTemp.end(); return breakRenderTargets.find(addr) != breakRenderTargets.end(); } @@ -229,7 +231,7 @@ bool IsRenderTargetBreakpoint(u32 addr) { addr &= 0x003FFFF0; - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); return breakRenderTargets.find(addr) != breakRenderTargets.end(); } @@ -251,7 +253,7 @@ bool IsCmdBreakpoint(u8 cmd) { } void AddAddressBreakpoint(u32 addr, bool temp) { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); if (temp) { if (breakPCs.find(addr) == breakPCs.end()) { @@ -283,7 +285,7 @@ void AddCmdBreakpoint(u8 cmd, bool temp) { } void AddTextureBreakpoint(u32 addr, bool temp) { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); if (temp) { if (breakTextures.find(addr) == breakTextures.end()) { @@ -299,7 +301,7 @@ void AddTextureBreakpoint(u32 addr, bool temp) { } void AddRenderTargetBreakpoint(u32 addr, bool temp) { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); addr &= 0x003FFFF0; @@ -321,7 +323,7 @@ void AddTextureChangeTempBreakpoint() { } void RemoveAddressBreakpoint(u32 addr) { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); breakPCsTemp.erase(addr); breakPCs.erase(addr); @@ -335,7 +337,7 @@ void RemoveCmdBreakpoint(u8 cmd) { } void RemoveTextureBreakpoint(u32 addr) { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); breakTexturesTemp.erase(addr); breakTextures.erase(addr); @@ -344,7 +346,7 @@ void RemoveTextureBreakpoint(u32 addr) { } void RemoveRenderTargetBreakpoint(u32 addr) { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); addr &= 0x003FFFF0; @@ -363,7 +365,7 @@ void UpdateLastTexture(u32 addr) { } void ClearAllBreakpoints() { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); breakCmds.clear(); breakCmds.resize(256, false); @@ -385,7 +387,7 @@ void ClearAllBreakpoints() { } void ClearTempBreakpoints() { - lock_guard guard(breaksLock); + std::lock_guard guard(breaksLock); // Reset ones that were temporary back to non-breakpoints in the primary arrays. for (int i = 0; i < 256; ++i) { diff --git a/GPU/Debugger/Stepping.cpp b/GPU/Debugger/Stepping.cpp index d2407b880b..3afff2b1cd 100644 --- a/GPU/Debugger/Stepping.cpp +++ b/GPU/Debugger/Stepping.cpp @@ -15,7 +15,9 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. -#include "base/mutex.h" +#include +#include + #include "GPU/Common/GPUDebugInterface.h" #include "GPU/Debugger/Stepping.h" #include "GPU/GPUState.h" @@ -36,11 +38,11 @@ enum PauseAction { static bool isStepping; -static recursive_mutex pauseLock; -static condition_variable pauseWait; +static std::mutex pauseLock; +static std::condition_variable pauseWait; static PauseAction pauseAction = PAUSE_CONTINUE; -static recursive_mutex actionLock; -static condition_variable actionWait; +static std::mutex actionLock; +static std::condition_variable actionWait; // In case of accidental wakeup. static volatile bool actionComplete; @@ -59,22 +61,20 @@ static int bufferLevel; static u32 pauseSetCmdValue; static void SetPauseAction(PauseAction act, bool waitComplete = true) { - { - lock_guard guard(pauseLock); - actionLock.lock(); - pauseAction = act; - } + pauseLock.lock(); + std::unique_lock guard(actionLock); + pauseAction = act; + pauseLock.unlock(); actionComplete = false; pauseWait.notify_one(); while (waitComplete && !actionComplete) { - actionWait.wait(actionLock); + actionWait.wait(guard); } - actionLock.unlock(); } static void RunPauseAction() { - lock_guard guard(actionLock); + std::lock_guard guard(actionLock); switch (pauseAction) { case PAUSE_CONTINUE: @@ -118,7 +118,7 @@ static void RunPauseAction() { } bool EnterStepping(std::function callback) { - lock_guard guard(pauseLock); + std::unique_lock guard(pauseLock); if (coreState != CORE_RUNNING && coreState != CORE_NEXTFRAME) { // Shutting down, don't try to step. return false; @@ -139,7 +139,7 @@ bool EnterStepping(std::function callback) { do { RunPauseAction(); - pauseWait.wait(pauseLock); + pauseWait.wait(guard); } while (pauseAction != PAUSE_CONTINUE); gpuDebug->NotifySteppingExit(); @@ -203,4 +203,4 @@ void ForceUnpause() { actionWait.notify_one(); } -}; +} // namespace diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index 24c1255f65..8379a035ef 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -1,7 +1,7 @@ #include #include +#include -#include "base/mutex.h" #include "base/timeutil.h" #include "Common/ColorConv.h" #include "Core/Reporting.h" @@ -679,7 +679,7 @@ void GPUCommon::UpdatePC(u32 currentPC, u32 newPC) { } // Exit the runloop and recalculate things. This happens a lot in some games. - easy_guard innerGuard(listLock); + // No need to lock, this function is always called under listLock. if (currentList) downcount = currentList->stall == 0 ? 0x0FFFFFFF : (currentList->stall - newPC) / 4; else @@ -936,7 +936,7 @@ void GPUCommon::Execute_Ret(u32 op, u32 diff) { void GPUCommon::Execute_End(u32 op, u32 diff) { easy_guard guard(listLock); const u32 prev = Memory::ReadUnchecked_U32(currentList->pc - 4); - UpdatePC(currentList->pc); + UpdatePC(currentList->pc, currentList->pc); // Count in a few extra cycles on END. cyclesExecuted += 60; @@ -1267,6 +1267,7 @@ void GPUCommon::Execute_WorldMtxNum(u32 op, u32 diff) { gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | ((op + count) & 0xF); // Skip over the loaded data, it's done now. + easy_guard innerGuard(listLock); UpdatePC(currentList->pc, currentList->pc + count * 4); currentList->pc += count * 4; } @@ -1307,6 +1308,7 @@ void GPUCommon::Execute_ViewMtxNum(u32 op, u32 diff) { gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | ((op + count) & 0xF); // Skip over the loaded data, it's done now. + easy_guard innerGuard(listLock); UpdatePC(currentList->pc, currentList->pc + count * 4); currentList->pc += count * 4; } @@ -1347,6 +1349,7 @@ void GPUCommon::Execute_ProjMtxNum(u32 op, u32 diff) { gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | ((op + count) & 0x1F); // Skip over the loaded data, it's done now. + easy_guard innerGuard(listLock); UpdatePC(currentList->pc, currentList->pc + count * 4); currentList->pc += count * 4; } @@ -1388,6 +1391,7 @@ void GPUCommon::Execute_TgenMtxNum(u32 op, u32 diff) { gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | ((op + count) & 0xF); // Skip over the loaded data, it's done now. + easy_guard innerGuard(listLock); UpdatePC(currentList->pc, currentList->pc + count * 4); currentList->pc += count * 4; } @@ -1447,6 +1451,7 @@ void GPUCommon::Execute_BoneMtxNum(u32 op, u32 diff) { gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | ((op + count) & 0x7F); // Skip over the loaded data, it's done now. + easy_guard innerGuard(listLock); UpdatePC(currentList->pc, currentList->pc + count * 4); currentList->pc += count * 4; } diff --git a/GPU/GPUCommon.h b/GPU/GPUCommon.h index 14ddaa63fc..f4a3bb3969 100644 --- a/GPU/GPUCommon.h +++ b/GPU/GPUCommon.h @@ -138,7 +138,7 @@ public: _mm_empty(); return safeResult; #else - lock_guard guard(curTickEstLock_); + std::lock_guard guard(curTickEstLock_); return curTickEst_; #endif } @@ -222,9 +222,6 @@ protected: virtual void FastRunLoop(DisplayList &list) = 0; void SlowRunLoop(DisplayList &list); void UpdatePC(u32 currentPC, u32 newPC); - void UpdatePC(u32 currentPC) { - UpdatePC(currentPC, currentPC); - } void UpdateState(GPURunState state); void PopDLQueue(); void CheckDrawSync(); @@ -248,10 +245,31 @@ protected: void PerformStencilUploadInternal(u32 dest, int size); void InvalidateCacheInternal(u32 addr, int size, GPUInvalidationType type); + // This mutex can be disabled, which is useful for single core mode. + class optional_mutex { + public: + optional_mutex() : enabled_(true) {} + void set_enabled(bool enabled) { + enabled_ = enabled; + } + void lock() { + if (enabled_) + mutex_.lock(); + } + void unlock() { + if (enabled_) + mutex_.unlock(); + } + private: + std::mutex mutex_; + bool enabled_; + }; + + // Allows early unlocking with a guard. Do not double unlock. class easy_guard { public: - easy_guard(optional_recursive_mutex &mtx) : mtx_(mtx), locked_(true) { mtx_.lock(); } + easy_guard(optional_mutex &mtx) : mtx_(mtx), locked_(true) { mtx_.lock(); } ~easy_guard() { if (locked_) mtx_.unlock(); @@ -265,7 +283,7 @@ protected: } private: - optional_recursive_mutex &mtx_; + optional_mutex &mtx_; bool locked_; }; @@ -283,7 +301,7 @@ protected: DisplayList dls[DisplayListMaxCount]; DisplayList *currentList; DisplayListQueue dlQueue; - optional_recursive_mutex listLock; + optional_mutex listLock; bool interruptRunning; GPURunState gpuState; @@ -309,7 +327,7 @@ private: alignas(16) std::atomic curTickEst_; #else volatile MEMORY_ALIGNED16(u64) curTickEst_; - recursive_mutex curTickEstLock_; + std::mutex curTickEstLock_; #endif inline void UpdateTickEstimate(u64 value) { @@ -320,7 +338,7 @@ private: *(__m64 *)&curTickEst_ = result; _mm_empty(); #else - lock_guard guard(curTickEstLock_); + std::lock_guard guard(curTickEstLock_); curTickEst_ = value; #endif } diff --git a/UI/BackgroundAudio.cpp b/UI/BackgroundAudio.cpp index 7093ba984d..da16480db7 100644 --- a/UI/BackgroundAudio.cpp +++ b/UI/BackgroundAudio.cpp @@ -1,7 +1,8 @@ #include +#include + #include "base/logging.h" #include "base/timeutil.h" -#include "base/mutex.h" #include "file/chunk_file.h" #include "Common/CommonTypes.h" @@ -162,7 +163,7 @@ private: SimpleAudio *decoder_; }; -static recursive_mutex bgMutex; +static std::mutex bgMutex; static std::string bgGamePath; static int playbackOffset; static AT3PlusReader *at3Reader; @@ -190,7 +191,7 @@ static void ClearBackgroundAudio(bool hard) { void SetBackgroundAudioGame(const std::string &path) { time_update(); - lock_guard lock(bgMutex); + std::lock_guard lock(bgMutex); if (path == bgGamePath) { // Do nothing return; @@ -211,7 +212,7 @@ void SetBackgroundAudioGame(const std::string &path) { int PlayBackgroundAudio() { time_update(); - lock_guard lock(bgMutex); + std::lock_guard lock(bgMutex); // Immediately stop the sound if it is turned off while playing. if (!g_Config.bEnableSound) { diff --git a/UI/ControlMappingScreen.cpp b/UI/ControlMappingScreen.cpp index b4bd3a3818..bc3feb5753 100644 --- a/UI/ControlMappingScreen.cpp +++ b/UI/ControlMappingScreen.cpp @@ -17,8 +17,8 @@ #include #include +#include -#include "base/mutex.h" #include "base/colorutil.h" #include "base/logging.h" #include "i18n/i18n.h" diff --git a/UI/ControlMappingScreen.h b/UI/ControlMappingScreen.h index 341534968e..40244206ae 100644 --- a/UI/ControlMappingScreen.h +++ b/UI/ControlMappingScreen.h @@ -19,8 +19,8 @@ #include #include +#include -#include "base/mutex.h" #include "ui/view.h" #include "ui/ui_screen.h" diff --git a/UI/GameInfoCache.cpp b/UI/GameInfoCache.cpp index 259b3e9b9c..ecdc010b81 100644 --- a/UI/GameInfoCache.cpp +++ b/UI/GameInfoCache.cpp @@ -209,7 +209,7 @@ u64 GameInfo::GetInstallDataSizeInBytes() { } bool GameInfo::LoadFromPath(const std::string &gamePath) { - lock_guard guard(lock); + std::lock_guard guard(lock); // No need to rebuild if we already have it loaded. if (filePath_ != gamePath) { delete fileLoader; @@ -290,26 +290,26 @@ void GameInfo::ParseParamSFO() { } std::string GameInfo::GetTitle() { - lock_guard guard(lock); + std::lock_guard guard(lock); return title; } bool GameInfo::IsPending() { - lock_guard guard(lock); + std::lock_guard guard(lock); return pending; } bool GameInfo::IsWorking() { - lock_guard guard(lock); + std::lock_guard guard(lock); return working; } void GameInfo::SetTitle(const std::string &newTitle) { - lock_guard guard(lock); + std::lock_guard guard(lock); title = newTitle; } -static bool ReadFileToString(IFileSystem *fs, const char *filename, std::string *contents, recursive_mutex *mtx) { +static bool ReadFileToString(IFileSystem *fs, const char *filename, std::string *contents, std::mutex *mtx) { PSPFileInfo info = fs->GetFileInfo(filename); if (!info.exists) { return false; @@ -321,7 +321,7 @@ static bool ReadFileToString(IFileSystem *fs, const char *filename, std::string } if (mtx) { - lock_guard lock(*mtx); + std::lock_guard lock(*mtx); contents->resize(info.size); fs->ReadFile(handle, (u8 *)contents->data(), info.size); } else { @@ -332,12 +332,12 @@ static bool ReadFileToString(IFileSystem *fs, const char *filename, std::string return true; } -static bool ReadVFSToString(const char *filename, std::string *contents, recursive_mutex *mtx) { +static bool ReadVFSToString(const char *filename, std::string *contents, std::mutex *mtx) { size_t sz; uint8_t *data = VFSReadFile(filename, &sz); if (data) { if (mtx) { - lock_guard lock(*mtx); + std::lock_guard lock(*mtx); *contents = std::string((const char *)data, sz); } else { *contents = std::string((const char *)data, sz); @@ -363,7 +363,7 @@ public: return; { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->working = true; info_->fileType = Identify_File(info_->GetFileLoader()); } @@ -394,14 +394,14 @@ public: // First, PARAM.SFO. std::vector sfoData; if (pbp.GetSubFile(PBP_PARAM_SFO, &sfoData)) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->paramSFO.ReadSFO(sfoData); info_->ParseParamSFO(); } // Then, ICON0.PNG. if (pbp.GetSubFileSize(PBP_ICON0_PNG) > 0) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); pbp.GetSubFileAsString(PBP_ICON0_PNG, &info_->iconTextureData); } else { // Read standard icon @@ -412,19 +412,19 @@ public: if (info_->wantFlags & GAMEINFO_WANTBG) { if (pbp.GetSubFileSize(PBP_PIC0_PNG) > 0) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); pbp.GetSubFileAsString(PBP_PIC0_PNG, &info_->pic0TextureData); info_->pic0DataLoaded = true; } if (pbp.GetSubFileSize(PBP_PIC1_PNG) > 0) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); pbp.GetSubFileAsString(PBP_PIC1_PNG, &info_->pic1TextureData); info_->pic1DataLoaded = true; } } if (info_->wantFlags & GAMEINFO_WANTSND) { if (pbp.GetSubFileSize(PBP_SND0_AT3) > 0) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); pbp.GetSubFileAsString(PBP_SND0_AT3, &info_->sndFileData); info_->sndDataLoaded = true; } @@ -436,7 +436,7 @@ public: handleELF: // An elf on its own has no usable information, no icons, no nothing. { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->id = "ELF000000"; info_->id_version = "ELF000000_1.00"; info_->paramSFOLoaded = true; @@ -456,7 +456,7 @@ handleELF: // Alright, let's fetch the PARAM.SFO. std::string paramSFOcontents; if (ReadFileToString(&umd, "/PARAM.SFO", ¶mSFOcontents, 0)) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->paramSFO.ReadSFO((const u8 *)paramSFOcontents.data(), paramSFOcontents.size()); info_->ParseParamSFO(); } @@ -474,7 +474,7 @@ handleELF: { info_->SetTitle(SaveState::GetTitle(gamePath_)); - lock_guard guard(info_->lock); + std::lock_guard guard(info_->lock); // Let's use the screenshot as an icon, too. std::string screenshotPath = ReplaceAll(gamePath_, ".ppst", ".jpg"); @@ -495,7 +495,7 @@ handleELF: // Alright, let's fetch the PARAM.SFO. std::string paramSFOcontents; if (ReadFileToString(&umd, "/PSP_GAME/PARAM.SFO", ¶mSFOcontents, 0)) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->paramSFO.ReadSFO((const u8 *)paramSFOcontents.data(), paramSFOcontents.size()); info_->ParseParamSFO(); } @@ -531,18 +531,18 @@ handleELF: // Alright, let's fetch the PARAM.SFO. std::string paramSFOcontents; if (ReadFileToString(&umd, "/PSP_GAME/PARAM.SFO", ¶mSFOcontents, nullptr)) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->paramSFO.ReadSFO((const u8 *)paramSFOcontents.data(), paramSFOcontents.size()); info_->ParseParamSFO(); if (info_->wantFlags & GAMEINFO_WANTBG) { - ReadFileToString(&umd, "/PSP_GAME/PIC0.PNG", &info_->pic0TextureData, &info_->lock); + ReadFileToString(&umd, "/PSP_GAME/PIC0.PNG", &info_->pic0TextureData, nullptr); info_->pic0DataLoaded = true; - ReadFileToString(&umd, "/PSP_GAME/PIC1.PNG", &info_->pic1TextureData, &info_->lock); + ReadFileToString(&umd, "/PSP_GAME/PIC1.PNG", &info_->pic1TextureData, nullptr); info_->pic1DataLoaded = true; } if (info_->wantFlags & GAMEINFO_WANTSND) { - ReadFileToString(&umd, "/PSP_GAME/SND0.AT3", &info_->sndFileData, &info_->lock); + ReadFileToString(&umd, "/PSP_GAME/SND0.AT3", &info_->sndFileData, nullptr); info_->pic1DataLoaded = true; } } @@ -589,13 +589,13 @@ handleELF: info_->hasConfig = g_Config.hasGameConfig(info_->id); if (info_->wantFlags & GAMEINFO_WANTSIZE) { - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->gameSize = info_->GetGameSizeInBytes(); info_->saveDataSize = info_->GetSaveDataSizeInBytes(); info_->installDataSize = info_->GetInstallDataSizeInBytes(); } - lock_guard lock(info_->lock); + std::lock_guard lock(info_->lock); info_->pending = false; info_->working = false; // ILOG("Completed writing info for %s", info_->GetTitle().c_str()); @@ -640,7 +640,7 @@ void GameInfoCache::Clear() { } for (auto iter = info_.begin(); iter != info_.end(); iter++) { { - lock_guard lock(iter->second->lock); + std::lock_guard lock(iter->second->lock); if (!iter->second->pic0TextureData.empty()) { iter->second->pic0TextureData.clear(); iter->second->pic0DataLoaded = false; @@ -678,7 +678,7 @@ void GameInfoCache::Clear() { void GameInfoCache::FlushBGs() { for (auto iter = info_.begin(); iter != info_.end(); iter++) { - lock_guard lock(iter->second->lock); + std::lock_guard lock(iter->second->lock); if (!iter->second->pic0TextureData.empty()) { iter->second->pic0TextureData.clear(); iter->second->pic0DataLoaded = false; @@ -770,7 +770,7 @@ again: } { - lock_guard lock(info->lock); + std::lock_guard lock(info->lock); info->wantFlags |= wantFlags; info->pending = true; } diff --git a/UI/GameInfoCache.h b/UI/GameInfoCache.h index 6096693d27..16dfe88f5b 100644 --- a/UI/GameInfoCache.h +++ b/UI/GameInfoCache.h @@ -19,8 +19,8 @@ #include #include +#include -#include "base/mutex.h" #include "file/file_util.h" #include "Core/ELF/ParamSFO.h" #include "Core/Loaders.h" @@ -129,7 +129,7 @@ public: // Don't need to hold it when just passing around the pointer, // and obviously also not when creating it and holding the only pointer // to it. - recursive_mutex lock; + std::mutex lock; std::string id; std::string id_version; diff --git a/UI/MainScreen.cpp b/UI/MainScreen.cpp index b8ccc4042e..263a88cc5d 100644 --- a/UI/MainScreen.cpp +++ b/UI/MainScreen.cpp @@ -673,7 +673,7 @@ const std::string GameBrowser::GetBaseName(const std::string &path) { UI::EventReturn GameBrowser::GameButtonClick(UI::EventParams &e) { GameButton *button = static_cast(e.v); - UI::EventParams e2; + UI::EventParams e2{}; e2.s = button->GamePath(); // Insta-update - here we know we are already on the right thread. OnChoice.Trigger(e2); @@ -682,7 +682,7 @@ UI::EventReturn GameBrowser::GameButtonClick(UI::EventParams &e) { UI::EventReturn GameBrowser::GameButtonHoldClick(UI::EventParams &e) { GameButton *button = static_cast(e.v); - UI::EventParams e2; + UI::EventParams e2{}; e2.s = button->GamePath(); // Insta-update - here we know we are already on the right thread. OnHoldChoice.Trigger(e2); diff --git a/UI/NativeApp.cpp b/UI/NativeApp.cpp index edd468b946..cb6986b80a 100644 --- a/UI/NativeApp.cpp +++ b/UI/NativeApp.cpp @@ -35,6 +35,7 @@ #endif #include #include +#include #if defined(_WIN32) #include "Windows/DSoundStream.h" @@ -43,7 +44,6 @@ #include "base/display.h" #include "base/logging.h" -#include "base/mutex.h" #include "base/NativeApp.h" #include "file/vfs.h" #include "file/zip_read.h" @@ -139,7 +139,7 @@ struct PendingMessage { std::string value; }; -static recursive_mutex pendingMutex; +static std::mutex pendingMutex; static std::vector pendingMessages; static Draw::DrawContext *g_draw; static Draw::Pipeline *colorPipeline; @@ -858,7 +858,7 @@ void NativeUpdate(InputState &input) { PROFILE_END_FRAME(); { - lock_guard lock(pendingMutex); + std::lock_guard lock(pendingMutex); for (size_t i = 0; i < pendingMessages.size(); i++) { HandleGlobalMessage(pendingMessages[i].msg, pendingMessages[i].value); screenManager->sendMessage(pendingMessages[i].msg.c_str(), pendingMessages[i].value.c_str()); @@ -1010,7 +1010,7 @@ bool NativeAxis(const AxisInput &axis) { void NativeMessageReceived(const char *message, const char *value) { // We can only have one message queued. - lock_guard lock(pendingMutex); + std::lock_guard lock(pendingMutex); PendingMessage pendingMessage; pendingMessage.msg = message; pendingMessage.value = value; diff --git a/UI/OnScreenDisplay.cpp b/UI/OnScreenDisplay.cpp index cd9152d837..d308c43d90 100644 --- a/UI/OnScreenDisplay.cpp +++ b/UI/OnScreenDisplay.cpp @@ -55,7 +55,7 @@ restart: void OnScreenMessages::Show(const std::string &text, float duration_s, uint32_t color, int icon, bool checkUnique, const char *id) { double now = time_now_d(); - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); if (checkUnique) { for (auto iter = messages_.begin(); iter != messages_.end(); ++iter) { if (iter->text == text || (id && iter->id && !strcmp(iter->id, id))) { diff --git a/UI/OnScreenDisplay.h b/UI/OnScreenDisplay.h index 8a0c6c17e0..6fbf093e55 100644 --- a/UI/OnScreenDisplay.h +++ b/UI/OnScreenDisplay.h @@ -2,8 +2,8 @@ #include #include +#include -#include "base/mutex.h" #include "base/basictypes.h" #include "math/geom2d.h" @@ -39,7 +39,7 @@ public: private: std::list messages_; - recursive_mutex mutex_; + std::mutex mutex_; }; class OnScreenMessagesView : public UI::InertView { diff --git a/UI/RemoteISOScreen.cpp b/UI/RemoteISOScreen.cpp index d2ee1a37e7..e9e62524ae 100644 --- a/UI/RemoteISOScreen.cpp +++ b/UI/RemoteISOScreen.cpp @@ -46,19 +46,19 @@ enum class ServerStatus { static std::thread *serverThread = nullptr; static ServerStatus serverStatus; -static recursive_mutex serverStatusLock; -static condition_variable serverStatusCond; +static std::mutex serverStatusLock; +static std::condition_variable serverStatusCond; static bool scanCancelled = false; static void UpdateStatus(ServerStatus s) { - lock_guard guard(serverStatusLock); + std::lock_guard guard(serverStatusLock); serverStatus = s; serverStatusCond.notify_one(); } static ServerStatus RetrieveStatus() { - lock_guard guard(serverStatusLock); + std::lock_guard guard(serverStatusLock); return serverStatus; } @@ -351,7 +351,7 @@ void RemoteISOScreen::CreateViews() { } UI::EventReturn RemoteISOScreen::HandleStartServer(UI::EventParams &e) { - lock_guard guard(serverStatusLock); + std::lock_guard guard(serverStatusLock); if (serverStatus != ServerStatus::STOPPED) { return EVENT_SKIPPED; @@ -365,7 +365,7 @@ UI::EventReturn RemoteISOScreen::HandleStartServer(UI::EventParams &e) { } UI::EventReturn RemoteISOScreen::HandleStopServer(UI::EventParams &e) { - lock_guard guard(serverStatusLock); + std::lock_guard guard(serverStatusLock); if (serverStatus != ServerStatus::RUNNING) { return EVENT_SKIPPED; @@ -385,7 +385,6 @@ UI::EventReturn RemoteISOScreen::HandleBrowse(UI::EventParams &e) { RemoteISOConnectScreen::RemoteISOConnectScreen() : status_(ScanStatus::SCANNING), nextRetry_(0.0) { scanCancelled = false; - statusLock_ = new recursive_mutex(); scanThread_ = new std::thread([](RemoteISOConnectScreen *thiz) { thiz->ExecuteScan(); @@ -404,7 +403,6 @@ RemoteISOConnectScreen::~RemoteISOConnectScreen() { } } delete scanThread_; - delete statusLock_; } void RemoteISOConnectScreen::CreateViews() { @@ -486,12 +484,12 @@ void RemoteISOConnectScreen::ExecuteScan() { return; } - lock_guard guard(*statusLock_); + std::lock_guard guard(statusLock_); status_ = host_.empty() ? ScanStatus::FAILED : ScanStatus::FOUND; } ScanStatus RemoteISOConnectScreen::GetStatus() { - lock_guard guard(*statusLock_); + std::lock_guard guard(statusLock_); return status_; } @@ -501,7 +499,7 @@ void RemoteISOConnectScreen::ExecuteLoad() { return; } - lock_guard guard(*statusLock_); + std::lock_guard guard(statusLock_); status_ = result ? ScanStatus::LOADED : ScanStatus::FAILED; } diff --git a/UI/RemoteISOScreen.h b/UI/RemoteISOScreen.h index b51a0ce943..d4bcd4074e 100644 --- a/UI/RemoteISOScreen.h +++ b/UI/RemoteISOScreen.h @@ -18,14 +18,13 @@ #pragma once #include +#include #include "ui/ui_screen.h" #include "ui/viewgroup.h" #include "UI/MiscScreens.h" #include "UI/MainScreen.h" -class recursive_mutex; - class RemoteISOScreen : public UIScreenWithBackground { public: RemoteISOScreen(); @@ -69,7 +68,7 @@ protected: ScanStatus status_; double nextRetry_; std::thread *scanThread_; - recursive_mutex *statusLock_; + std::mutex statusLock_; std::string host_; int port_; std::vector games_; diff --git a/Windows/EmuThread.cpp b/Windows/EmuThread.cpp index f9d1ffa301..6280066bba 100644 --- a/Windows/EmuThread.cpp +++ b/Windows/EmuThread.cpp @@ -1,8 +1,9 @@ // NOTE: Apologies for the quality of this code, this is really from pre-opensource Dolphin - that is, 2003. +#include + #include "base/timeutil.h" #include "base/NativeApp.h" -#include "base/mutex.h" #include "i18n/i18n.h" #include "input/input_state.h" #include "util/text/utf8.h" @@ -27,7 +28,7 @@ #include #pragma intrinsic(_InterlockedExchange) -static recursive_mutex emuThreadLock; +static std::mutex emuThreadLock; static HANDLE emuThread; static volatile long emuThreadReady; @@ -46,7 +47,7 @@ enum EmuThreadStatus : long HANDLE EmuThread_GetThreadHandle() { - lock_guard guard(emuThreadLock); + std::lock_guard guard(emuThreadLock); return emuThread; } @@ -54,7 +55,7 @@ unsigned int WINAPI TheThread(void *); void EmuThread_Start() { - lock_guard guard(emuThreadLock); + std::lock_guard guard(emuThreadLock); emuThread = (HANDLE)_beginthreadex(0, 0, &TheThread, 0, 0, 0); } @@ -62,7 +63,7 @@ void EmuThread_Stop() { // Already stopped? { - lock_guard guard(emuThreadLock); + std::lock_guard guard(emuThreadLock); if (emuThread == NULL || emuThreadReady == THREAD_END) return; } @@ -75,7 +76,7 @@ void EmuThread_Stop() _dbg_assert_msg_(COMMON, false, "Wait for EmuThread timed out."); } { - lock_guard guard(emuThreadLock); + std::lock_guard guard(emuThreadLock); CloseHandle(emuThread); emuThread = 0; } diff --git a/Windows/InputDevice.cpp b/Windows/InputDevice.cpp index 643abeb1f3..f0b16553de 100644 --- a/Windows/InputDevice.cpp +++ b/Windows/InputDevice.cpp @@ -18,7 +18,8 @@ #include #include #include -#include "base/mutex.h" +#include + #include "input/input_state.h" #include "thread/threadutil.h" #include "Core/Config.h" @@ -32,8 +33,8 @@ static volatile bool inputThreadStatus = false; static volatile bool inputThreadEnabled = false; static std::thread *inputThread = NULL; -static recursive_mutex inputMutex; -static condition_variable inputEndCond; +static std::mutex inputMutex; +static std::condition_variable inputEndCond; static bool focused = true; extern InputState input_state; @@ -42,7 +43,7 @@ inline static void ExecuteInputPoll() { // Hm, we may hold the input_state lock for quite a while (time it takes to poll all devices)... // If that becomes an issue, maybe should poll to a copy of inputstate and only hold the lock while // copying that one to the real one? - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); input_state.pad_buttons = 0; input_state.pad_lstick_x = 0; input_state.pad_lstick_y = 0; @@ -67,13 +68,13 @@ static void RunInputThread() { Sleep(4); } - lock_guard guard(inputMutex); + std::lock_guard guard(inputMutex); inputThreadStatus = false; inputEndCond.notify_one(); } void InputDevice::BeginPolling() { - lock_guard guard(inputMutex); + std::lock_guard guard(inputMutex); inputThreadEnabled = true; inputThread = new std::thread(&RunInputThread); inputThread->detach(); @@ -82,9 +83,9 @@ void InputDevice::BeginPolling() { void InputDevice::StopPolling() { inputThreadEnabled = false; - lock_guard guard(inputMutex); + std::unique_lock guard(inputMutex); if (inputThreadStatus) { - inputEndCond.wait(inputMutex); + inputEndCond.wait(guard); } delete inputThread; inputThread = NULL; diff --git a/Windows/KeyboardDevice.h b/Windows/KeyboardDevice.h index 895b411595..ff63395335 100644 --- a/Windows/KeyboardDevice.h +++ b/Windows/KeyboardDevice.h @@ -1,7 +1,6 @@ #pragma once -#include -#include "base/mutex.h" +#include #include "InputDevice.h" extern std::map windowsTransTable; diff --git a/Windows/MainWindow.cpp b/Windows/MainWindow.cpp index d20b690b31..f1ee8a97e4 100644 --- a/Windows/MainWindow.cpp +++ b/Windows/MainWindow.cpp @@ -543,7 +543,7 @@ namespace MainWindow // Hack: Take the opportunity to show the cursor. mouseButtonDown = true; { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); input_state.mouse_valid = true; input_state.pointer_down[0] = true; @@ -589,7 +589,7 @@ namespace MainWindow prevCursorY = cursorY; { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); input_state.pointer_x[0] = GET_X_LPARAM(lParam) * g_dpi_scale; input_state.pointer_y[0] = GET_Y_LPARAM(lParam) * g_dpi_scale; } @@ -612,7 +612,7 @@ namespace MainWindow // Hack: Take the opportunity to hide the cursor. mouseButtonDown = false; { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); input_state.pointer_down[0] = false; input_state.pointer_x[0] = GET_X_LPARAM(lParam) * g_dpi_scale; input_state.pointer_y[0] = GET_Y_LPARAM(lParam) * g_dpi_scale; diff --git a/android/jni/app-android.cpp b/android/jni/app-android.cpp index 66b682ffec..19611f3509 100644 --- a/android/jni/app-android.cpp +++ b/android/jni/app-android.cpp @@ -15,11 +15,12 @@ #include #include #include +#include +#include #include "base/basictypes.h" #include "base/stringutil.h" #include "base/display.h" -#include "base/mutex.h" #include "base/NativeApp.h" #include "base/logging.h" #include "base/timeutil.h" @@ -319,7 +320,7 @@ void AndroidVulkanContext::Resize() { void AndroidVulkanContext::SwapInterval(int interval) { } -static recursive_mutex frameCommandLock; +static std::mutex frameCommandLock; static std::queue frameCommands; std::string systemName; @@ -373,7 +374,7 @@ GraphicsContext *graphicsContext; static void ProcessFrameCommands(JNIEnv *env); void PushCommand(std::string cmd, std::string param) { - lock_guard guard(frameCommandLock); + std::lock_guard guard(frameCommandLock); frameCommands.push(FrameCommand(cmd, param)); } @@ -677,7 +678,7 @@ extern "C" void Java_org_ppsspp_ppsspp_NativeRenderer_displayRender(JNIEnv *env, if (renderer_inited) { // TODO: Look into if these locks are a perf loss { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); input_state.pad_lstick_x = left_joystick_x_async; input_state.pad_lstick_y = left_joystick_y_async; @@ -689,7 +690,7 @@ extern "C" void Java_org_ppsspp_ppsspp_NativeRenderer_displayRender(JNIEnv *env, NativeUpdate(input_state); { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); EndInputState(&input_state); } @@ -705,7 +706,7 @@ extern "C" void Java_org_ppsspp_ppsspp_NativeRenderer_displayRender(JNIEnv *env, glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); } - lock_guard guard(frameCommandLock); + std::lock_guard guard(frameCommandLock); if (!nativeActivity) { while (!frameCommands.empty()) frameCommands.pop(); @@ -763,7 +764,7 @@ extern "C" jboolean JNICALL Java_org_ppsspp_ppsspp_NativeApp_touch bool retval = NativeTouch(touch); { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); if (pointerId >= MAX_POINTERS) { ELOG("Too many pointers: %i", pointerId); return false; // We ignore 8+ pointers entirely. @@ -1000,7 +1001,7 @@ extern "C" jint JNICALL Java_org_ppsspp_ppsspp_NativeApp_getDesiredBackbufferHei } static void ProcessFrameCommands(JNIEnv *env) { - lock_guard guard(frameCommandLock); + std::lock_guard guard(frameCommandLock); while (!frameCommands.empty()) { FrameCommand frameCmd; frameCmd = frameCommands.front(); @@ -1062,7 +1063,7 @@ extern "C" bool JNICALL Java_org_ppsspp_ppsspp_NativeActivity_runEGLRenderLoop(J // TODO: Look into if these locks are a perf loss { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); input_state.pad_lstick_x = left_joystick_x_async; input_state.pad_lstick_y = left_joystick_y_async; @@ -1074,7 +1075,7 @@ extern "C" bool JNICALL Java_org_ppsspp_ppsspp_NativeActivity_runEGLRenderLoop(J NativeUpdate(input_state); { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); EndInputState(&input_state); } diff --git a/ext/native/base/mutex.h b/ext/native/base/mutex.h deleted file mode 100644 index 9f017be406..0000000000 --- a/ext/native/base/mutex.h +++ /dev/null @@ -1,364 +0,0 @@ -#pragma once - -// Simple cross platform mutex implementation. -// Similar to the new C++11 api. - -// Windows and pthreads implementations in one. - -// TODO: Need to clean up these primitives and put them in a reasonable namespace. - -#ifdef _WIN32 -#define WIN32_LEAN_AND_MEAN -#ifndef NOMINMAX -#define NOMINMAX -#endif -#include -#include -#include - -// Zap stupid windows defines -// Should move these somewhere clever. -#undef p -#undef DrawText -#undef itoa -#undef min -#undef max - -#else -#include -#include -#include -#endif - -#include "base/basictypes.h" - -struct atomic_flag_init { - atomic_flag_init() : v(false) { - } - - bool v; -}; -static const atomic_flag_init NATIVE_ATOMIC_FLAG_INIT; - -class atomic_flag { -public: - atomic_flag() { - } - - atomic_flag(const atomic_flag_init &v) : value(0) { - } - - void clear() { -#if defined(_WIN32) - _WriteBarrier(); - value = 0; -#else - __sync_lock_release(&value); -#endif - } - - // Returns the previous value. - bool test_and_set() { -#if defined(_WIN32) - return InterlockedExchange(&value, 1) != 0; -#else - return __sync_lock_test_and_set(&value, 1) != 0; -#endif - } - -private: - volatile unsigned int value; - - DISALLOW_COPY_AND_ASSIGN(atomic_flag); -}; - -class recursive_mutex { -#ifdef _WIN32 - typedef CRITICAL_SECTION mutexType; -#else - typedef pthread_mutex_t mutexType; -#endif -public: - recursive_mutex() { -#ifdef _WIN32 - InitializeCriticalSection(&mut_); -#else - // Critical sections are recursive so let's make these recursive too. - pthread_mutexattr_t attr; - pthread_mutexattr_init(&attr); - pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(&mut_, &attr); -#endif - } - ~recursive_mutex() { -#ifdef _WIN32 - DeleteCriticalSection(&mut_); -#else - pthread_mutex_destroy(&mut_); -#endif - } - - bool trylock() { -#ifdef _WIN32 - return TryEnterCriticalSection(&mut_) != FALSE; -#else - return pthread_mutex_trylock(&mut_) != EBUSY; -#endif - } - - void lock() { -#ifdef _WIN32 - EnterCriticalSection(&mut_); -#else - pthread_mutex_lock(&mut_); -#endif - } - - void unlock() { -#ifdef _WIN32 - LeaveCriticalSection(&mut_); -#else - pthread_mutex_unlock(&mut_); -#endif - } - - mutexType &native_handle() { - return mut_; - } - -private: - mutexType mut_; - recursive_mutex(const recursive_mutex &other); - recursive_mutex& operator=(const recursive_mutex& other); -}; - -class lock_guard { -public: - lock_guard(recursive_mutex &mtx) : mtx_(mtx) {mtx_.lock();} - ~lock_guard() {mtx_.unlock();} - -private: - recursive_mutex &mtx_; -}; - -// This mutex can be disabled, which is useful for single core mode. -class optional_recursive_mutex { -public: - optional_recursive_mutex() : enabled_(true) {} - void set_enabled(bool enabled) { - enabled_ = enabled; - } - void lock() { - if (enabled_) - mutex_.lock(); - } - void unlock() { - if (enabled_) - mutex_.unlock(); - } - bool trylock() { - if (enabled_) - return mutex_.trylock(); - else - return true; - } -private: - recursive_mutex mutex_; - bool enabled_; -}; - -// Like a Windows event, or a modern condition variable. - -class event { -public: -#ifdef _WIN32 -#else -#endif - event() { -#ifdef _WIN32 - event_ = CreateEvent(0, FALSE, FALSE, 0); -#else - pthread_cond_init(&event_, NULL); -#endif - } - ~event() { -#ifdef _WIN32 - CloseHandle(event_); -#else - pthread_cond_destroy(&event_); -#endif - } - - void notify_one() { -#ifdef _WIN32 - SetEvent(event_); -#else - pthread_cond_signal(&event_); -#endif - } - - // notify_all is not really possible to implement with win32 events? - - void wait(recursive_mutex &mtx) { - // broken -#ifdef _WIN32 - // This has to be horribly racy. - mtx.lock(); - WaitForSingleObject(event_, INFINITE); - ResetEvent(event_); // necessary? - mtx.unlock(); -#else - pthread_mutex_lock(&mtx.native_handle()); - pthread_cond_wait(&event_, &mtx.native_handle()); - pthread_mutex_unlock(&mtx.native_handle()); -#endif - } - - void wait_for(recursive_mutex &mtx, int milliseconds) { -#ifdef _WIN32 - //mtx.unlock(); - WaitForSingleObject(event_, milliseconds); - ResetEvent(event_); // necessary? - // mtx.lock(); -#else - timespec timeout; -#ifdef __APPLE__ - timeval tv; - gettimeofday(&tv, NULL); - timeout.tv_sec = tv.tv_sec; - timeout.tv_nsec = tv.tv_usec * 1000; -#else - clock_gettime(CLOCK_REALTIME, &timeout); -#endif - timeout.tv_sec += milliseconds / 1000; - timeout.tv_nsec += (milliseconds % 1000) * 1000000; - pthread_mutex_lock(&mtx.native_handle()); - pthread_cond_timedwait(&event_, &mtx.native_handle(), &timeout); - pthread_mutex_unlock(&mtx.native_handle()); -#endif - } - - void reset() { -#ifdef _WIN32 - ResetEvent(event_); -#endif - } -private: -#ifdef _WIN32 - HANDLE event_; -#else - pthread_cond_t event_; -#endif -}; - -// Win32 CONDITION_VARIABLE is Vista+ only. We thus limit it to our 64-bit builds where -// we can be almost certain that the user isn't running XP. - -class condition_variable { -public: -#ifdef _WIN32 -#else -#endif - condition_variable() { -#ifdef _WIN32 -#ifdef _WIN64 - InitializeConditionVariable(&cond_); -#else - sema_ = CreateSemaphore(NULL, 0, LONG_MAX, NULL); - waiting_ = 0; -#endif -#else - pthread_cond_init(&event_, NULL); -#endif - } - ~condition_variable() { -#ifdef _WIN32 -#ifdef _WIN64 -#else - CloseHandle(sema_); -#endif -#else - pthread_cond_destroy(&event_); -#endif - } - - void notify_one() { -#ifdef _WIN32 -#ifdef _M_X64 - WakeConditionVariable(&cond_); -#else - // Should be locked at this time. - if (waiting_ != 0) { - ReleaseSemaphore(sema_, 1, NULL); - } -#endif -#else - pthread_cond_signal(&event_); -#endif - } - - // notify_all is not really possible to implement with win32 events? - // Can be done just fine using WakeAllConditionVariable though. - - void wait(recursive_mutex &mtx) { - // broken http://msdn.microsoft.com/en-us/library/windows/desktop/ms686301(v=vs.85).aspx -#ifdef _WIN32 -#ifdef _M_X64 - SleepConditionVariableCS(&cond_, &mtx.native_handle(), INFINITE); -#else - // Since a semaphore keeps a count, the window between unlock and lock won't cause us to deadlock. - // However, we could wake early incorrectly (if the semaphore is signalled already.) - // That's better than deadlocking or forgetting to wake. - waiting_++; - mtx.unlock(); - WaitForSingleObject(sema_, INFINITE); - mtx.lock(); - waiting_--; -#endif -#else - pthread_cond_wait(&event_, &mtx.native_handle()); -#endif - } - - void wait_for(recursive_mutex &mtx, int milliseconds) { -#ifdef _WIN32 -#ifdef _M_X64 - SleepConditionVariableCS(&cond_, &mtx.native_handle(), milliseconds); -#else - // Since a semaphore keeps a count, the window between unlock and lock won't cause us to deadlock. - // However, we could wake early incorrectly (if the semaphore is signalled already.) - // That's better than deadlocking or forgetting to wake. - waiting_++; - mtx.unlock(); - WaitForSingleObject(sema_, milliseconds); - mtx.lock(); - waiting_--; -#endif -#else - timespec timeout; -#ifdef __APPLE__ - timeval tv; - gettimeofday(&tv, NULL); - timeout.tv_sec = tv.tv_sec; - timeout.tv_nsec = tv.tv_usec * 1000; -#else - clock_gettime(CLOCK_REALTIME, &timeout); -#endif - timeout.tv_sec += milliseconds / 1000; - timeout.tv_nsec += (milliseconds % 1000) * 1000000; - pthread_cond_timedwait(&event_, &mtx.native_handle(), &timeout); -#endif - } - -private: -#ifdef _WIN32 -#ifdef _M_X64 - CONDITION_VARIABLE cond_; -#else - HANDLE sema_; - volatile int waiting_; -#endif -#else - pthread_cond_t event_; -#endif -}; diff --git a/ext/native/input/input_state.h b/ext/native/input/input_state.h index a63eecae43..e8fac8a747 100644 --- a/ext/native/input/input_state.h +++ b/ext/native/input/input_state.h @@ -10,9 +10,9 @@ #include #include +#include #include "math/lin/vec3.h" -#include "base/mutex.h" #include "base/basictypes.h" #include "input/keycodes.h" @@ -125,7 +125,7 @@ struct AxisPos { // deltas where applicable. struct InputState { // Lock this whenever you access the data in this struct. - mutable recursive_mutex lock; + mutable std::mutex lock; InputState() : pad_buttons(0), pad_last_buttons(0), diff --git a/ext/native/native.vcxproj b/ext/native/native.vcxproj index 4e031cb8f7..b0e02b3869 100644 --- a/ext/native/native.vcxproj +++ b/ext/native/native.vcxproj @@ -197,7 +197,6 @@ - diff --git a/ext/native/native.vcxproj.filters b/ext/native/native.vcxproj.filters index 1f4e1baf47..f484e83585 100644 --- a/ext/native/native.vcxproj.filters +++ b/ext/native/native.vcxproj.filters @@ -116,9 +116,6 @@ ui - - base - data diff --git a/ext/native/thread/prioritizedworkqueue.cpp b/ext/native/thread/prioritizedworkqueue.cpp index 754e9b606e..80c20136a1 100644 --- a/ext/native/thread/prioritizedworkqueue.cpp +++ b/ext/native/thread/prioritizedworkqueue.cpp @@ -12,19 +12,19 @@ PrioritizedWorkQueue::~PrioritizedWorkQueue() { } void PrioritizedWorkQueue::Add(PrioritizedWorkQueueItem *item) { - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); queue_.push_back(item); notEmpty_.notify_one(); } void PrioritizedWorkQueue::Stop() { - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); done_ = true; notEmpty_.notify_one(); } void PrioritizedWorkQueue::Flush() { - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); int flush_count = 0; for (auto iter = queue_.begin(); iter != queue_.end(); ++iter) { delete *iter; @@ -36,13 +36,13 @@ void PrioritizedWorkQueue::Flush() { bool PrioritizedWorkQueue::WaitUntilDone(bool all) { // We'll lock drain this entire time, so make sure you follow that lock ordering. - lock_guard guard(drainMutex_); + std::unique_lock guard(drainMutex_); if (AllItemsDone()) { return true; } while (!AllItemsDone()) { - drain_.wait(drainMutex_); + drain_.wait(guard); if (!all) { // Return whether empty or not, something just drained. return AllItemsDone(); @@ -53,32 +53,32 @@ bool PrioritizedWorkQueue::WaitUntilDone(bool all) { } void PrioritizedWorkQueue::NotifyDrain() { - lock_guard guard(drainMutex_); + std::lock_guard guard(drainMutex_); drain_.notify_one(); } bool PrioritizedWorkQueue::AllItemsDone() { - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); return queue_.empty() && !working_; } // The worker should simply call this in a loop. Will block when appropriate. PrioritizedWorkQueueItem *PrioritizedWorkQueue::Pop() { { - lock_guard guard(mutex_); + std::lock_guard guard(mutex_); working_ = false; // The thread only calls Pop if it's done. } // Important: make sure mutex_ is not locked while draining. NotifyDrain(); - lock_guard guard(mutex_); + std::unique_lock guard(mutex_); if (done_) { return 0; } while (queue_.empty()) { - notEmpty_.wait(mutex_); + notEmpty_.wait(guard); if (done_) { return 0; } diff --git a/ext/native/thread/prioritizedworkqueue.h b/ext/native/thread/prioritizedworkqueue.h index 5d3acea216..d7c9ad5f71 100644 --- a/ext/native/thread/prioritizedworkqueue.h +++ b/ext/native/thread/prioritizedworkqueue.h @@ -2,9 +2,9 @@ #include #include +#include #include "base/basictypes.h" -#include "base/mutex.h" #include "thread/threadutil.h" // Priorities can change dynamically. @@ -46,10 +46,10 @@ private: bool done_; bool working_; - recursive_mutex mutex_; - recursive_mutex drainMutex_; - condition_variable notEmpty_; - condition_variable drain_; + std::mutex mutex_; + std::mutex drainMutex_; + std::condition_variable notEmpty_; + std::condition_variable drain_; std::vector queue_; diff --git a/ext/native/thread/threadpool.cpp b/ext/native/thread/threadpool.cpp index b89447d084..9ba70fa39a 100644 --- a/ext/native/thread/threadpool.cpp +++ b/ext/native/thread/threadpool.cpp @@ -26,14 +26,15 @@ void WorkerThread::Process(const std::function& work) { } void WorkerThread::WaitForCompletion() { - done.wait(doneMutex); + std::unique_lock guard(doneMutex); + done.wait(guard); } void WorkerThread::WorkFunc() { - mutex.lock(); + std::unique_lock guard(mutex); started = true; while (active) { - signal.wait(mutex); + signal.wait(guard); if (active) { work_(); doneMutex.lock(); @@ -50,7 +51,7 @@ LoopWorkerThread::LoopWorkerThread() : WorkerThread(true) { } void LoopWorkerThread::Process(const std::function &work, int start, int end) { - mutex.lock(); + std::lock_guard guard(mutex); work_ = work; start_ = start; end_ = end; @@ -59,10 +60,10 @@ void LoopWorkerThread::Process(const std::function &work, int st } void LoopWorkerThread::WorkFunc() { - mutex.lock(); + std::unique_lock guard(mutex); started = true; while (active) { - signal.wait(mutex); + signal.wait(guard); if (active) { work_(start_, end_); doneMutex.lock(); @@ -98,7 +99,7 @@ void ThreadPool::StartWorkers() { void ThreadPool::ParallelLoop(const std::function &loop, int lower, int upper) { int range = upper - lower; if (range >= numThreads_ * 2) { // don't parallelize tiny loops (this could be better, maybe add optional parameter that estimates work per iteration) - lock_guard guard(mutex); + std::lock_guard guard(mutex); StartWorkers(); // could do slightly better load balancing for the generic case, diff --git a/ext/native/thread/threadpool.h b/ext/native/thread/threadpool.h index 1844f5e7c0..220d9aa82e 100644 --- a/ext/native/thread/threadpool.h +++ b/ext/native/thread/threadpool.h @@ -4,8 +4,8 @@ #include #include #include - -#include "base/mutex.h" +#include +#include // This is the simplest possible worker implementation I can think of // but entirely sufficient for the given purpose. @@ -25,9 +25,9 @@ protected: virtual void WorkFunc(); std::thread *thread; // the worker thread - ::condition_variable signal; // used to signal new work - ::condition_variable done; // used to signal work completion - ::recursive_mutex mutex, doneMutex; // associated with each respective condition variable + std::condition_variable signal; // used to signal new work + std::condition_variable done; // used to signal work completion + std::mutex mutex, doneMutex; // associated with each respective condition variable volatile bool active, started; private: @@ -65,7 +65,7 @@ public: private: int numThreads_; std::vector> workers; - ::recursive_mutex mutex; // used to sequentialize loop execution + std::mutex mutex; // used to sequentialize loop execution bool workersStarted; void StartWorkers(); diff --git a/ext/native/thread/threadutil.h b/ext/native/thread/threadutil.h index 2c80ef7736..512c15d0bb 100644 --- a/ext/native/thread/threadutil.h +++ b/ext/native/thread/threadutil.h @@ -1,6 +1,35 @@ #pragma once +#include +#include +#include + // Note that name must be a global string that lives until the end of the process, // for assertThreadName to work. void setCurrentThreadName(const char *threadName); void AssertCurrentThreadName(const char *threadName); + +class event { +public: + void notify_one() { + cond_.notify_one(); + } + + // notify_all is not really possible to implement with win32 events? + + void wait(std::mutex &mtx) { + // broken logic + std::unique_lock guard(mtx); + cond_.wait(guard); + } + + void wait_for(std::mutex &mtx, int milliseconds) { + std::unique_lock guard(mtx); + cond_.wait_for(guard, std::chrono::milliseconds(milliseconds)); + } + + void reset() { + } +private: + std::condition_variable cond_; +}; \ No newline at end of file diff --git a/ext/native/ui/screen.cpp b/ext/native/ui/screen.cpp index e745d8cff9..3dac293149 100644 --- a/ext/native/ui/screen.cpp +++ b/ext/native/ui/screen.cpp @@ -47,7 +47,7 @@ void ScreenManager::update(InputState &input) { } void ScreenManager::switchToNext() { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); if (!nextScreen_) { ELOG("switchToNext: No nextScreen_!"); } @@ -67,7 +67,7 @@ void ScreenManager::switchToNext() { } bool ScreenManager::touch(const TouchInput &touch) { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); if (!stack_.empty()) { return stack_.back().screen->touch(touch); } else { @@ -76,7 +76,7 @@ bool ScreenManager::touch(const TouchInput &touch) { } bool ScreenManager::key(const KeyInput &key) { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); if (!stack_.empty()) { return stack_.back().screen->key(key); } else { @@ -85,7 +85,7 @@ bool ScreenManager::key(const KeyInput &key) { } bool ScreenManager::axis(const AxisInput &axis) { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); if (!stack_.empty()) { return stack_.back().screen->axis(axis); } else { @@ -94,7 +94,7 @@ bool ScreenManager::axis(const AxisInput &axis) { } void ScreenManager::resized() { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); // Have to notify the whole stack, otherwise there will be problems when going back // to non-top screens. for (auto iter = stack_.begin(); iter != stack_.end(); ++iter) { @@ -168,7 +168,7 @@ Screen *ScreenManager::topScreen() const { } void ScreenManager::shutdown() { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); for (auto x = stack_.begin(); x != stack_.end(); x++) delete x->screen; stack_.clear(); @@ -177,7 +177,7 @@ void ScreenManager::shutdown() { } void ScreenManager::push(Screen *screen, int layerFlags) { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); if (nextScreen_ && stack_.empty()) { // we're during init, this is OK switchToNext(); @@ -192,7 +192,7 @@ void ScreenManager::push(Screen *screen, int layerFlags) { } void ScreenManager::pop() { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); if (stack_.size()) { delete stack_.back().screen; stack_.pop_back(); @@ -223,7 +223,7 @@ void ScreenManager::finishDialog(Screen *dialog, DialogResult result) { void ScreenManager::processFinishDialog() { if (dialogFinished_) { - lock_guard guard(inputLock_); + std::lock_guard guard(inputLock_); // Another dialog may have been pushed before the render, so search for it. Screen *caller = 0; for (size_t i = 0; i < stack_.size(); ++i) { diff --git a/ext/native/ui/screen.h b/ext/native/ui/screen.h index be844e2283..5f71662def 100644 --- a/ext/native/ui/screen.h +++ b/ext/native/ui/screen.h @@ -14,10 +14,10 @@ #pragma once #include +#include #include "base/basictypes.h" #include "base/logging.h" -#include "base/mutex.h" #include "base/NativeApp.h" namespace UI { @@ -130,7 +130,7 @@ public: Screen *topScreen() const; - recursive_mutex inputLock_; + std::mutex inputLock_; private: void pop(); diff --git a/ext/native/ui/ui_screen.cpp b/ext/native/ui/ui_screen.cpp index aaffa3a2ff..ee47c79b60 100644 --- a/ext/native/ui/ui_screen.cpp +++ b/ext/native/ui/ui_screen.cpp @@ -19,7 +19,7 @@ UIScreen::~UIScreen() { } void UIScreen::DoRecreateViews() { - lock_guard guard(screenManager()->inputLock_); + std::lock_guard guard(screenManager()->inputLock_); if (recreateViews_) { UI::PersistMap persisted; diff --git a/ext/native/ui/view.cpp b/ext/native/ui/view.cpp index ceff4b95d0..b91fef0d08 100644 --- a/ext/native/ui/view.cpp +++ b/ext/native/ui/view.cpp @@ -1,7 +1,7 @@ #include #include +#include -#include "base/mutex.h" #include "base/stringutil.h" #include "base/timeutil.h" #include "input/input_state.h" @@ -20,7 +20,7 @@ namespace UI { static View *focusedView; static bool focusMovementEnabled; bool focusForced; -static recursive_mutex mutex_; +static std::recursive_mutex eventMutex_; // needs recursivity! const float ITEM_HEIGHT = 64.f; const float MIN_TEXT_SCALE = 0.8f; @@ -33,9 +33,8 @@ struct DispatchQueueItem { std::deque g_dispatchQueue; - void EventTriggered(Event *e, EventParams params) { - lock_guard guard(mutex_); + std::unique_lock guard(eventMutex_); DispatchQueueItem item; item.e = e; @@ -44,7 +43,7 @@ void EventTriggered(Event *e, EventParams params) { } void DispatchEvents() { - lock_guard guard(mutex_); + std::unique_lock guard(eventMutex_); while (!g_dispatchQueue.empty()) { DispatchQueueItem item = g_dispatchQueue.back(); diff --git a/ext/native/ui/view.h b/ext/native/ui/view.h index 3d77689b52..10eaa9f3fd 100644 --- a/ext/native/ui/view.h +++ b/ext/native/ui/view.h @@ -16,7 +16,6 @@ #include #include "base/logging.h" -#include "base/mutex.h" #include "base/basictypes.h" #include "gfx/texture_atlas.h" #include "math/lin/matrix4x4.h" diff --git a/ext/native/ui/viewgroup.cpp b/ext/native/ui/viewgroup.cpp index 5cfb83f22a..e6da68390d 100644 --- a/ext/native/ui/viewgroup.cpp +++ b/ext/native/ui/viewgroup.cpp @@ -1,8 +1,8 @@ #include #include +#include #include "base/logging.h" -#include "base/mutex.h" #include "base/stringutil.h" #include "base/timeutil.h" #include "input/keycodes.h" @@ -17,7 +17,7 @@ namespace UI { const float ITEM_HEIGHT = 64.f; -static recursive_mutex focusLock; +static std::mutex focusLock; static std::vector focusMoves; extern bool focusForced; bool dragCaptured[MAX_POINTERS]; @@ -57,7 +57,7 @@ ViewGroup::~ViewGroup() { } void ViewGroup::RemoveSubview(View *view) { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); for (size_t i = 0; i < views_.size(); i++) { if (views_[i] == view) { views_.erase(views_.begin() + i); @@ -68,7 +68,7 @@ void ViewGroup::RemoveSubview(View *view) { } void ViewGroup::Clear() { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); for (size_t i = 0; i < views_.size(); i++) { delete views_[i]; views_[i] = nullptr; @@ -77,7 +77,7 @@ void ViewGroup::Clear() { } void ViewGroup::PersistData(PersistStatus status, std::string anonId, PersistMap &storage) { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); std::string tag = Tag(); if (tag.empty()) { @@ -91,7 +91,7 @@ void ViewGroup::PersistData(PersistStatus status, std::string anonId, PersistMap } void ViewGroup::Touch(const TouchInput &input) { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); for (auto iter = views_.begin(); iter != views_.end(); ++iter) { // TODO: If there is a transformation active, transform input coordinates accordingly. if ((*iter)->GetVisibility() == V_VISIBLE) @@ -109,7 +109,7 @@ void ViewGroup::Query(float x, float y, std::vector &list) { } bool ViewGroup::Key(const KeyInput &input) { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); bool ret = false; for (auto iter = views_.begin(); iter != views_.end(); ++iter) { // TODO: If there is a transformation active, transform input coordinates accordingly. @@ -120,7 +120,7 @@ bool ViewGroup::Key(const KeyInput &input) { } void ViewGroup::Axis(const AxisInput &input) { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); for (auto iter = views_.begin(); iter != views_.end(); ++iter) { // TODO: If there is a transformation active, transform input coordinates accordingly. if ((*iter)->GetVisibility() == V_VISIBLE) @@ -165,7 +165,7 @@ void ViewGroup::Update(const InputState &input_state) { } bool ViewGroup::SetFocus() { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); if (!CanBeFocused() && !views_.empty()) { for (size_t i = 0; i < views_.size(); i++) { if (views_[i]->SetFocus()) @@ -1394,7 +1394,7 @@ bool KeyEvent(const KeyInput &key, ViewGroup *root) { } heldKeys.insert(hk); - lock_guard lock(focusLock); + std::lock_guard lock(focusLock); focusMoves.push_back(key.keyCode); retval = true; } @@ -1440,7 +1440,7 @@ restart: key.flags = KEY_DOWN; KeyEvent(key, root); - lock_guard lock(focusLock); + std::lock_guard lock(focusLock); focusMoves.push_back(key.keyCode); // Cannot modify the current item when looping over a set, so let's do this instead. @@ -1477,7 +1477,7 @@ void UpdateViewHierarchy(const InputState &input_state, ViewGroup *root) { } if (focusMoves.size()) { - lock_guard lock(focusLock); + std::lock_guard lock(focusLock); EnableFocusMovement(true); if (!GetFocusedView()) { if (root->GetDefaultFocusView()) { diff --git a/ext/native/ui/viewgroup.h b/ext/native/ui/viewgroup.h index 98f7868730..62c7c6511b 100644 --- a/ext/native/ui/viewgroup.h +++ b/ext/native/ui/viewgroup.h @@ -2,9 +2,9 @@ #include #include +#include #include "base/logging.h" -#include "base/mutex.h" #include "math/geom2d.h" #include "input/gesture_detector.h" #include "ui/view.h" @@ -44,7 +44,7 @@ public: // Takes ownership! DO NOT add a view to multiple parents! template T *Add(T *view) { - lock_guard guard(modifyLock_); + std::lock_guard guard(modifyLock_); views_.push_back(view); return view; } @@ -77,7 +77,7 @@ public: std::string Describe() const override { return "ViewGroup: " + View::Describe(); } protected: - recursive_mutex modifyLock_; // Hold this when changing the subviews. + std::mutex modifyLock_; // Hold this when changing the subviews. std::vector views_; View *defaultFocusView_; Drawable bg_; diff --git a/ios/ViewController.mm b/ios/ViewController.mm index 573ff11628..769aa9d687 100644 --- a/ios/ViewController.mm +++ b/ios/ViewController.mm @@ -258,7 +258,7 @@ static GraphicsContext *graphicsContext; - (void)glkView:(GLKView *)view drawInRect:(CGRect)rect { { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); UpdateInputState(&input_state); NativeUpdate(input_state); EndInputState(&input_state); @@ -270,7 +270,7 @@ static GraphicsContext *graphicsContext; - (void)touchX:(float)x y:(float)y code:(int)code pointerId:(int)pointerId { - lock_guard guard(input_state.lock); + std::lock_guard guard(input_state.lock); float scale = [UIScreen mainScreen].scale;