diff options
Diffstat (limited to 'backends/platform/psp/powerman.cpp')
-rw-r--r-- | backends/platform/psp/powerman.cpp | 352 |
1 files changed, 123 insertions, 229 deletions
diff --git a/backends/platform/psp/powerman.cpp b/backends/platform/psp/powerman.cpp index df8da12f6d..eaadad16c5 100644 --- a/backends/platform/psp/powerman.cpp +++ b/backends/platform/psp/powerman.cpp @@ -23,16 +23,16 @@ * */ -//#define __PSP_DEBUG_FUNCS__ /* can put this locally too */ -//#define __PSP_DEBUG_PRINT__ -#include "backends/platform/psp/trace.h" - #include <psppower.h> #include <pspthreadman.h> #include "backends/platform/psp/powerman.h" #include "engine.h" +//#define __PSP_DEBUG_FUNCS__ /* can put this locally too */ +//#define __PSP_DEBUG_PRINT__ +#include "backends/platform/psp/trace.h" + DECLARE_SINGLETON(PowerManager) // Function to debug the Power Manager (we have no output to screen) @@ -47,68 +47,30 @@ inline void PowerManager::debugPM() { * Constructor * ********************************************/ -PowerManager::PowerManager() { - DEBUG_ENTER_FUNC(); - - _flagMutex = NULL; /* Init mutex handle */ - _listMutex = NULL; /* Init mutex handle */ - _condSuspendable = NULL; /* Init condition variable */ - _condPM = NULL; - - _condSuspendable = SDL_CreateCond(); - if (_condSuspendable <= 0) { - PSP_ERROR("Couldn't create Suspendable condition variable\n"); - } - - _condPM = SDL_CreateCond(); - if (_condPM <= 0) { - PSP_ERROR("Couldn't create PM condition variable\n"); - } - - _flagMutex = SDL_CreateMutex(); - if (_flagMutex <= 0) { - PSP_ERROR("Couldn't create flag Mutex\n"); - } - - _listMutex = SDL_CreateMutex(); - if (_listMutex <= 0) { - PSP_ERROR("Couldn't create list Mutex\n"); - } - - _suspendFlag = false; - _criticalCounter = 0; // How many are in the critical section - _pauseFlag = 0; - _pauseFlagOld = 0; - _pauseClientState = 0; - _listCounter = 0; - PMStatusSet(kInitDone); - _error = 0; -} +PowerManager::PowerManager() : _pauseFlag(false), _pauseFlagOld(false), _pauseClientState(UNPAUSED), + _suspendFlag(false), _flagMutex(true), _listMutex(true), + _criticalCounter(0), _listCounter(0), _error(0), _PMStatus(kInitDone) {} /******************************************* * * Function to register to be notified when suspend/resume time comes * ********************************************/ -int PowerManager::registerSuspend(Suspendable *item) { +bool PowerManager::registerForSuspend(Suspendable *item) { DEBUG_ENTER_FUNC(); // Register in list debugPM(); - if (SDL_mutexP(_listMutex) != 0) { - PSP_ERROR("Couldn't lock _listMutex[%p]\n", _listMutex); - } + _listMutex.lock(); _suspendList.push_front(item); _listCounter++; - if (SDL_mutexV(_listMutex) != 0) { - PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex); - } + _listMutex.unlock(); debugPM(); - return 0; + return true; } /******************************************* @@ -116,26 +78,20 @@ int PowerManager::registerSuspend(Suspendable *item) { * Function to unregister to be notified when suspend/resume time comes * ********************************************/ -int PowerManager::unregisterSuspend(Suspendable *item) { +bool PowerManager::unregisterForSuspend(Suspendable *item) { DEBUG_ENTER_FUNC(); debugPM(); // Unregister from stream list - if (SDL_mutexP(_listMutex) != 0) { - PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex); - } - + _listMutex.lock(); + _suspendList.remove(item); _listCounter--; - if (SDL_mutexV(_listMutex) != 0) { - PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex); - } + _listMutex.unlock(); - PSP_DEBUG_PRINT("Out of unregisterSuspend\n"); debugPM(); - - return 0; + return true; } /******************************************* @@ -144,21 +100,7 @@ int PowerManager::unregisterSuspend(Suspendable *item) { * ********************************************/ PowerManager::~PowerManager() { - DEBUG_ENTER_FUNC(); - - PMStatusSet(kDestroyPM); - - SDL_DestroyCond(_condSuspendable); - _condSuspendable = 0; - - SDL_DestroyCond(_condPM); - _condPM = 0; - - SDL_DestroyMutex(_flagMutex); - _flagMutex = 0; - - SDL_DestroyMutex(_listMutex); - _listMutex = 0; + _PMStatus = kDestroyPM; } /******************************************* @@ -171,114 +113,92 @@ PowerManager::~PowerManager() { * ********************************************/ void PowerManager::pollPauseEngine() { - + DEBUG_ENTER_FUNC(); + + bool pause = _pauseFlag; // We copy so as not to have multiple values - if ((pause != _pauseFlagOld) && g_engine) { // Check to see if we have an engine - if (pause && _pauseClientState == PowerManager::Unpaused) { - _pauseClientState = PowerManager::Pausing; // Tell PM we're in the middle of pausing - g_engine->pauseEngine(true); - PSP_DEBUG_PRINT_FUNC("Pausing engine\n"); - _pauseClientState = PowerManager::Paused; // Tell PM we're done pausing - } else if (!pause && _pauseClientState == PowerManager::Paused) { - g_engine->pauseEngine(false); - PSP_DEBUG_PRINT_FUNC("Unpausing for resume\n"); - _pauseClientState = PowerManager::Unpaused; // Tell PM we're in the middle of pausing + if (pause != _pauseFlagOld) { + if (g_engine) { // Check to see if we have an engine + if (pause && _pauseClientState == UNPAUSED) { + _pauseClientState = PAUSING; // Tell PM we're in the middle of pausing + g_engine->pauseEngine(true); + PSP_DEBUG_PRINT_FUNC("Pausing engine\n"); + _pauseClientState = PAUSED; // Tell PM we're done pausing + } else if (!pause && _pauseClientState == PAUSED) { + g_engine->pauseEngine(false); + PSP_DEBUG_PRINT_FUNC("Unpausing for resume\n"); + _pauseClientState = UNPAUSED; // Tell PM we're unpaused + } } - _pauseFlagOld = pause; } } /******************************************* * -* Function to be called by threads wanting to block on the PSP entering suspend -* Use this for small critical sections where you can easily restore the previous state. -* -********************************************/ -int PowerManager::blockOnSuspend() { - return beginCriticalSection(true); -} - -/******************************************* -* * Function to block on a suspend, then start a non-suspendable critical section * Use this for large or REALLY critical critical-sections. * Make sure to call endCriticalSection or the PSP won't suspend. +* returns true if blocked, false if not blocked ********************************************/ -int PowerManager::beginCriticalSection(bool justBlock) { +bool PowerManager::beginCriticalSection() { DEBUG_ENTER_FUNC(); - int ret = NotBlocked; - - if (SDL_mutexP(_flagMutex) != 0) { - PSP_ERROR("PowerManager::blockOnSuspend(): Couldn't lock flagMutex[%p]\n", _flagMutex); - ret = Error; - } + bool ret = false; + + _flagMutex.lock(); // Check the access flag - if (_suspendFlag == true) { - PSP_DEBUG_PRINT("We're being blocked!\n"); - debugPM(); - ret = Blocked; + if (_suspendFlag) { + ret = true; - // If it's true, we wait for a signal to continue - if (SDL_CondWait(_condSuspendable, _flagMutex) != 0) { - PSP_DEBUG_PRINT("PowerManager::blockOnSuspend(): Couldn't wait on cond[%p]\n", _condSuspendable); - } + PSP_DEBUG_PRINT("I got blocked. ThreadId[%x]\n", sceKernelGetThreadId()); + debugPM(); + + _threadSleep.wait(_flagMutex); - PSP_DEBUG_PRINT("We got blocked!!\n"); + PSP_DEBUG_PRINT_FUNC("I got released. ThreadId[%x]\n", sceKernelGetThreadId()); debugPM(); } // Now prevent the PM from suspending until we're done - if (justBlock == false) - _criticalCounter++; + _criticalCounter++; - if (SDL_mutexV(_flagMutex) != 0) { - PSP_ERROR("PowerManager::blockOnSuspend(): Couldn't unlock flagMutex[%p]\n", _flagMutex); - ret = Error; - } + _flagMutex.unlock(); return ret; } -int PowerManager::endCriticalSection() { +// returns success = true +void PowerManager::endCriticalSection() { DEBUG_ENTER_FUNC(); - int ret = 0; - if (SDL_mutexP(_flagMutex) != 0) { - PSP_ERROR("PowerManager::endCriticalSection(): Couldn't lock flagMutex[%p]\n", _flagMutex); - ret = Error; - } + _flagMutex.lock(); // We're done with our critical section _criticalCounter--; if (_criticalCounter <= 0) { - if (_suspendFlag == true) { // If the PM is sleeping, this flag must be set - PSP_DEBUG_PRINT("Unblocked thread waking up the PM.\n"); - debugPM(); - - SDL_CondBroadcast(_condPM); - - PSP_DEBUG_PRINT("Woke up the PM\n"); - debugPM(); + if (_suspendFlag) { // If the PM is sleeping, this flag must be set + PSP_DEBUG_PRINT_FUNC("PM is asleep. Waking it up.\n"); + debugPM(); + + _pmSleep.releaseAll(); + + PSP_DEBUG_PRINT_FUNC("Woke up the PM\n"); + + debugPM(); } if (_criticalCounter < 0) { // Check for bad usage of critical sections - PSP_ERROR("Critical counter[%d]\n", _criticalCounter); + PSP_ERROR("Critical counter[%d]!!!\n", _criticalCounter); debugPM(); } } - if (SDL_mutexV(_flagMutex) != 0) { - PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex); - ret = Error; - } - - return ret; + _flagMutex.unlock(); } /******************************************* @@ -286,90 +206,77 @@ int PowerManager::endCriticalSection() { * Callback function to be called to put every Suspendable to suspend * ********************************************/ -int PowerManager::suspend() { +void PowerManager::suspend() { DEBUG_ENTER_FUNC(); - int ret = 0; - if (_pauseFlag) return ret; // Very important - make sure we only suspend once + if (_pauseFlag) + return; // Very important - make sure we only suspend once - scePowerLock(0); // Critical to make sure PSP doesn't suspend before we're done + scePowerLock(0); // Also critical to make sure PSP doesn't suspend before we're done // The first stage of suspend is pausing the engine if possible. We don't want to cause files // to block, or we might not get the engine to pause. On the other hand, we might wait for polling // and it'll never happen. We also want to do this w/o mutexes (for speed) which is ok in this case. _pauseFlag = true; - PMStatusSet(kWaitForClientPause); + _PMStatus = kWaitForClientPause; // Now we wait, giving the engine thread some time to find our flag. - for (int i = 0; i < 10 && _pauseClientState == Unpaused; i++) - sceKernelDelayThread(50000); // We wait 50 msec x 10 times = 0.5 seconds + for (int i = 0; i < 10 && _pauseClientState == UNPAUSED; i++) + PspThread::delayMicros(50000); // We wait 50 msec x 10 times = 0.5 seconds - if (_pauseClientState == Pausing) { // Our event has been acknowledged. Let's wait until the client is done. - PMStatusSet(kWaitForClientToFinishPausing); + if (_pauseClientState == PAUSING) { // Our event has been acknowledged. Let's wait until the client is done. + _PMStatus = kWaitForClientToFinishPausing; - while (_pauseClientState != Paused) - sceKernelDelayThread(50000); // We wait 50 msec at a time + while (_pauseClientState != PAUSED) + PspThread::delayMicros(50000); // We wait 50 msec at a time } - // It's possible that the polling thread missed our pause event, but there's nothing we can do about that. - // We can't know if there's polling going on or not. It's usually not a critical thing anyway. + // It's possible that the polling thread missed our pause event, but there's + // nothing we can do about that. + // We can't know if there's polling going on or not. + // It's usually not a critical thing anyway. - PMStatusSet(kGettingFlagMutexSuspend); + _PMStatus = kGettingFlagMutexSuspend; // Now we set the suspend flag to true to cause reading threads to block + _flagMutex.lock(); - if (SDL_mutexP(_flagMutex) != 0) { - PSP_ERROR("Couldn't lock flagMutex[%p]\n", _flagMutex); - _error = Error; - ret = Error; - } - - PMStatusSet(kGotFlagMutexSuspend); + _PMStatus = kGotFlagMutexSuspend; _suspendFlag = true; // Check if anyone is in a critical section. If so, we'll wait for them if (_criticalCounter > 0) { - PMStatusSet(kWaitCritSectionSuspend); - SDL_CondWait(_condPM, _flagMutex); - PMStatusSet(kDoneWaitingCritSectionSuspend); - } + _PMStatus = kWaitCritSectionSuspend; + + _pmSleep.wait(_flagMutex); + + _PMStatus = kDoneWaitingCritSectionSuspend; + } + + _flagMutex.unlock(); - if (SDL_mutexV(_flagMutex) != 0) { - PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex); - _error = Error; - ret = Error; - } - - PMStatusSet(kGettingListMutexSuspend); + _PMStatus = kGettingListMutexSuspend; // Loop over list, calling suspend() - if (SDL_mutexP(_listMutex) != 0) { - PSP_ERROR("Couldn't lock listMutex[%p]\n", _listMutex); - _error = Error; - ret = Error; - } - PMStatusSet(kIteratingListSuspend); + _listMutex.lock(); + + _PMStatus = kIteratingListSuspend; // Iterate Common::List<Suspendable *>::iterator i; for (i = _suspendList.begin(); i != _suspendList.end(); ++i) { (*i)->suspend(); } + _PMStatus = kDoneIteratingListSuspend; - PMStatusSet(kDoneIteratingListSuspend); - - if (SDL_mutexV(_listMutex) != 0) { - PSP_ERROR("Couldn't unlock listMutex[%p]\n", _listMutex); - _error = Error; - ret = Error; - } - PMStatusSet(kDoneSuspend); + _listMutex.unlock(); + _PMStatus = kDoneSuspend; scePowerUnlock(0); // Allow the PSP to go to sleep now - - return ret; + + _PMStatus = kDonePowerUnlock; } /******************************************* @@ -377,24 +284,26 @@ int PowerManager::suspend() { * Callback function to resume every Suspendable * ********************************************/ -int PowerManager::resume() { +void PowerManager::resume() { DEBUG_ENTER_FUNC(); - int ret = 0; + + _PMStatus = kBeginResume; // Make sure we can't get another suspend scePowerLock(0); - if (!_pauseFlag) return ret; // Make sure we can only resume once + _PMStatus = kCheckingPauseFlag; + + if (!_pauseFlag) + return; // Make sure we can only resume once - PMStatusSet(kGettingListMutexResume); + _PMStatus = kGettingListMutexResume; // First we notify our Suspendables. Loop over list, calling resume() - if (SDL_mutexP(_listMutex) != 0) { - PSP_ERROR("Couldn't lock listMutex[%p]\n", _listMutex); - _error = Error; - ret = Error; - } - PMStatusSet(kIteratingListResume); + _listMutex.lock(); + + _PMStatus = kIteratingListResume; + // Iterate Common::List<Suspendable *>::iterator i = _suspendList.begin(); @@ -402,46 +311,31 @@ int PowerManager::resume() { (*i)->resume(); } - PMStatusSet(kDoneIteratingListResume); + _PMStatus = kDoneIteratingListResume; - if (SDL_mutexV(_listMutex) != 0) { - PSP_ERROR("Couldn't unlock listMutex[%p]\n", _listMutex); - _error = Error; - ret = Error; - } - - PMStatusSet(kGettingFlagMutexResume); + _listMutex.unlock(); + + _PMStatus = kGettingFlagMutexResume; // Now we set the suspend flag to false - if (SDL_mutexP(_flagMutex) != 0) { - PSP_ERROR("Couldn't lock flagMutex %p\n", _flagMutex); - _error = Error; - ret = Error; - } - PMStatusSet(kGotFlagMutexResume); + _flagMutex.lock(); + + _PMStatus = kGotFlagMutexResume; _suspendFlag = false; - PMStatusSet(kSignalSuspendedThreadsResume); + _PMStatus = kSignalSuspendedThreadsResume; - // Signal the other threads to wake up - if (SDL_CondBroadcast(_condSuspendable) != 0) { - PSP_ERROR("Couldn't broadcast condition[%p]\n", _condSuspendable); - _error = Error; - ret = Error; - } - PMStatusSet(kDoneSignallingSuspendedThreadsResume); + // Signal the threads to wake up + _threadSleep.releaseAll(); + + _PMStatus = kDoneSignallingSuspendedThreadsResume; - if (SDL_mutexV(_flagMutex) != 0) { - PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex); - _error = Error; - ret = Error; - } - PMStatusSet(kDoneResume); + _flagMutex.unlock(); + + _PMStatus = kDoneResume; - _pauseFlag = false; // Signal engine to unpause + _pauseFlag = false; // Signal engine to unpause -- no mutex needed scePowerUnlock(0); // Allow new suspends - - return ret; } |