6 files changed, 211 insertions, 82 deletions

diff --git a/VC2008/MCServer.vcproj b/VC2008/MCServer.vcproj
index 0522b7ea5..1dc6129e8 100644
--- a/VC2008/MCServer.vcproj
+++ b/VC2008/MCServer.vcproj
@@ -20,6 +20,7 @@
 			OutputDirectory="Debug"

 			IntermediateDirectory="Debug"

 			ConfigurationType="1"

+			CharacterSet="2"

 			>

 			<Tool

 				Name="VCPreBuildEventTool"

diff --git a/source/cChunkGenerator.cpp b/source/cChunkGenerator.cpp
index f6a16342c..78c90e244 100644
--- a/source/cChunkGenerator.cpp
+++ b/source/cChunkGenerator.cpp
@@ -15,116 +15,123 @@
 typedef std::pair<int, int> ChunkCoord;

 typedef std::list< ChunkCoord > ChunkCoordList;

 

-#define MAX_SEMAPHORES 1000

+

+

+

+

+/// If the generation queue size exceeds this number, a warning will be output

+#define QUEUE_WARNING_LIMIT 1000

+

+

+

+

 

 struct cChunkGenerator::sChunkGeneratorState

 {

-	sChunkGeneratorState()

-		: pCriticalSection( 0 )

-		, pSemaphore( 0 )

+	cCriticalSection m_CriticalSection;  // For protecting the variables in this struct

+

+	ChunkCoordList GenerateQueue;

+	ChunkCoord CurrentlyGeneratingCoords;

+	cChunk* pCurrentlyGenerating;

+	bool bCurrentlyGenerating;

+

+	cSemaphore m_Semaphore;

+	cThread * pThread;

+

+	bool bStop;

+

+	sChunkGeneratorState(void)

+		: m_Semaphore(1, 0)

 		, pThread( 0 )

 		, bStop( false )

 		, bCurrentlyGenerating( false )

 		, pCurrentlyGenerating( false )

-		, pChunkCriticalSection( 0 )

 	{}

-	ChunkCoordList GenerateQueue;			// Protected by pCriticalSection

-	ChunkCoord CurrentlyGeneratingCoords;	// Protected by pCriticalSection

-	cChunk* pCurrentlyGenerating;			// Protected by pCriticalSection

-	bool bCurrentlyGenerating;				// Protected by pCriticalSection

+};

+

 

-	cCriticalSection* pCriticalSection;

-	cSemaphore* pSemaphore;

-	cThread* pThread;

 

-	cCriticalSection* pChunkCriticalSection;// Specially for protecting the actual chunk that is currently being generated, and not just the variables in this struct

 

-	bool bStop;

-};

 

 cChunkGenerator::cChunkGenerator( cChunkMap* a_pChunkMap )

 	: m_pState( new sChunkGeneratorState )

 	, m_pChunkMap( a_pChunkMap )

 {

-	m_pState->pCriticalSection = new cCriticalSection();

-	m_pState->pSemaphore = new cSemaphore( MAX_SEMAPHORES, 0 );

-

-	m_pState->pChunkCriticalSection = new cCriticalSection();

-

 	m_pState->pThread = new cThread( GenerateThread, this, "cChunkGenerator::GenerateThread" );

 	m_pState->pThread->Start( true );

 }

 

+

+

+

+

 cChunkGenerator::~cChunkGenerator()

 {

 	m_pState->bStop = true;

 

-	m_pState->pSemaphore->Signal(); // Signal so thread can continue and exit

+	m_pState->m_Semaphore.Signal(); // Signal so thread can continue and exit

 	delete m_pState->pThread;

 

-	delete m_pState->pSemaphore;

-	delete m_pState->pCriticalSection;

-	delete m_pState->pChunkCriticalSection;

-	delete m_pState; m_pState = 0;

+	delete m_pState;

 }

 

+

+

+

+

 void cChunkGenerator::GenerateChunk( int a_X, int a_Z )

 {

-	m_pState->pCriticalSection->Lock();

+	cCSLock Lock(&m_pState->m_CriticalSection);

 

-	if( m_pState->bCurrentlyGenerating )

+	if (m_pState->bCurrentlyGenerating)

 	{

-		if( m_pState->CurrentlyGeneratingCoords.first == a_X && m_pState->CurrentlyGeneratingCoords.second == a_Z )

+		if ((m_pState->CurrentlyGeneratingCoords.first == a_X) && (m_pState->CurrentlyGeneratingCoords.second == a_Z))

 		{

-			m_pState->pCriticalSection->Unlock();

 			return;	// Already generating this chunk, so ignore

 		}

 	}

 

-	int SizeBefore = m_pState->GenerateQueue.size();

-

 	m_pState->GenerateQueue.remove( ChunkCoord(a_X, a_Z) );

-	if( m_pState->GenerateQueue.size() >= MAX_SEMAPHORES )

+	if (m_pState->GenerateQueue.size() >= QUEUE_WARNING_LIMIT)

 	{

-		LOGWARN("WARNING: Can't add chunk (%i, %i) to generation queue: Queue is too big! (%i)", a_X, a_Z, m_pState->GenerateQueue.size() );

-		m_pState->pCriticalSection->Unlock();

-		return;

+		LOGWARN("WARNING: Adding chunk (%i, %i) to generation queue; Queue is too big! (%i)", a_X, a_Z, m_pState->GenerateQueue.size() );

 	}

 	m_pState->GenerateQueue.push_back( ChunkCoord(a_X, a_Z) );

-	int SizeAfter = m_pState->GenerateQueue.size();

 

-	m_pState->pCriticalSection->Unlock();

-	if( SizeBefore < SizeAfter )

-		m_pState->pSemaphore->Signal();

+	Lock.Unlock();

+	

+	m_pState->m_Semaphore.Signal();

 }

 

