flewkey
/
cuberite-2a
1
0
Fork 0
Code Releases Activity

refactored chunk Queue to seperate class

This commit is contained in:
Tycho Bickerstaff 2013-12-31 15:48:57 +00:00
parent d0cd9a2b36
commit f3736b1eb7
7 changed files with 161 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/ChunkDef.h
View File

@ -14,7 +14,6 @@
/** This is really only a placeholder to be used in places where we need to "make up" a chunk's Y coord.
It will help us when the new chunk format comes out and we need to patch everything up for compatibility.
*/

6
src/OSSupport/Event.h
View File

@ -20,10 +20,10 @@ class cEvent
{
public:
cEvent(void);
~cEvent();
virtual ~cEvent();
void Wait(void);
void Set (void);
virtual void Wait(void);
virtual void Set (void);
private:

1
src/OSSupport/IsThread.h
View File

@ -22,7 +22,6 @@ In the descending class' constructor call the Start() method to start the thread
class cIsThread
{
protected:

108
src/OSSupport/Queue.h
View File

@ -1,30 +1,104 @@
#pragma once
#include <list>
#include "../OSSupport/Promise.h"
//this empty struct allows function inlining
template<class T>
class cDeleter
struct cQueueFuncs
{
public:
static void Delete(T) {};
}
static void Combine(T&, const T) {};
};
template<class T, class D = cDelete>
template<class ItemType, class Funcs = cQueueFuncs<ItemType> >
class cQueue
{
typedef typename std::list<ItemType> ListType;
//magic typedef to persuade clang that the iterator is a type
typedef typename ListType::iterator iterator;
public:
cQueue(int warnsize);
cQueue(cQueue<T>& queue);
~cQueue();
cQueue() {}
~cQueue() {}
void EnqueueItem(ItemType a_item)
{
cCSLock Lock(m_CS);
m_contents.push_back(a_item);
m_evtAdded.Set();
}
void EnqueueItemIfNotPresent(ItemType a_item)
{
cCSLock Lock(m_CS);
for (iterator itr = m_contents.begin(); itr != m_contents.end(); ++itr)
{
if((*itr) == a_item) {
Funcs funcTable;
funcTable.Combine(*itr,a_item);
return;
}
}
m_contents.push_back(a_item);
m_evtAdded.Set();
}
bool TryDequeueItem(ItemType& item)
{
cCSLock Lock(m_CS);
if (m_contents.size() == 0) return false;
item = m_contents.front();
m_contents.pop_front();
return true;
}
ItemType DequeueItem()
{
cCSLock Lock(m_CS);
while (m_contents.size() == 0)
{
cCSUnlock Unlock(m_CS);
m_evtAdded.Wait();
}
return m_contents.pop_front();
}
cPromise* BlockTillEmpty() {
return new cEmptyQueuePromise(this);
}
//can all be inlined when delete is a noop
void Clear()
{
cCSLock Lock(m_CS);
Funcs funcTable;
while (!m_contents.empty())
{
funcTable.Delete(m_contents.front());
m_contents.pop_front();
}
}
size_t Size()
{
cCSLock Lock(m_CS);
return m_contents.size();
}
bool Remove(ItemType item)
{
cCSLock Lock(m_CS);
m_contents.remove(item);
}
void EnqueueItem(T item);
bool TryDequeueItem(T& item);
T DequeueItem();
void BlockTillEmpty(cEvent CancelationEvent);
void Clear();
int Size();
private:
int warnsize;
}
ListType m_contents;
cCriticalSection m_CS;
cEvent m_evtAdded;
//template classes must be implemented in the header
#include "Queue.inc"
class cEmptyQueuePromise : public cPromise {
public:
cEmptyQueuePromise(cQueue* a_Queue) : cPromise(), m_Queue(a_Queue) {}
virtual bool IsCompleted() {return m_Queue->Size() != 0;}
private:
cQueue* m_Queue;
};
};

4
src/OSSupport/Queue.inc
View File

@ -1,4 +0,0 @@
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules

136
src/WorldStorage/WorldStorage.cpp
View File

