- added a special thread to calculate interpolation to try to improve performance

source/shared_lib/include/platform/common/base_thread.h

@@ -31,19 +31,19 @@ protected:
 	bool quit;
 	bool running;
 
-	void setRunningStatus(bool value);
-	void setQuitStatus(bool value);
+	virtual void setRunningStatus(bool value);
+	virtual void setQuitStatus(bool value);
 
 public:
 	BaseThread();
 	~BaseThread();
 	virtual void execute()=0;
 
-    void signalQuit();
-    bool getQuitStatus();
-    bool getRunningStatus();
+	virtual void signalQuit();
+	virtual bool getQuitStatus();
+	virtual bool getRunningStatus();
     static void shutdownAndWait(BaseThread *ppThread);
-    void shutdownAndWait();
+    virtual void shutdownAndWait();
 };
 
 }}//end namespace

source/shared_lib/include/platform/sdl/thread.h

@@ -0,0 +1,82 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2005 Matthias Braun <matze@braunis.de>
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef _SHARED_PLATFORM_THREAD_H_
+#define _SHARED_PLATFORM_THREAD_H_
+
+#include <SDL_thread.h>
+#include <SDL_mutex.h>
+
+// =====================================================
+//	class Thread
+// =====================================================
+
+namespace Shared{ namespace Platform{
+
+class Thread{
+public:
+	enum Priority {
+		pIdle = 0,
+		pLow = 1,
+		pNormal = 2,
+		pHigh = 3,
+		pRealTime = 4
+	};
+	
+private:
+	SDL_Thread* thread;
+
+public:
+	virtual ~Thread() {}
+	
+	void start();
+	virtual void execute()=0;
+	void setPriority(Thread::Priority threadPriority);	
+	void suspend();
+	void resume();
+
+private:
+	static int beginExecution(void *param);
+};
+
+// =====================================================
+//	class Mutex
+// =====================================================
+
+class Mutex{
+private:
+	SDL_mutex* mutex;
+
+public:
+	Mutex();
+	~Mutex();
+	void p();
+	void v();
+};
+
+// =====================================================
+//	class Semaphore
+// =====================================================
+
+class Semaphore {
+private:
+	SDL_sem* semaphore;
+
+public:
+	Semaphore(Uint32 initialValue = 0);
+	~Semaphore();
+	void signal();
+	int waitTillSignalled();
+};
+
+}}//end namespace
+
+#endif

source/shared_lib/sources/platform/common/simple_threads.cpp