+

+

+

+

 void cChunkGenerator::GenerateThread( void* a_Params )

 {

 	// Cache some values for easy access (they are all references/pointers)

-	cChunkGenerator* self = (cChunkGenerator*)a_Params;

-	sChunkGeneratorState* m_pState = self->m_pState;

-	ChunkCoordList& GenerateQueue = m_pState->GenerateQueue;

-	cChunkMap& ChunkMap = *self->m_pChunkMap;

-	cCriticalSection& CriticalSection = *m_pState->pCriticalSection;

-	cSemaphore& Semaphore = *m_pState->pSemaphore;

-

-	while( !m_pState->bStop )

+	cChunkGenerator * self = (cChunkGenerator*)a_Params;

+	sChunkGeneratorState * m_pState = self->m_pState;

+	ChunkCoordList & GenerateQueue = m_pState->GenerateQueue;

+	cChunkMap & ChunkMap = *self->m_pChunkMap;

+	cCriticalSection * CriticalSection = &m_pState->m_CriticalSection;

+	cSemaphore & Semaphore = m_pState->m_Semaphore;

+

+	while (!m_pState->bStop)

 	{

-		Semaphore.Wait();

-		if( m_pState->bStop ) break;

-

-		CriticalSection.Lock();

-		if( GenerateQueue.size() == 0 )

+		cCSLock Lock(CriticalSection);

+		if (GenerateQueue.size() == 0)

 		{

-			if( !m_pState->bStop ) LOGERROR("ERROR: Semaphore was signaled while GenerateQueue.size == 0");

-			CriticalSection.Unlock();

-			continue;

+			cCSUnlock Unlock(Lock);

+			Semaphore.Wait();

 		}

+		if (m_pState->bStop) break;

+		

 		ChunkCoord coord = *GenerateQueue.begin();		// Get next coord from queue

 		GenerateQueue.erase( GenerateQueue.begin() );	// Remove coordinate from queue

 		m_pState->bCurrentlyGenerating = true;

 		m_pState->CurrentlyGeneratingCoords = coord;

-		CriticalSection.Unlock();			// Unlock ASAP

+		Lock.Unlock();			// Unlock ASAP

 

 		ChunkMap.GetWorld()->LockChunks();

 		if( ChunkMap.GetChunk( coord.first, 0, coord.second ) ) // Make sure it has not been loaded in the meantime. Don't want to generate the same chunk twice

@@ -137,36 +144,23 @@ void cChunkGenerator::GenerateThread( void* a_Params )
 		LOGINFO("cChunkGenerator generating chunk %i %i", coord.first, coord.second );

 		cChunk* Chunk = new cChunk( coord.first, 0, coord.second, ChunkMap.GetWorld() );

 

-		CriticalSection.Lock();

+		Lock.Lock();

 		m_pState->pCurrentlyGenerating = Chunk;

-		CriticalSection.Unlock();

+		Lock.Unlock();

 

-		self->Lock(); // Protect the actual chunk

 		Chunk->Initialize(); // Generate the chunk

-		self->Unlock();

 

 		ChunkMap.GetWorld()->LockChunks();

 		ChunkMap.AddChunk( Chunk );

 		ChunkMap.GetWorld()->UnlockChunks();

 

-		CriticalSection.Lock();

+		Lock.Lock();

 		m_pState->bCurrentlyGenerating = false;

 		m_pState->pCurrentlyGenerating = 0;

-		CriticalSection.Unlock();

-	}

+		Lock.Unlock();

+	}  // while (!bStop)

 }

 

-cChunk* cChunkGenerator::GetCurrentlyGenerating()

-{

-	return m_pState->pCurrentlyGenerating;

-}

 

-void cChunkGenerator::Lock()

-{

-	m_pState->pChunkCriticalSection->Lock();

-}

 

-void cChunkGenerator::Unlock()

-{

-	m_pState->pChunkCriticalSection->Unlock();

-}
\ No newline at end of file
+

diff --git a/source/cChunkGenerator.h b/source/cChunkGenerator.h
index df29a3e60..bdba4da98 100644
--- a/source/cChunkGenerator.h
+++ b/source/cChunkGenerator.h
@@ -10,9 +10,6 @@ public:
 

 	void GenerateChunk( int a_X, int a_Z );

 

