TESTBED: Merged changes from trunk to my branch

svn-id: r51798

1 files changed, 181 insertions, 34 deletions

diff --git a/backends/platform/psp/thread.cpp b/backends/platform/psp/thread.cpp
index 4e7d5eada9..916b1e553b 100644
--- a/backends/platform/psp/thread.cpp
+++ b/backends/platform/psp/thread.cpp
@@ -23,14 +23,56 @@
  *
  */
 
-#include <time.h> 
-#include <psptypes.h>
-#include <psprtc.h>
 #include <pspthreadman.h> 
 
 #include "backends/platform/psp/thread.h"
 #include "backends/platform/psp/trace.h"
  
+// Class PspThreadable -------------------------------------------------- 
+// Inherit this to create C++ threads easily
+
+bool PspThreadable::threadCreateAndStart(const char *threadName, int priority, int stackSize, bool useVfpu /*= false*/) {
+	DEBUG_ENTER_FUNC();
+
+	if (_threadId != -1) {
+		PSP_ERROR("thread already created!\n");
+		return false;
+	}
+		
+	_threadId = sceKernelCreateThread(threadName, __threadCallback, priority, stackSize, THREAD_ATTR_USER, 0);	// add VFPU support
+
+	if (_threadId < 0) {
+		PSP_ERROR("failed to create %s thread. Error code %d\n", threadName, _threadId);
+		return false;
+	}
+	
+	// We want to pass the pointer to this, but we'll have to take address of this so use a little trick
+	PspThreadable *_this = this;
+	
+	if (sceKernelStartThread(_threadId, sizeof(uint32 *), &_this) < 0) {
+		PSP_ERROR("failed to start %s thread id[%d]\n", threadName, _threadId);
+		return false;
+	}
+	
+	PSP_DEBUG_PRINT("Started %s thread with id[%x]\n", threadName, _threadId);	
+	
+	return true;
+}
+
+// Callback function to be called by PSP kernel
+int PspThreadable::__threadCallback(SceSize, void *__this) {
+	DEBUG_ENTER_FUNC();
+	
+	PspThreadable *_this = *(PspThreadable **)__this;	// Dereference the copied value which was 'this'
+	
+	_this->threadFunction();	// call the virtual function
+	
+	return 0;
+}
+
+// PspThread class
+// Utilities to access general thread functions
+ 
 void PspThread::delayMillis(uint32 ms) {
 	sceKernelDelayThread(ms * 1000);
 }
@@ -39,49 +81,154 @@ void PspThread::delayMicros(uint32 us) {
 	sceKernelDelayThread(us);
 }
 
