From 6a5bd81599fbafe8edc92add8316eba74504e49d Mon Sep 17 00:00:00 2001 From: Joost Peters Date: Wed, 23 Sep 2009 16:11:23 +0000 Subject: PSP: improved suspend/resume support [patch from bluddy] svn-id: r44276 --- backends/fs/psp/psp-fs.cpp | 22 ++-- backends/fs/psp/psp-stream.cpp | 221 +++++++++++++++++++++------------ backends/fs/psp/psp-stream.h | 18 ++- backends/fs/stdiostream.h | 10 +- backends/platform/psp/osys_psp.cpp | 8 ++ backends/platform/psp/powerman.cpp | 242 ++++++++++++++++++++++++++++++------- backends/platform/psp/powerman.h | 82 ++++++++++--- backends/platform/psp/trace.cpp | 10 +- backends/platform/psp/trace.h | 13 ++ backends/saves/psp/psp-saves.cpp | 5 + 10 files changed, 478 insertions(+), 153 deletions(-) (limited to 'backends') diff --git a/backends/fs/psp/psp-fs.cpp b/backends/fs/psp/psp-fs.cpp index 03247e86ad..0c53020d94 100644 --- a/backends/fs/psp/psp-fs.cpp +++ b/backends/fs/psp/psp-fs.cpp @@ -27,7 +27,6 @@ #include "engines/engine.h" #include "backends/fs/abstract-fs.h" #include "backends/fs/psp/psp-stream.h" -#include "backends/platform/psp/powerman.h" #include #include @@ -38,7 +37,6 @@ #include "backends/platform/psp/trace.h" - /** * Implementation of the ScummVM file system API based on PSPSDK API. * @@ -98,7 +96,8 @@ PSPFilesystemNode::PSPFilesystemNode(const Common::String &p, bool verify) { if (verify) { struct stat st; - PowerMan.beginCriticalSection(); + if(PowerMan.beginCriticalSection()==PowerManager::Blocked) + PSPDebugSuspend("Suspended in PSPFilesystemNode::PSPFilesystemNode\n"); _isValid = (0 == stat(_path.c_str(), &st)); PowerMan.endCriticalSection(); _isDirectory = S_ISDIR(st.st_mode); @@ -108,7 +107,9 @@ PSPFilesystemNode::PSPFilesystemNode(const Common::String &p, bool verify) { bool PSPFilesystemNode::exists() const { int ret = 0; - PowerMan.beginCriticalSection(); // Make sure to block in case of suspend + if (PowerMan.beginCriticalSection() == PowerManager::Blocked) + PSPDebugSuspend("Suspended in PSPFilesystemNode::exists()\n"); // Make sure to block in case of suspend + ret = access(_path.c_str(), F_OK); PowerMan.endCriticalSection(); @@ -118,7 +119,9 @@ bool PSPFilesystemNode::exists() const { bool PSPFilesystemNode::isReadable() const { int ret = 0; - PowerMan.beginCriticalSection(); // Make sure to block in case of suspend + if (PowerMan.beginCriticalSection() == PowerManager::Blocked) + PSPDebugSuspend("Suspended in PSPFilesystemNode::isReadable()\n"); // Make sure to block in case of suspend + ret = access(_path.c_str(), R_OK); PowerMan.endCriticalSection(); @@ -128,7 +131,9 @@ bool PSPFilesystemNode::isReadable() const { bool PSPFilesystemNode::isWritable() const { int ret = 0; - PowerMan.beginCriticalSection(); // Make sure to block in case of suspend + if (PowerMan.beginCriticalSection() == PowerManager::Blocked) + PSPDebugSuspend("Suspended in PSPFilesystemNode::isWritable()\n"); // Make sure to block in case of suspend + ret = access(_path.c_str(), W_OK); PowerMan.endCriticalSection(); @@ -156,8 +161,9 @@ bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool bool ret = true; - PowerMan.beginCriticalSection(); // Make sure to block in case of suspend - + if (PowerMan.beginCriticalSection() == PowerManager::Blocked) + PSPDebugSuspend("Suspended in PSPFilesystemNode::getChildren\n"); // Make sure to block in case of suspend + int dfd = sceIoDopen(_path.c_str()); if (dfd > 0) { SceIoDirent dir; diff --git a/backends/fs/psp/psp-stream.cpp b/backends/fs/psp/psp-stream.cpp index c88e711cd0..d72bafd0ad 100644 --- a/backends/fs/psp/psp-stream.cpp +++ b/backends/fs/psp/psp-stream.cpp @@ -24,8 +24,13 @@ */ #ifdef __PSP__ -#include "backends/fs/psp/psp-stream.h" +#include +#include + #include "backends/platform/psp/trace.h" +#include "backends/platform/psp/powerman.h" +#include "backends/fs/psp/psp-stream.h" + #include PSPIoStream::PSPIoStream(const Common::String &path, bool writeMode) @@ -34,91 +39,89 @@ PSPIoStream::PSPIoStream(const Common::String &path, bool writeMode) assert(!path.empty()); _handle = (void *)0; // Need to do this since base class asserts not 0. - - PowerMan.registerSuspend(this); // Register with the powermanager to be suspended - + _ferror = false; + _feof = false; + _pos = 0; + +#ifdef __PSP_DEBUG_SUSPEND__ + _errorSuspend = 0; + _errorSource = 0; + _errorPos = 0; + _errorHandle = 0; + _suspendCount = 0; +#endif } PSPIoStream::~PSPIoStream() { + if (PowerMan.beginCriticalSection() == PowerManager::Blocked) + PSPDebugSuspend("Suspended in PSPIoStream::~PSPIoStream()\n"); + PowerMan.unregisterSuspend(this); // Unregister with powermanager to be suspended // Must do this before fclose() or resume() will reopen. - fclose((FILE *)_handle); + fclose((FILE *)_handle); // We don't need a critical section(?). Worst case, the handle gets closed on its own + + PowerMan.endCriticalSection(); } // Function to open the file pointed to by the path. // // -void * PSPIoStream::open() { - if (PowerMan.beginCriticalSection()==PowerManager::Blocked) { +void *PSPIoStream::open() { + if (PowerMan.beginCriticalSection() == PowerManager::Blocked) { // No need to open. Just return the _handle resume() already opened. - PSPDebugTrace("Suspended in PSPIoStream::open\n"); - } else { - _handle = fopen(_path.c_str(), _writeMode ? "wb" : "rb"); // open - } - + PSPDebugSuspend("Suspended in PSPIoStream::open\n"); + } + + _handle = fopen(_path.c_str(), _writeMode ? "wb" : "rb"); // open + + PowerMan.registerSuspend(this); // Register with the powermanager to be suspended + PowerMan.endCriticalSection(); return _handle; } bool PSPIoStream::err() const { - bool ret; - - if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::err()\n"); - - ret = ferror((FILE *)_handle) != 0; - - PowerMan.endCriticalSection(); - - return ret; + if (_ferror) + PSPDebugSuspend("In PSPIoStream::err - mem_ferror=%d, source=%d, suspend error=%d, pos=%d, _errorPos=%d, _errorHandle=%p, suspendCount=%d _handle\n", + _ferror, _errorSource, _errorSuspend, _pos, _errorPos, _errorHandle, _suspendCount); + + return _ferror; } void PSPIoStream::clearErr() { - if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::clearErr()\n"); - - clearerr((FILE *)_handle); - - PowerMan.endCriticalSection(); + _ferror = false; // Remove regular error bit + } bool PSPIoStream::eos() const { - bool ret; - - if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::eos()\n"); - - ret = feof((FILE *)_handle) != 0; - - PowerMan.endCriticalSection(); - - return ret; + return _feof; } int32 PSPIoStream::pos() const { - int32 ret; - - if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::pos()\n"); - - ret = ftell((FILE *)_handle); - - PowerMan.endCriticalSection(); - - return ret; + return _pos; } int32 PSPIoStream::size() const { if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::size()\n"); + PSPDebugSuspend("Suspended in PSPIoStream::size()\n"); - int32 oldPos = ftell((FILE *)_handle); fseek((FILE *)_handle, 0, SEEK_END); int32 length = ftell((FILE *)_handle); - fseek((FILE *)_handle, oldPos, SEEK_SET); + fseek((FILE *)_handle, _pos, SEEK_SET); + + if (_pos < 0 || length < 0) { // Check for errors + PSPDebugSuspend("In PSPIoStream::size(). encountered an error!\n"); + _ferror = true; + length = -1; // If our oldPos is bad, we want length to be bad too to signal + clearerr((FILE *)_handle); + +#ifdef __PSP_DEBUG_SUSPEND__ + _errorSource = 2; +#endif + } PowerMan.endCriticalSection(); @@ -126,13 +129,27 @@ int32 PSPIoStream::size() const { } bool PSPIoStream::seek(int32 offs, int whence) { - int ret = 0; - // Check if we can access the file if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::seek()\n"); + PSPDebugSuspend("Suspended in PSPIoStream::seek()\n"); - ret = fseek((FILE *)_handle, offs, whence); + int ret = fseek((FILE *)_handle, offs, whence); + + if (ret != 0) { + _ferror = true; + PSPDebugSuspend("In PSPIoStream::seek(). encountered an error!\n"); + clearerr((FILE *)_handle); + _feof = feof((FILE *)_handle); + +#ifdef __PSP_DEBUG_SUSPEND__ + _errorSource = 3; +#endif + } + else { // everything ok + _feof = false; // Reset eof flag since we know it was ok + } + + _pos = ftell((FILE *)_handle); // update pos PowerMan.endCriticalSection(); @@ -140,13 +157,27 @@ bool PSPIoStream::seek(int32 offs, int whence) { } uint32 PSPIoStream::read(void *ptr, uint32 len) { - int ret = 0; - // Check if we can access the file if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::read()\n"); + PSPDebugSuspend("Suspended in PSPIoStream::read()\n"); - ret = fread((byte *)ptr, 1, len, (FILE *)_handle); + size_t ret = fread((byte *)ptr, 1, len, (FILE *)_handle); + + _pos += ret; // Update pos + + if (ret != len) { // Check for eof + _feof = feof((FILE *)_handle); + if (!_feof) { // It wasn't an eof. Must be an error + _ferror = true; + clearerr((FILE *)_handle); + _pos = ftell((FILE *)_handle); // Update our position + PSPDebugSuspend("In PSPIoStream::read(). encountered an error!\n"); + +#ifdef __PSP_DEBUG_SUSPEND__ + _errorSource = 4; +#endif + } + } PowerMan.endCriticalSection(); @@ -154,13 +185,24 @@ uint32 PSPIoStream::read(void *ptr, uint32 len) { } uint32 PSPIoStream::write(const void *ptr, uint32 len) { - int ret = 0; - // Check if we can access the file if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::read()\n"); + PSPDebugSuspend("Suspended in PSPIoStream::read()\n"); + + size_t ret = fwrite(ptr, 1, len, (FILE *)_handle); + + _pos += ret; - ret = fwrite(ptr, 1, len, (FILE *)_handle); + if (ret != len) { // Set error + _ferror = true; + clearerr((FILE *)_handle); + _pos = ftell((FILE *)_handle); // Update pos + PSPDebugTrace("In PSPIoStream::write(). encountered an error!\n"); + +#ifdef __PSP_DEBUG_SUSPEND__ + _errorSource = 5; +#endif + } PowerMan.endCriticalSection(); @@ -168,13 +210,21 @@ uint32 PSPIoStream::write(const void *ptr, uint32 len) { } bool PSPIoStream::flush() { - int ret = 0; - - // Check if we can access the file + // Enter critical section if (PowerMan.beginCriticalSection() == PowerManager::Blocked) - PSPDebugTrace("Suspended in PSPIoStream::read()\n"); + PSPDebugSuspend("Suspended in PSPIoStream::read()\n"); - ret = fflush((FILE *)_handle); + int ret = fflush((FILE *)_handle); + + if (ret != 0) { + _ferror = true; + clearerr((FILE *)_handle); + PSPDebugSuspend("In PSPIoStream::flush(). encountered an error!\n"); + +#ifdef __PSP_DEBUG_SUSPEND__ + _errorSource = 6; +#endif + } PowerMan.endCriticalSection(); @@ -199,10 +249,19 @@ PSPIoStream *PSPIoStream::makeFromPath(const Common::String &path, bool writeMod * Function to suspend the IO stream (called by PowerManager) */ int PSPIoStream::suspend() { +#ifdef __PSP_DEBUG_SUSPEND__ + _suspendCount++; + + if (_handle > 0 && _pos < 0) { + _errorSuspend = SuspendError; + _errorPos = _pos; + _errorHandle = _handle; + } +#endif /* __PSP_DEBUG_SUSPEND__ */ + if (_handle > 0) { - _pos = ftell((FILE *)_handle); // Save our position fclose((FILE *)_handle); // close our file descriptor - _handle = 0; // Set handle to null + _handle = (void *)0xFFFFFFFF; // Set handle to non-null invalid value so makeFromPath doesn't return error } return 0; @@ -213,18 +272,32 @@ int PSPIoStream::suspend() { */ int PSPIoStream::resume() { int ret = 0; - +#ifdef __PSP_DEBUG_SUSPEND__ + _suspendCount--; +#endif + // We reopen our file descriptor _handle = fopen(_path.c_str(), _writeMode ? "wb" : "rb"); if (_handle <= 0) { - PSPDebugTrace("PSPIoStream::resume(): Couldn't reopen file %s\n", _path.c_str()); - ret = -1; + PSPDebugSuspend("PSPIoStream::resume(): Couldn't reopen file %s\n", _path.c_str()); } // Resume our previous position - if(_handle > 0) fseek((FILE *)_handle, _pos, SEEK_SET); + if (_handle > 0 && _pos > 0) { + ret = fseek((FILE *)_handle, _pos, SEEK_SET); + +#ifdef __PSP_DEBUG_SUSPEND__ + if (ret != 0) { // Check for problem + _errorSuspend = ResumeError; + _errorPos = _pos; + _errorHandle = _handle; + } +#endif + + } return ret; } + #endif /* __PSP__ */ diff --git a/backends/fs/psp/psp-stream.h b/backends/fs/psp/psp-stream.h index 0363c92416..112d36ccdb 100644 --- a/backends/fs/psp/psp-stream.h +++ b/backends/fs/psp/psp-stream.h @@ -37,7 +37,23 @@ class PSPIoStream : public StdioStream, public Suspendable { protected: Common::String _path; /* Need to maintain for reopening after suspend */ bool _writeMode; /* "" */ - unsigned int _pos; /* "" */ + int _pos; /* "" */ + mutable int _ferror; /* Save file ferror */ + mutable bool _feof; /* and eof */ + + enum { + SuspendError = 2, + ResumeError = 3 + }; + + int _errorSuspend; + mutable int _errorSource; + +#ifdef __PSP_DEBUG_SUSPEND__ + int _errorPos; + void * _errorHandle; + int _suspendCount; +#endif /* __PSP_DEBUG_SUSPEND__ */ public: /** diff --git a/backends/fs/stdiostream.h b/backends/fs/stdiostream.h index 3d44062d7f..25800f210a 100644 --- a/backends/fs/stdiostream.h +++ b/backends/fs/stdiostream.h @@ -46,17 +46,17 @@ public: StdioStream(void *handle); virtual ~StdioStream(); - bool err() const; - void clearErr(); - bool eos() const; + virtual bool err() const; + virtual void clearErr(); + virtual bool eos() const; virtual uint32 write(const void *dataPtr, uint32 dataSize); virtual bool flush(); virtual int32 pos() const; virtual int32 size() const; - bool seek(int32 offs, int whence = SEEK_SET); - uint32 read(void *dataPtr, uint32 dataSize); + virtual bool seek(int32 offs, int whence = SEEK_SET); + virtual uint32 read(void *dataPtr, uint32 dataSize); }; #endif diff --git a/backends/platform/psp/osys_psp.cpp b/backends/platform/psp/osys_psp.cpp index 78081db384..79804b3e18 100644 --- a/backends/platform/psp/osys_psp.cpp +++ b/backends/platform/psp/osys_psp.cpp @@ -35,6 +35,7 @@ #include "osys_psp.h" #include "trace.h" +#include "powerman.h" #include "backends/saves/psp/psp-saves.h" #include "backends/timer/default/default-timer.h" @@ -927,6 +928,13 @@ bool OSystem_PSP::processInput(Common::Event &event) { bool OSystem_PSP::pollEvent(Common::Event &event) { float nub_angle = -1; int x, y; + + // If we're polling for events, we should check for pausing the engine + // Pausing the engine is a necessary fix for games that use the timer for music synchronization + // recovering many hours later causes the game to crash. We're polling without mutexes since it's not critical to + // get it right now. + + PowerMan.pollPauseEngine(); sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(1); diff --git a/backends/platform/psp/powerman.cpp b/backends/platform/psp/powerman.cpp index c553669fc3..678f3697fb 100644 --- a/backends/platform/psp/powerman.cpp +++ b/backends/platform/psp/powerman.cpp @@ -23,17 +23,33 @@ * */ +#include +#include + #include "./powerman.h" #include "./trace.h" +#include "engine.h" DECLARE_SINGLETON(PowerManager); +#ifdef __PSP_DEBUG_SUSPEND__ +void PowerManager::debugPM() { + PSPDebugTrace("PM status is %d. Listcount is %d. CriticalCount is %d. ThreadId is %x. Error = %d\n", _PMStatus, _listCounter, + _criticalCounter, sceKernelGetThreadId(), _error); +} +#else + #define debugPM() + #define PMStatusSet(x) +#endif /* __PSP_DEBUG_SUSPEND__ */ + + /******************************************* * * Constructor * ********************************************/ PowerManager::PowerManager() { + _flagMutex = NULL; /* Init mutex handle */ _listMutex = NULL; /* Init mutex handle */ _condSuspendable = NULL; /* Init condition variable */ @@ -41,26 +57,33 @@ PowerManager::PowerManager() { _condSuspendable = SDL_CreateCond(); if (_condSuspendable <= 0) { - PSPDebugTrace("PowerManager::PowerManager(): Couldn't create condSuspendable\n"); + PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condSuspendable\n"); } _condPM = SDL_CreateCond(); if (_condPM <= 0) { - PSPDebugTrace("PowerManager::PowerManager(): Couldn't create condPM\n"); + PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condPM\n"); } _flagMutex = SDL_CreateMutex(); if (_flagMutex <= 0) { - PSPDebugTrace("PowerManager::PowerManager(): Couldn't create flagMutex\n"); + PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create flagMutex\n"); } _listMutex = SDL_CreateMutex(); if (_listMutex <= 0) { - PSPDebugTrace("PowerManager::PowerManager(): Couldn't create listMutex\n"); + PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create listMutex\n"); } _suspendFlag = false; _criticalCounter = 0; + _pauseFlag = 0; _pauseFlagOld = 0; _pauseClientState = 0; + +#ifdef __PSP_DEBUG_SUSPEND__ + _listCounter = 0; + PMStatusSet(kInitDone); + _error = 0; +#endif } /******************************************* @@ -70,20 +93,25 @@ PowerManager::PowerManager() { ********************************************/ int PowerManager::registerSuspend(Suspendable *item) { // Register in list - PSPDebugTrace("In registerSuspend\n"); + PSPDebugSuspend("In registerSuspend\n"); + debugPM(); if (SDL_mutexP(_listMutex) != 0) { PSPDebugTrace("PowerManager::registerSuspend(): Couldn't lock _listMutex %d\n", _listMutex); } _suspendList.push_front(item); +#ifdef __PSP_DEBUG_SUSPEND__ + _listCounter++; +#endif if (SDL_mutexV(_listMutex) != 0) { PSPDebugTrace("PowerManager::registerSuspend(): Couldn't unlock _listMutex %d\n", _listMutex); } - PSPDebugTrace("Out of registerSuspend\n"); - + PSPDebugSuspend("Out of registerSuspend\n"); + debugPM(); + return 0; } @@ -94,7 +122,8 @@ int PowerManager::registerSuspend(Suspendable *item) { ********************************************/ int PowerManager::unregisterSuspend(Suspendable *item) { - PSPDebugTrace("In unregisterSuspend\n"); + PSPDebugSuspend("In unregisterSuspend\n"); + debugPM(); // Unregister from stream list if (SDL_mutexP(_listMutex) != 0) { @@ -102,13 +131,17 @@ int PowerManager::unregisterSuspend(Suspendable *item) { } _suspendList.remove(item); - +#ifdef __PSP_DEBUG_SUSPEND__ + _listCounter--; +#endif + if (SDL_mutexV(_listMutex) != 0) { PSPDebugTrace("PowerManager::unregisterSuspend(): Couldn't unlock _listMutex %d\n", _listMutex); } - PSPDebugTrace("Out of unregisterSuspend\n"); - + PSPDebugSuspend("Out of unregisterSuspend\n"); + debugPM(); + return 0; } @@ -118,6 +151,11 @@ int PowerManager::unregisterSuspend(Suspendable *item) { * ********************************************/ PowerManager::~PowerManager() { + +#ifdef __PSP_DEBUG_SUSPEND__ + PMStatusSet(kDestroyPM); +#endif + SDL_DestroyCond(_condSuspendable); _condSuspendable = 0; @@ -130,48 +168,84 @@ int PowerManager::unregisterSuspend(Suspendable *item) { SDL_DestroyMutex(_listMutex); _listMutex = 0; } + +/******************************************* +* +* Unsafe function to poll for a pause event (first stage of suspending) +* Only for pausing the engine, which doesn't need high synchronization ie. we don't care if it misreads +* the flag a couple of times since there is NO mutex protection (for performance reasons). +* Polling the engine happens regularly. +* On the other hand, we don't know if there will be ANY polling which prevents us from using proper events. +* +********************************************/ +void PowerManager::pollPauseEngine() { + + 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); + PSPDebugSuspend("Pausing engine in PowerManager::pollPauseEngine()\n"); + _pauseClientState = PowerManager::Paused; // Tell PM we're done pausing + } + else if (!pause && _pauseClientState == PowerManager::Paused) { + g_engine->pauseEngine(false); + PSPDebugSuspend("Unpausing for resume in PowerManager::pollPauseEngine()\n"); + _pauseClientState = PowerManager::Unpaused; // Tell PM we're in the middle of pausing + } + + _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 - */ -int PowerManager::beginCriticalSection(bool justBlock) { - int ret = PowerManager::NotBlocked; +/******************************************* +* +* 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. +********************************************/ + + int PowerManager::beginCriticalSection(bool justBlock) { + int ret = NotBlocked; if (SDL_mutexP(_flagMutex) != 0) { PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't lock flagMutex %d\n", _flagMutex); - ret = PowerManager::Error; + ret = Error; } // Check the access flag if (_suspendFlag == true) { - PSPDebugTrace("Blocking!!\n"); - ret = PowerManager::Blocked; + PSPDebugSuspend("We're being blocked!\n"); + debugPM(); + ret = Blocked; // If it's true, we wait for a signal to continue - if( SDL_CondWait(_condSuspendable, _flagMutex) != 0) { + if (SDL_CondWait(_condSuspendable, _flagMutex) != 0) { PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't wait on cond %d\n", _condSuspendable); } - PSPDebugTrace("We got blocked!!\n"); + PSPDebugSuspend("We got blocked!!\n"); + debugPM(); } - // Now put the pm to sleep + // Now prevent the PM from suspending until we're done if (justBlock == false) _criticalCounter++; if (SDL_mutexV(_flagMutex) != 0) { PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't unlock flagMutex %d\n", _flagMutex); - ret = PowerManager::Error; + ret = Error; } return ret; @@ -182,25 +256,32 @@ int PowerManager::endCriticalSection() { if (SDL_mutexP(_flagMutex) != 0) { PSPDebugTrace("PowerManager::endCriticalSection(): Couldn't lock flagMutex %d\n", _flagMutex); - ret = PowerManager::Error; + ret = Error; } // We're done with our critical section _criticalCounter--; if (_criticalCounter <= 0) { - if(_suspendFlag == true) PSPDebugTrace("Waking up the PM and suspendFlag is true\n"); - - SDL_CondBroadcast(_condPM); + if (_suspendFlag == true) { // If the PM is sleeping, this flag must be set + PSPDebugSuspend("Unblocked thread waking up the PM.\n"); + debugPM(); + + SDL_CondBroadcast(_condPM); + + PSPDebugSuspend("Woke up the PM\n"); + debugPM(); + } - if (_criticalCounter < 0) { + if (_criticalCounter < 0) { // Check for bad usage of critical sections PSPDebugTrace("PowerManager::endCriticalSection(): Error! Critical counter is %d\n", _criticalCounter); + debugPM(); } } if (SDL_mutexV(_flagMutex) != 0) { PSPDebugTrace("PowerManager::endCriticalSection(): Couldn't unlock flagMutex %d\n", _flagMutex); - ret = PowerManager::Error; + ret = Error; } return ret; @@ -213,40 +294,86 @@ int PowerManager::endCriticalSection() { ********************************************/ int PowerManager::suspend() { int ret = 0; + + if (_pauseFlag) return ret; // Very important - make sure we only suspend once - // First we set the suspend flag to true + scePowerLock(0); // 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); + + // 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 + + if (_pauseClientState == Pausing) { // Our event has been acknowledged. Let's wait until the client is done. + PMStatusSet(kWaitForClientToFinishPausing); + + while (_pauseClientState != Paused) + sceKernelDelayThread(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. + + PMStatusSet(kGettingFlagMutexSuspend); + + // Now we set the suspend flag to true to cause reading threads to block + if (SDL_mutexP(_flagMutex) != 0) { PSPDebugTrace("PowerManager::suspend(): Couldn't lock flagMutex %d\n", _flagMutex); - ret = -1; + _error = Error; + ret = Error; } + PMStatusSet(kGotFlagMutexSuspend); + _suspendFlag = true; - if (_criticalCounter > 0) + // 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); + } if (SDL_mutexV(_flagMutex) != 0) { PSPDebugTrace("PowerManager::suspend(): Couldn't unlock flagMutex %d\n", _flagMutex); - ret = -1; + _error = Error; + ret = Error; } + PMStatusSet(kGettingListMutexSuspend); + // Loop over list, calling suspend() if (SDL_mutexP(_listMutex) != 0) { PSPDebugTrace("PowerManager::suspend(): Couldn't lock listMutex %d\n", _listMutex); - ret = -1; + _error = Error; + ret = Error; } - + PMStatusSet(kIteratingListSuspend); + // Iterate Common::List::iterator i = _suspendList.begin(); for (; i != _suspendList.end(); i++) { (*i)->suspend(); } + + PMStatusSet(kDoneIteratingListSuspend); if (SDL_mutexV(_listMutex) != 0) { PSPDebugTrace("PowerManager::suspend(): Couldn't unlock listMutex %d\n", _listMutex); - ret = -1; + _error = Error; + ret = Error; } + PMStatusSet(kDoneSuspend); + scePowerUnlock(0); // Allow the PSP to go to sleep now + return ret; } @@ -258,40 +385,67 @@ int PowerManager::suspend() { int PowerManager::resume() { int ret = 0; + // Make sure we can't get another suspend + scePowerLock(0); + + if (!_pauseFlag) return ret; // Make sure we can only resume once + + PMStatusSet(kGettingListMutexResume); + // First we notify our Suspendables. Loop over list, calling resume() if (SDL_mutexP(_listMutex) != 0) { PSPDebugTrace("PowerManager::resume(): Couldn't lock listMutex %d\n", _listMutex); - ret = -1; + _error = Error; + ret = Error; } - + PMStatusSet(kIteratingListResume); + // Iterate Common::List::iterator i = _suspendList.begin(); for (; i != _suspendList.end(); i++) { (*i)->resume(); } + + PMStatusSet(kDoneIteratingListResume); if (SDL_mutexV(_listMutex) != 0) { PSPDebugTrace("PowerManager::resume(): Couldn't unlock listMutex %d\n", _listMutex); - ret = -1; + _error = Error; + ret = Error; } + + PMStatusSet(kGettingFlagMutexResume); // Now we set the suspend flag to false if (SDL_mutexP(_flagMutex) != 0) { PSPDebugTrace("PowerManager::resume(): Couldn't lock flagMutex %d\n", _flagMutex); - ret = -1; + _error = Error; + ret = Error; } + PMStatusSet(kGotFlagMutexResume); + _suspendFlag = false; + PMStatusSet(kSignalSuspendedThreadsResume); + // Signal the other threads to wake up if (SDL_CondBroadcast(_condSuspendable) != 0) { PSPDebugTrace("PowerManager::resume(): Couldn't broadcast condition %d\n", _condSuspendable); - ret = -1; + _error = Error; + ret = Error; } + PMStatusSet(kDoneSignallingSuspendedThreadsResume); if (SDL_mutexV(_flagMutex) != 0) { PSPDebugTrace("PowerManager::resume(): Couldn't unlock flagMutex %d\n", _flagMutex); - ret = -1; + _error = Error; + ret = Error; } + PMStatusSet(kDoneResume); + + _pauseFlag = false; // Signal engine to unpause + scePowerUnlock(0); // Allow new suspends + return ret; } diff --git a/backends/platform/psp/powerman.h b/backends/platform/psp/powerman.h index 0a5f7a2361..43fb55459b 100644 --- a/backends/platform/psp/powerman.h +++ b/backends/platform/psp/powerman.h @@ -50,19 +50,6 @@ * *******************************************************************************************************/ class PowerManager: public Common::Singleton { -private: - friend class Common::Singleton; - PowerManager(); - ~PowerManager(); - - Common::List _suspendList; /* list to register in */ - - bool _suspendFlag; /* protected variable */ - SDL_mutex *_flagMutex; /* mutex to access access flag */ - SDL_mutex *_listMutex; /* mutex to access Suspendable list */ - SDL_cond *_condSuspendable; /* signal to synchronize accessing threads */ - SDL_cond *_condPM; /* signal to wake up the PM from a critical section */ - int _criticalCounter; /* Counter of how many threads are in a critical section */ public: int blockOnSuspend(); /* block if suspending */ @@ -72,13 +59,78 @@ public: int unregisterSuspend(Suspendable *item); /* remove from suspend/resume list */ int suspend(); /* callback to have all items in list suspend */ int resume(); /* callback to have all items in list resume */ + // Functions for pausing the engine + void pollPauseEngine(); /* Poll whether the engine should be paused */ enum { Error = -1, NotBlocked = 0, - Blocked = 1 + Blocked = 1 + }; + + enum PauseState { + Unpaused = 0, + PauseEvent, + UnpauseEvent, + Pausing, + Paused }; - + + private: + friend class Common::Singleton; + PowerManager(); + ~PowerManager(); + + Common::List _suspendList; /* list to register in */ + + volatile bool _pauseFlag; /* For pausing, which is before suspending */ + volatile bool _pauseFlagOld; /* Save the last state of the flag while polling */ + volatile int _pauseClientState; /* Pause state of the target */ + + volatile bool _suspendFlag; /* protected variable */ + SDL_mutex *_flagMutex; /* mutex to access access flag */ + SDL_mutex *_listMutex; /* mutex to access Suspendable list */ + SDL_cond *_condSuspendable; /* signal to synchronize accessing threads */ + SDL_cond *_condPM; /* signal to wake up the PM from a critical section */ + volatile int _criticalCounter; /* Counter of how many threads are in a critical section */ + int _error; /* error code - PM can't talk to us. For debugging */ + + // States for PM to be in (used for debugging) + enum PMState { + kInitDone = 1 , + kDestroyPM, + kWaitForClientPause, + kWaitForClientToFinishPausing, + kGettingFlagMutexSuspend, + kGotFlagMutexSuspend, + kWaitCritSectionSuspend, + kDoneWaitingCritSectionSuspend, + kGettingListMutexSuspend, + kIteratingListSuspend, + kDoneIteratingListSuspend, + kDoneSuspend, + kGettingListMutexResume, + kIteratingListResume, + kDoneIteratingListResume, + kGettingFlagMutexResume, + kGotFlagMutexResume, + kSignalSuspendedThreadsResume, + kDoneSignallingSuspendedThreadsResume, + kDoneResume + }; +#ifdef __PSP_DEBUG_SUSPEND__ + + volatile int _listCounter; /* How many people are in the list - just for debugging */ + + void debugPM(); /* print info about the PM */ + void PMStatusSet(PMState s) { _PMStatus = s; } + volatile int _PMStatus; /* What the PM is doing */ + + public: + int getPMStatus() { return _PMStatus; } + +#endif /* __PSP_DEBUG_SUSPEND__ */ + }; // For easy access diff --git a/backends/platform/psp/trace.cpp b/backends/platform/psp/trace.cpp index 00d19b582c..752c0b8306 100644 --- a/backends/platform/psp/trace.cpp +++ b/backends/platform/psp/trace.cpp @@ -27,10 +27,8 @@ #include "./trace.h" -//#define __DEBUG__ - void PSPDebugTrace (const char *format, ...) { -#ifdef __DEBUG__ +#ifdef __PSP_DEBUG__ va_list opt; char buff[2048]; int bufsz, fd; @@ -46,11 +44,11 @@ void PSPDebugTrace (const char *format, ...) { sceIoWrite(fd, (const void*)buff, bufsz); sceIoClose(fd); -#endif +#endif /* __PSP_DEBUG__ */ } void PSPDebugTrace (const char * filename, const char *format, ...) { -#ifdef __DEBUG__ +#ifdef __PSP_DEBUG__ va_list opt; char buff[2048]; int bufsz, fd; @@ -66,5 +64,5 @@ void PSPDebugTrace (const char * filename, const char *format, ...) { sceIoWrite(fd, (const void*)buff, bufsz); sceIoClose(fd); -#endif +#endif /* __PSP_DEBUG__ */ } diff --git a/backends/platform/psp/trace.h b/backends/platform/psp/trace.h index 80afdbc4fe..ef8992ceb2 100644 --- a/backends/platform/psp/trace.h +++ b/backends/platform/psp/trace.h @@ -33,8 +33,21 @@ #include #include +// Use these defines for debugging + +//#define __PSP_DEBUG__ +//#define __PSP_DEBUG_SUSPEND__ + void PSPDebugTrace (const char *filename, const char *format, ...); void PSPDebugTrace (const char *format, ...); +#ifdef __PSP_DEBUG_SUSPEND__ +#define PSPDebugSuspend(format,...) PSPDebugTrace(format, ## __VA_ARGS__) +#else +#define PSPDegbugSuspend(x) +#define PSPDebugSuspend(format,...) +#endif /* __PSP_DEBUG_SUSPEND__ */ + + #endif // TRACE_H diff --git a/backends/saves/psp/psp-saves.cpp b/backends/saves/psp/psp-saves.cpp index f759d3f531..bba27762cd 100644 --- a/backends/saves/psp/psp-saves.cpp +++ b/backends/saves/psp/psp-saves.cpp @@ -26,6 +26,7 @@ #ifdef __PSP__ #include "backends/saves/psp/psp-saves.h" +#include "backends/platform/psp/powerman.h" #include "common/config-manager.h" #include "common/savefile.h" @@ -49,6 +50,8 @@ void PSPSaveFileManager::checkPath(const Common::FSNode &dir) { const char *savePath = dir.getPath().c_str(); clearError(); + PowerMan.beginCriticalSection(); + //check if the save directory exists SceUID fd = sceIoDopen(savePath); if (fd < 0) { @@ -58,6 +61,8 @@ void PSPSaveFileManager::checkPath(const Common::FSNode &dir) { //it exists, so close it again. sceIoDclose(fd); } + + PowerMan.endCriticalSection(); } #endif -- cgit v1.2.3