@ -13,7 +13,7 @@
#include "../Generating/ChunkGenerator.h"
#include "../Entities/Entity.h"
#include "../BlockEntities/BlockEntity.h"
#include "../OSSupport/Promise.h"
@ -63,8 +63,6 @@ cWorldStorage::~cWorldStorage()
{
delete *itr;
} // for itr - m_Schemas[]
m_LoadQueue.clear();
m_SaveQueue.clear();
}
@ -98,9 +96,7 @@ void cWorldStorage::WaitForFinish(void)
LOG("Waiting for the world storage to finish saving");
{
// Cancel all loading requests:
cCSLock Lock(m_CSQueues);
m_LoadQueue.clear();
m_LoadQueue.Clear();
}
// Wait for the saving to finish:
@ -120,32 +116,36 @@ void cWorldStorage::WaitForFinish(void)
void cWorldStorage::WaitForQueuesEmpty(void)
{
cCSLock Lock(m_CSQueues);
while (!m_ShouldTerminate && (!m_LoadQueue.empty() || !m_SaveQueue.empty()))
{
cCSUnlock Unlock(Lock);
m_evtRemoved.Wait();
}
cPromise * LoadPromise = m_LoadQueue.BlockTillEmpty();
cPromise * SavePromise = m_SaveQueue.BlockTillEmpty();
cPromise * QueuePromise = LoadPromise->WaitFor(SavePromise);
cPromise * CancelPromise = QueuePromise->CancelOn(m_ShouldTerminate);
CancelPromise->Wait();
delete CancelPromise;
delete QueuePromise;
delete SavePromise;
delete LoadPromise;
}
int cWorldStorage::GetLoadQueueLength(void)
size_t cWorldStorage::GetLoadQueueLength(void)
{
cCSLock Lock(m_CSQueues);
return (int)m_LoadQueue.size();
return m_LoadQueue.Size();
}
int cWorldStorage::GetSaveQueueLength(void)
size_t cWorldStorage::GetSaveQueueLength(void)
{
cCSLock Lock(m_CSQueues);
return (int)m_SaveQueue.size();
return m_SaveQueue.Size();
}
@ -154,22 +154,7 @@ int cWorldStorage::GetSaveQueueLength(void)
void cWorldStorage::QueueLoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ, bool a_Generate)
{
// Queues the chunk for loading; if not loaded, the chunk will be generated
{
cCSLock Lock(m_CSQueues);
// Check if already in the queue:
for (sChunkLoadQueue::iterator itr = m_LoadQueue.begin(); itr != m_LoadQueue.end(); ++itr)
{
if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkY == a_ChunkY) && (itr->m_ChunkZ == a_ChunkZ) && (itr->m_Generate == a_Generate))
{
return;
}
}
m_LoadQueue.push_back(sChunkLoad(a_ChunkX, a_ChunkY, a_ChunkZ, a_Generate));
}
m_Event.Set();
m_LoadQueue.EnqueueItemIfNotPresent(sChunkLoad(a_ChunkX, a_ChunkY, a_ChunkZ, a_Generate));
}
@ -178,12 +163,7 @@ void cWorldStorage::QueueLoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ, boo
void cWorldStorage::QueueSaveChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
{
{
cCSLock Lock(m_CSQueues);
m_SaveQueue.remove (cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ)); // Don't add twice
m_SaveQueue.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));
}
m_Event.Set();
m_SaveQueue.EnqueueItemIfNotPresent(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));
}
@ -192,12 +172,8 @@ void cWorldStorage::QueueSaveChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
void cWorldStorage::QueueSavedMessage(void)
{
// Pushes a special coord pair into the queue, signalizing a message instead:
{
cCSLock Lock(m_CSQueues);
m_SaveQueue.push_back(cChunkCoords(0, CHUNK_Y_MESSAGE, 0));
}
m_Event.Set();
// Pushes a special coord pair into the queue, signalizing a message instead
m_SaveQueue.EnqueueItem(cChunkCoords(0, CHUNK_Y_MESSAGE, 0));
}
@ -206,7 +182,7 @@ void cWorldStorage::QueueSavedMessage(void)
void cWorldStorage::UnqueueLoad(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
{
cCSLock Lock(m_CSQueues);
/*cCSLock Lock(m_CSQueues);
for (sChunkLoadQueue::iterator itr = m_LoadQueue.begin(); itr != m_LoadQueue.end(); ++itr)
{
if ((itr->m_ChunkX != a_ChunkX) || (itr->m_ChunkY != a_ChunkY) || (itr->m_ChunkZ != a_ChunkZ))
@ -217,7 +193,8 @@ void cWorldStorage::UnqueueLoad(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
Lock.Unlock();
m_evtRemoved.Set();
return;
} // for itr - m_LoadQueue[]
} // for itr - m_LoadQueue[]*/
m_LoadQueue.Remove(sChunkLoad(a_ChunkX, a_ChunkY, a_ChunkZ,true));
}
@ -226,11 +203,7 @@ void cWorldStorage::UnqueueLoad(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
void cWorldStorage::UnqueueSave(const cChunkCoords & a_Chunk)
{
{
cCSLock Lock(m_CSQueues);
m_SaveQueue.remove(a_Chunk);
}
m_evtRemoved.Set();
m_SaveQueue.Remove(a_Chunk);
}
@ -281,19 +254,19 @@ void cWorldStorage::Execute(void)
m_Event.Wait();
// Process both queues until they are empty again:
bool HasMore;
bool Success;
do
{
HasMore = false;
Success = false;
if (m_ShouldTerminate)
{
return;
}
HasMore = LoadOneChunk();
HasMore = HasMore | SaveOneChunk();
Success = LoadOneChunk();
Success |= SaveOneChunk();
m_evtRemoved.Set();
} while (HasMore);
} while (Success);
}
}
@ -304,19 +277,7 @@ void cWorldStorage::Execute(void)
bool cWorldStorage::LoadOneChunk(void)
{
sChunkLoad ToLoad(0, 0, 0, false);
bool HasMore;
bool ShouldLoad = false;
{
cCSLock Lock(m_CSQueues);
if (!m_LoadQueue.empty())
{
ToLoad = m_LoadQueue.front();
m_LoadQueue.pop_front();
ShouldLoad = true;
}
HasMore = !m_LoadQueue.empty();
}
bool ShouldLoad = m_LoadQueue.TryDequeueItem(ToLoad);
if (ShouldLoad && !LoadChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ))
{
if (ToLoad.m_Generate)
@ -330,7 +291,7 @@ bool cWorldStorage::LoadOneChunk(void)
// m_World->ChunkLoadFailed(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ);
}
}
return HasMore;
return ShouldLoad;
}
@ -339,33 +300,24 @@ bool cWorldStorage::LoadOneChunk(void)
bool cWorldStorage::SaveOneChunk(void)
{
cChunkCoords Save(0, 0, 0);
bool HasMore;
bool ShouldSave = false;
{
cCSLock Lock(m_CSQueues);
if (!m_SaveQueue.empty())
cChunkCoords ToSave(0, 0, 0);
bool ShouldSave = m_SaveQueue.TryDequeueItem(ToSave);
if(ShouldSave) {
if (ToSave.m_ChunkY == CHUNK_Y_MESSAGE)
{
Save = m_SaveQueue.front();
m_SaveQueue.pop_front();
ShouldSave = true;
LOGINFO("Saved all chunks in world %s", m_World->GetName().c_str());
return ShouldSave;
}
HasMore = !m_SaveQueue.empty();
}
if (Save.m_ChunkY == CHUNK_Y_MESSAGE)
{
LOGINFO("Saved all chunks in world %s", m_World->GetName().c_str());
return HasMore;
}
if (ShouldSave && m_World->IsChunkValid(Save.m_ChunkX, Save.m_ChunkZ))
{
m_World->MarkChunkSaving(Save.m_ChunkX, Save.m_ChunkZ);
if (m_SaveSchema->SaveChunk(Save))
if (ShouldSave && m_World->IsChunkValid(ToSave.m_ChunkX, ToSave.m_ChunkZ))
{
m_World->MarkChunkSaved(Save.m_ChunkX, Save.m_ChunkZ);
m_World->MarkChunkSaving(ToSave.m_ChunkX, ToSave.m_ChunkZ);
if (m_SaveSchema->SaveChunk(ToSave))
{
m_World->MarkChunkSaved(ToSave.m_ChunkX, ToSave.m_ChunkZ);
}
}
}
return HasMore;
return ShouldSave;
}

28
src/WorldStorage/WorldStorage.h
View File

@ -16,6 +16,7 @@
#include "../ChunkDef.h"
#include "../OSSupport/IsThread.h"
#include "../OSSupport/Queue.h"
@ -24,6 +25,8 @@
// fwd:
class cWorld;
typedef cQueue<cChunkCoords> cChunkCoordsQueue;
@ -78,8 +81,8 @@ public:
void WaitForFinish(void);
void WaitForQueuesEmpty(void);
int GetLoadQueueLength(void);
int GetSaveQueueLength(void);
size_t GetLoadQueueLength(void);
size_t GetSaveQueueLength(void);
protected:
@ -91,9 +94,24 @@ protected:
bool m_Generate; // If true, the chunk will be generated if it cannot be loaded
sChunkLoad(int a_ChunkX, int a_ChunkY, int a_ChunkZ, bool a_Generate) : m_ChunkX(a_ChunkX), m_ChunkY(a_ChunkY), m_ChunkZ(a_ChunkZ), m_Generate(a_Generate) {}
bool operator==(const sChunkLoad other) const
{
return this->m_ChunkX == other.m_ChunkX &&
this->m_ChunkY == other.m_ChunkY &&
this->m_ChunkZ == other.m_ChunkZ;
}
} ;
typedef std::list<sChunkLoad> sChunkLoadQueue;
struct FuncTable {
static void Delete(sChunkLoad) {};
static void Combine(sChunkLoad& a_orig, const sChunkLoad a_new)
{
a_orig.m_Generate |= a_new.m_Generate;
};
};
typedef cQueue<sChunkLoad,FuncTable> sChunkLoadQueue;
cWorld * m_World;
AString m_StorageSchemaName;
@ -101,7 +119,7 @@ protected:
// Both queues are locked by the same CS
cCriticalSection m_CSQueues;
sChunkLoadQueue m_LoadQueue;
cChunkCoordsList m_SaveQueue;
cChunkCoordsQueue m_SaveQueue;
cEvent m_Event; // Set when there's any addition to the queues
cEvent m_evtRemoved; // Set when an item has been removed from the queue, either by the worker thread or the Unqueue methods