-void PspRtc::init() {						// init our starting ticks
-	uint32 ticks[2];
-	sceRtcGetCurrentTick((u64 *)ticks);
+// Class PspSemaphore ------------------------------------------------
+//#define __PSP_DEBUG_FUNCS__	/* For debugging function calls */
+//#define __PSP_DEBUG_PRINT__	/* For debug printouts */
+
+#include "backends/platform/psp/trace.h"
 
-	_startMillis = ticks[0]/1000;
-	_startMicros = ticks[0];
-	//_lastMillis = ticks[0]/1000;	//debug - only when we don't subtract startMillis
+PspSemaphore::PspSemaphore(int initialValue, int maxValue/*=255*/) {
+	DEBUG_ENTER_FUNC();
+	_handle = 0;
+	_handle = (uint32)sceKernelCreateSema("ScummVM Sema", 0 /* attr */, 
+								  initialValue, maxValue, 
+								  0 /*option*/);
+	if (!_handle)
+		PSP_ERROR("failed to create semaphore.\n");
 }
 
-#define MS_LOOP_AROUND 4294967				/* We loop every 2^32 / 1000 = 71 minutes */
-#define MS_LOOP_CHECK  60000				/* Threading can cause weird mixups without this */
+PspSemaphore::~PspSemaphore() {
+	DEBUG_ENTER_FUNC();
+	if (_handle)
+		if (sceKernelDeleteSema((SceUID)_handle) < 0)
+			PSP_ERROR("failed to delete semaphore.\n");
+}
 
-// Note that after we fill up 32 bits ie 50 days we'll loop back to 0, which may cause 
-// unpredictable results
-uint32 PspRtc::getMillis() {
-	uint32 ticks[2];
+int PspSemaphore::numOfWaitingThreads() {
+	DEBUG_ENTER_FUNC();
+	SceKernelSemaInfo info;
+	info.numWaitThreads = 0;
 	
-	sceRtcGetCurrentTick((u64 *)ticks);		// can introduce weird thread delays
+	if (sceKernelReferSemaStatus((SceUID)_handle, &info) < 0)
+		PSP_ERROR("failed to retrieve semaphore info for handle %d\n", _handle);
+		
+	return info.numWaitThreads;
+}
+
+int PspSemaphore::getValue() {
+	DEBUG_ENTER_FUNC();
+	SceKernelSemaInfo info;
+	info.currentCount = 0;
 	
-	uint32 millis = ticks[0]/1000;
-	millis -= _startMillis;					// get ms since start of program
+	if (sceKernelReferSemaStatus((SceUID)_handle, &info) < 0)
+		PSP_ERROR("failed to retrieve semaphore info for handle %d\n", _handle);
+		
+	return info.currentCount;
+}
 
-	if ((int)_lastMillis - (int)millis > MS_LOOP_CHECK) {		// we must have looped around
-		if (_looped == false) {					// check to make sure threads do this once
-			_looped = true;
-			_milliOffset += MS_LOOP_AROUND;		// add the needed offset
-			PSP_DEBUG_PRINT("looping around. last ms[%d], curr ms[%d]\n", _lastMillis, millis);
-		}	
-	} else {
-		_looped = false;
-	}
+bool PspSemaphore::pollForValue(int value) {
+	DEBUG_ENTER_FUNC();
+	if (sceKernelPollSema((SceUID)_handle, value) < 0)
+		return false;
+	
+	return true;
+}
+
+// false: timeout or error
+bool PspSemaphore::takeWithTimeOut(uint32 timeOut) {
+	DEBUG_ENTER_FUNC();
+	
+	uint32 *pTimeOut = 0;
+	if (timeOut) 
+		pTimeOut = &timeOut;
+	
+	if (sceKernelWaitSema(_handle, 1, pTimeOut) < 0)	// we always wait for 1
+		return false;
+	return true;
+}
+
+bool PspSemaphore::give(int num /*=1*/) {
+	DEBUG_ENTER_FUNC();
 	
-	_lastMillis = millis;	
+	if (sceKernelSignalSema((SceUID)_handle, num) < 0)
+		return false;	
+	return true;
+}
+
+// Class PspMutex ------------------------------------------------------------
+
+bool PspMutex::lock() {
+	DEBUG_ENTER_FUNC();
+	int threadId = sceKernelGetThreadId();
+	bool ret = true;
 	
-	return millis + _milliOffset;
+	if (_ownerId == threadId) {
+		_recursiveCount++;
+	} else {
+		ret = _semaphore.take();
+		_ownerId = threadId;
+		_recursiveCount = 0;
+	}
+	return ret;
 }
 
-uint32 PspRtc::getMicros() {
-	uint32 ticks[2];
+bool PspMutex::unlock() {
+	DEBUG_ENTER_FUNC();
+	int threadId = sceKernelGetThreadId();
+	bool ret = true;
 	
-	sceRtcGetCurrentTick((u64 *)ticks);
-	ticks[0] -= _startMicros;
+	if (_ownerId != threadId) {
+		PSP_ERROR("attempt to unlock mutex by thread[%x] as opposed to owner[%x]\n",
+			threadId, _ownerId);
+		return false;
+	}
 	
-	return ticks[0]; 
+	if (_recursiveCount) {
+		_recursiveCount--;
+	} else {
+		_ownerId = 0;
+		ret = _semaphore.give(1);
+	}	
+	return ret;
+}
+
+// Class PspCondition -------------------------------------------------
+
+// Release all threads waiting on the condition
+void PspCondition::releaseAll() {
+        _mutex.lock();
+        if (_waitingThreads > _signaledThreads) {	// we have signals to issue
+                int numWaiting = _waitingThreads - _signaledThreads;	// threads we haven't signaled
+                _signaledThreads = _waitingThreads;
+                
+				_waitSem.give(numWaiting);
+                _mutex.unlock();
+                for (int i=0; i<numWaiting; i++)	// wait for threads to tell us they're awake
+					_doneSem.take();
+        } else {
+                _mutex.unlock();
+        }
+}
+
+// Mutex must be taken before entering wait
+void PspCondition::wait(PspMutex &externalMutex) {
+        _mutex.lock();
+        _waitingThreads++;
+        _mutex.unlock();
+
+        externalMutex.unlock();	// must unlock external mutex
+
+		_waitSem.take();	// sleep on the wait semaphore
+
+		// let the signaling thread know we're done
+		_mutex.lock();
+        if (_signaledThreads > 0 ) {
+                _doneSem.give();	// let the thread know
+                _signaledThreads--;
+        }
+        _waitingThreads--;
+        _mutex.unlock();
+
+        externalMutex.lock();		// must lock external mutex here for continuation
 }