-	cChunk* GetCurrentlyGenerating(); // WARNING - Be sure to Lock() before calling, and Unlock() after done with the chunk!

-	void Lock();

-	void Unlock();

 private:

 	static void GenerateThread( void* a_Params );

 

diff --git a/source/cChunkMap.cpp b/source/cChunkMap.cpp
index a6bf6bda0..3cfeb0485 100644
--- a/source/cChunkMap.cpp
+++ b/source/cChunkMap.cpp
@@ -396,14 +396,15 @@ cChunk* cChunkMap::GetChunk( int a_X, int a_Y, int a_Z )
 				delete [] Data->m_Compressed; Data->m_Compressed = 0; Data->m_CompressedSize = 0;

 				return Chunk;

 			}

-

-			

 		}

 	}

-

 	return 0;

 }

 

+

+

+

+

 void cChunkMap::Tick( float a_Dt )

 {

 	/*	// OLD

diff --git a/source/cCriticalSection.cpp b/source/cCriticalSection.cpp
index 85f89c195..bf84b7c2f 100644
--- a/source/cCriticalSection.cpp
+++ b/source/cCriticalSection.cpp
@@ -1,5 +1,6 @@
 #include "cCriticalSection.h"

 #include "cMCLogger.h"

+#include <assert.h>

 

 #ifdef _WIN32

 #include <Windows.h>

@@ -7,6 +8,13 @@
 #include <pthread.h>

 #endif

 

+

+

+

+

+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+// cCriticalSection:

+

 cCriticalSection::cCriticalSection()

 {

 #ifdef _WIN32

@@ -25,6 +33,10 @@ cCriticalSection::cCriticalSection()
 #endif

 }

 

+

+

+

+

 cCriticalSection::~cCriticalSection()

 {

 #ifdef _WIN32

@@ -41,6 +53,10 @@ cCriticalSection::~cCriticalSection()
 #endif

 }

 

+

+

+

+

 void cCriticalSection::Lock()

 {

 #ifdef _WIN32

@@ -50,6 +66,10 @@ void cCriticalSection::Lock()
 #endif

 }

 

+

+

+

+

 void cCriticalSection::Unlock()

 {

 #ifdef _WIN32

@@ -58,3 +78,80 @@ void cCriticalSection::Unlock()
     pthread_mutex_unlock( (pthread_mutex_t*)m_CriticalSectionPtr );

 #endif

 }

+

+

+

+

+

+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+// cCSLock

+

+cCSLock::cCSLock(cCriticalSection * a_CS) :

+	m_CS(a_CS),

+	m_IsLocked(false)

+{

+	Lock();

+}

+

+

+

+

+

+cCSLock::~cCSLock()

+{

+	Unlock();

+}

+

+

+

+

+

+void cCSLock::Lock(void)

+{

+	#ifdef _DEBUG

+	assert(!m_IsLocked);

+	m_IsLocked = true;

+	#endif  // _DEBUG

+	

+	m_CS->Lock();

+}

+

+

+

+

+

+void cCSLock::Unlock(void)

+{

+	#ifdef _DEBUG

+	assert(m_IsLocked);

+	m_IsLocked = false;

+	#endif  // _DEBUG

+	

+	m_CS->Unlock();

+}

+

+

+

+

+

+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+// cCSUnlock:

+

+cCSUnlock::cCSUnlock(cCSLock & a_Lock) :

+	m_Lock(a_Lock)

+{

+	m_Lock.Unlock();

+}

+

+

+

+

+

+cCSUnlock::~cCSUnlock()

+{

+	m_Lock.Lock();

+}

+

+

+

+

diff --git a/source/cCriticalSection.h b/source/cCriticalSection.h
index fd1d34e46..60602e821 100644
--- a/source/cCriticalSection.h
+++ b/source/cCriticalSection.h
@@ -13,4 +13,43 @@ private:
 #ifndef _WIN32

 	void* m_Attributes;

 #endif

-};
\ No newline at end of file
+};

+

+

+

+

+/// RAII for cCriticalSection - locks the CS on creation, unlocks on destruction

+class cCSLock

+{

+	cCriticalSection * m_CS;

+

+	#ifdef _DEBUG

+	// Unlike a cCriticalSection, this object should be used from a single thread, therefore access to m_IsLocked is not threadsafe

+	bool m_IsLocked;

+	#endif  // _DEBUG

+	

+public:

+	cCSLock(cCriticalSection * a_CS);

+	~cCSLock();

+	

+	// Temporarily unlock or re-lock:

+	void Lock(void);

+	void Unlock(void);

+} ;

+

+

+

+

+

+/// Temporary RAII unlock for a cCSLock. Useful for unlock-wait-relock scenarios

+class cCSUnlock

+{

+	cCSLock & m_Lock;

+public:

+	cCSUnlock(cCSLock & a_Lock);

+	~cCSUnlock();

+} ;

+

+

+

+