@@ -67,7 +67,7 @@ void FileCRCPreCacheThread::execute() {
 SimpleTaskThread::SimpleTaskThread(	SimpleTaskCallbackInterface *simpleTaskInterface, 
 									unsigned int executionCount,
 									unsigned int millisecsBetweenExecutions,
-									bool needTaskSignal) {
+									bool needTaskSignal) : BaseThread() {
 	this->simpleTaskInterface		 = simpleTaskInterface;
 	this->executionCount			 = executionCount;
 	this->millisecsBetweenExecutions = millisecsBetweenExecutions;
@@ -79,7 +79,7 @@ void SimpleTaskThread::execute() {
 	try {
 		setRunningStatus(true);
 
-		SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+		SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 
 		unsigned int idx = 0;
 		for(;this->simpleTaskInterface != NULL;) {
@@ -93,7 +93,7 @@ void SimpleTaskThread::execute() {
 			}
 
 			if(getQuitStatus() == true) {
-				//SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+				//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 				break;
 			}
 
@@ -108,19 +108,19 @@ void SimpleTaskThread::execute() {
 				}
 			}
 			if(getQuitStatus() == true) {
-				//SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+				//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 				break;
 			}
 
 			sleep(this->millisecsBetweenExecutions);
 		}
 
-		SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+		SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 	}
 	catch(const exception &ex) {
 		setRunningStatus(false);
 
-		SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+		SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 
 		throw runtime_error(ex.what());
 	}
@@ -128,24 +128,24 @@ void SimpleTaskThread::execute() {
 }
 
 void SimpleTaskThread::setTaskSignalled(bool value) {
-	//SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+	//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 
 	mutexTaskSignaller.p();
 	taskSignalled = value;
 	mutexTaskSignaller.v();
 
-	//SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+	//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 }
 
 bool SimpleTaskThread::getTaskSignalled() {
-	//SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+	//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 
 	bool retval = false;
 	mutexTaskSignaller.p();
 	retval = taskSignalled;
 	mutexTaskSignaller.v();
 
-	//SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
+	//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 
 	return retval;
 }

source/shared_lib/sources/platform/sdl/thread.cpp

@@ -0,0 +1,89 @@
+//This file is part of Glest Shared Library (www.glest.org)
+//Copyright (C) 2005 Matthias Braun <matze@braunis.de>
+
+//You can redistribute this code and/or modify it under 
+//the terms of the GNU General Public License as published by the Free Software 
+//Foundation; either version 2 of the License, or (at your option) any later 
+//version.
+
+#include "thread.h"
+
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+
+#include "noimpl.h"
+
+namespace Shared{ namespace Platform{ 
+
+// =====================================
+//          Threads                    
+// =====================================
+
+void Thread::start() {
+	thread = SDL_CreateThread(beginExecution, this);
+}
+
+void Thread::setPriority(Thread::Priority threadPriority) {
+	NOIMPL;
+}
+
+int Thread::beginExecution(void* data) {
+	Thread* thread = static_cast<Thread*> (data);
+	thread->execute();
+	return 0;
+}
+
+void Thread::suspend() {
+	NOIMPL;
+}
+
+void Thread::resume() {
+	NOIMPL;
+}
+
+// =====================================
+//          Mutex                      
+// =====================================
+
+Mutex::Mutex() {
+	mutex = SDL_CreateMutex();
+	if(mutex == 0)
+		throw std::runtime_error("Couldn't initialize mutex");
+}
+
+Mutex::~Mutex() {
+	SDL_DestroyMutex(mutex);
+}
+
+void Mutex::p() {
+	SDL_mutexP(mutex);
+}
+
+void Mutex::v() {
+	SDL_mutexV(mutex);
+}
+
+// =====================================================
+//	class Semaphore
+// =====================================================
+
+Semaphore::Semaphore(Uint32 initialValue) {
+	semaphore = SDL_CreateSemaphore(initialValue);
+}
+
+Semaphore::~Semaphore() {
+	SDL_DestroySemaphore(semaphore);
+	semaphore = NULL;
+}
+
+void Semaphore::signal() {
+	SDL_SemPost(semaphore);
+}
+
+int Semaphore::waitTillSignalled() {
+	int semValue = SDL_SemWait(semaphore);
+	return semValue;
+}
+
+}}//end namespace

source/shared_lib/sources/platform/win32/thread.cpp

@@ -0,0 +1,88 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2008 Martio Figueroa
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#include "thread.h"
+
+#include "leak_dumper.h"
+
+namespace Shared{ namespace Platform{ 
+
+// =====================================================
+//	class Threads
+// =====================================================
+
+ThreadId Thread::nextThreadId= threadIdBase;
+
+void Thread::start(){
+	threadHandle= CreateThread(NULL, 0, beginExecution, this, 0, &nextThreadId); 
+	nextThreadId++;
+}
+
+void Thread::setPriority(Thread::Priority threadPriority){
+	SetThreadPriority(threadHandle, threadPriority);
+}
+
+DWORD WINAPI Thread::beginExecution(void *param){
+	static_cast<Thread*>(param)->execute();
+	return 0;
+}
+
+void Thread::suspend(){
+	SuspendThread(threadHandle);
+}
+
+void Thread::resume(){
+	ResumeThread(threadHandle);
+}
+
+// =====================================================
+//	class Mutex
+// =====================================================
+
+Mutex::Mutex(){
+    InitializeCriticalSection(&mutex); 
+}
+
+Mutex::~Mutex(){
+    DeleteCriticalSection(&mutex);
+}
+
+void Mutex::p(){
+    EnterCriticalSection(&mutex);
+}
+
+void Mutex::v(){
+    LeaveCriticalSection(&mutex);
+}
+
+// =====================================================
+//	class Semaphore
+// =====================================================
+
+Semaphore::Semaphore(Uint32 initialValue) {
+	semaphore = SDL_CreateSemaphore(initialValue);
+}
+
+Semaphore::~Semaphore() {
+	SDL_DestroySemaphore(semaphore);
+	semaphore = NULL;
+}
+
+void Semaphore::signal() {
+	SDL_SemPost(semaphore);
+}
+
+int Semaphore::waitTillSignalled() {
+	int semValue = SDL_SemWait(semaphore);
+	return semValue;
+}
+
+}}//end namespace