mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-09-24 05:30:32 +00:00
713 lines
14 KiB
C++
713 lines
14 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "stdmisc.h"
|
|
#include "nel/misc/time_nl.h"
|
|
#include "nel/misc/command.h"
|
|
#include "nel/misc/buf_fifo.h"
|
|
|
|
using namespace std;
|
|
|
|
#define DEBUG_FIFO 0
|
|
|
|
// if 0, don't stat the time of different function
|
|
#define STAT_FIFO 1
|
|
|
|
namespace NLMISC {
|
|
|
|
#ifdef BUFFIFO_TRACK_ALL_BUFFERS
|
|
CBufFIFO::TAllBuffers CBufFIFO::_AllBuffers;
|
|
#endif
|
|
|
|
|
|
CBufFIFO::CBufFIFO() : _Buffer(NULL), _BufferSize(0), _Empty(true), _Head(NULL), _Tail(NULL), _Rewinder(NULL)
|
|
{
|
|
#ifdef BUFFIFO_TRACK_ALL_BUFFERS
|
|
_AllBuffers.insert(this);
|
|
#endif
|
|
|
|
// reset statistic
|
|
_BiggestBlock = 0;
|
|
_SmallestBlock = 999999999;
|
|
_BiggestBuffer = 0;
|
|
_SmallestBuffer = 999999999;
|
|
_Pushed = 0;
|
|
_Fronted = 0;
|
|
_Resized = 0;
|
|
_PushedTime = 0;
|
|
_FrontedTime = 0;
|
|
_ResizedTime = 0;
|
|
}
|
|
|
|
CBufFIFO::~CBufFIFO()
|
|
{
|
|
#ifdef BUFFIFO_TRACK_ALL_BUFFERS
|
|
_AllBuffers.erase(this);
|
|
#endif
|
|
|
|
if (_Buffer != NULL)
|
|
{
|
|
delete []_Buffer;
|
|
#if DEBUG_FIFO
|
|
nldebug("%p delete", this);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void CBufFIFO::push (const uint8 *buffer, uint32 s)
|
|
{
|
|
// if the buffer is more than 1 meg, there s surely a problem, no?
|
|
// nlassert( buffer.size() < 1000000 ); // size check in debug mode
|
|
|
|
#if STAT_FIFO
|
|
TTicks before = CTime::getPerformanceTime();
|
|
#endif
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p push(%d)", this, s);
|
|
#endif
|
|
|
|
nlassert(s > 0 && s < pow(2.0, static_cast<double>(sizeof(TFifoSize)*8)));
|
|
|
|
// stat code
|
|
if (s > _BiggestBlock) _BiggestBlock = s;
|
|
if (s < _SmallestBlock) _SmallestBlock = s;
|
|
_Pushed++;
|
|
|
|
while (!canFit (s + sizeof (TFifoSize)))
|
|
{
|
|
resize(_BufferSize * 2);
|
|
}
|
|
|
|
*(TFifoSize *)_Head = s;
|
|
_Head += sizeof(TFifoSize);
|
|
|
|
CFastMem::memcpy(_Head, buffer, s);
|
|
|
|
_Head += s;
|
|
|
|
_Empty = false;
|
|
|
|
#if STAT_FIFO
|
|
// stat code
|
|
TTicks after = CTime::getPerformanceTime();
|
|
_PushedTime += after - before;
|
|
#endif
|
|
|
|
#if DEBUG_FIFO
|
|
display ();
|
|
#endif
|
|
}
|
|
|
|
void CBufFIFO::push(const std::vector<uint8> &buffer1, const std::vector<uint8> &buffer2)
|
|
{
|
|
#if STAT_FIFO
|
|
TTicks before = CTime::getPerformanceTime();
|
|
#endif
|
|
|
|
TFifoSize s = (TFifoSize)(buffer1.size() + buffer2.size());
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p push2(%d)", this, s);
|
|
#endif
|
|
|
|
nlassert((buffer1.size() + buffer2.size ()) > 0 && (buffer1.size() + buffer2.size ()) < pow(2.0, static_cast<double>(sizeof(TFifoSize)*8)));
|
|
|
|
// avoid too big fifo
|
|
if (this->size() > 10000000)
|
|
{
|
|
throw Exception ("CBufFIFO::push(): stack full (more than 10mb)");
|
|
}
|
|
|
|
|
|
// stat code
|
|
if (s > _BiggestBlock) _BiggestBlock = s;
|
|
if (s < _SmallestBlock) _SmallestBlock = s;
|
|
|
|
_Pushed++;
|
|
|
|
// resize while the buffer is enough big to accept the block
|
|
while (!canFit (s + sizeof (TFifoSize)))
|
|
{
|
|
resize(_BufferSize * 2);
|
|
}
|
|
|
|
// store the size of the block
|
|
*(TFifoSize *)_Head = s;
|
|
_Head += sizeof(TFifoSize);
|
|
|
|
// store the block itself
|
|
CFastMem::memcpy(_Head, &(buffer1[0]), buffer1.size());
|
|
CFastMem::memcpy(_Head + buffer1.size(), &(buffer2[0]), buffer2.size());
|
|
_Head += s;
|
|
|
|
_Empty = false;
|
|
|
|
#if STAT_FIFO
|
|
// stat code
|
|
TTicks after = CTime::getPerformanceTime();
|
|
_PushedTime += after - before;
|
|
#endif
|
|
|
|
#if DEBUG_FIFO
|
|
display ();
|
|
#endif
|
|
}
|
|
|
|
void CBufFIFO::pop ()
|
|
{
|
|
if (empty ())
|
|
{
|
|
nlwarning("BF: Try to pop an empty fifo!");
|
|
return;
|
|
}
|
|
|
|
if (_Rewinder != NULL && _Tail == _Rewinder)
|
|
{
|
|
#if DEBUG_FIFO
|
|
nldebug("%p pop rewind!", this);
|
|
#endif
|
|
|
|
// need to rewind
|
|
_Tail = _Buffer;
|
|
_Rewinder = NULL;
|
|
}
|
|
|
|
TFifoSize s = *(TFifoSize *)_Tail;
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p pop(%d)", this, s);
|
|
#endif
|
|
|
|
#ifdef NL_DEBUG
|
|
// clear the message to be sure user doesn't use it anymore
|
|
memset (_Tail, '-', s + sizeof (TFifoSize));
|
|
#endif
|
|
|
|
_Tail += s + sizeof (TFifoSize);
|
|
|
|
if (_Tail == _Head) _Empty = true;
|
|
|
|
#if DEBUG_FIFO
|
|
display ();
|
|
#endif
|
|
}
|
|
|
|
uint8 CBufFIFO::frontLast ()
|
|
{
|
|
uint8 *tail = _Tail;
|
|
|
|
if (empty ())
|
|
{
|
|
nlwarning("BF: Try to get the front of an empty fifo!");
|
|
return 0;
|
|
}
|
|
|
|
if (_Rewinder != NULL && tail == _Rewinder)
|
|
{
|
|
#if DEBUG_FIFO
|
|
nldebug("%p front rewind!", this);
|
|
#endif
|
|
|
|
// need to rewind
|
|
tail = _Buffer;
|
|
}
|
|
|
|
TFifoSize s = *(TFifoSize *)tail;
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p frontLast() returns %d ", this, s, *(tail+sizeof(TFifoSize)+size-1));
|
|
#endif
|
|
|
|
return *(tail+sizeof(TFifoSize)+s-1);
|
|
}
|
|
|
|
|
|
void CBufFIFO::front (vector<uint8> &buffer)
|
|
{
|
|
uint8 *tmpbuffer;
|
|
uint32 s;
|
|
|
|
buffer.clear ();
|
|
|
|
front (tmpbuffer, s);
|
|
|
|
buffer.resize (s);
|
|
|
|
CFastMem::memcpy (&(buffer[0]), tmpbuffer, s);
|
|
|
|
/* TTicks before = CTime::getPerformanceTime ();
|
|
|
|
uint8 *tail = _Tail;
|
|
|
|
buffer.clear ();
|
|
|
|
if (empty ())
|
|
{
|
|
nlwarning("Try to get the front of an empty fifo!");
|
|
return;
|
|
}
|
|
|
|
_Fronted++;
|
|
|
|
if (_Rewinder != NULL && tail == _Rewinder)
|
|
{
|
|
#if DEBUG_FIFO
|
|
nldebug("%p front rewind!", this);
|
|
#endif
|
|
|
|
// need to rewind
|
|
tail = _Buffer;
|
|
}
|
|
|
|
TFifoSize size = *(TFifoSize *)tail;
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p front(%d)", this, size);
|
|
#endif
|
|
|
|
tail += sizeof (TFifoSize);
|
|
|
|
buffer.resize (size);
|
|
|
|
CFastMem::memcpy (&(buffer[0]), tail, size);
|
|
|
|
// stat code
|
|
TTicks after = CTime::getPerformanceTime ();
|
|
_FrontedTime += after - before;
|
|
|
|
#if DEBUG_FIFO
|
|
display ();
|
|
#endif
|
|
*/}
|
|
|
|
|
|
void CBufFIFO::front (NLMISC::CMemStream &buffer)
|
|
{
|
|
uint8 *tmpbuffer;
|
|
uint32 s;
|
|
|
|
buffer.clear ();
|
|
|
|
front (tmpbuffer, s);
|
|
|
|
buffer.fill (tmpbuffer, s);
|
|
|
|
/*
|
|
TTicks before = CTime::getPerformanceTime ();
|
|
|
|
uint8 *tail = _Tail;
|
|
|
|
buffer.clear ();
|
|
|
|
if (empty ())
|
|
{
|
|
nlwarning("Try to get the front of an empty fifo!");
|
|
return;
|
|
}
|
|
|
|
_Fronted++;
|
|
|
|
if (_Rewinder != NULL && tail == _Rewinder)
|
|
{
|
|
#if DEBUG_FIFO
|
|
nldebug("%p front rewind!", this);
|
|
#endif
|
|
|
|
// need to rewind
|
|
tail = _Buffer;
|
|
}
|
|
|
|
TFifoSize size = *(TFifoSize *)tail;
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p front(%d)", this, size);
|
|
#endif
|
|
|
|
tail += sizeof (TFifoSize);
|
|
|
|
//buffer.resize (size);
|
|
//CFastMem::memcpy (&(buffer[0]), tail, size);
|
|
|
|
buffer.fill (tail, size);
|
|
|
|
// stat code
|
|
TTicks after = CTime::getPerformanceTime ();
|
|
_FrontedTime += after - before;
|
|
|
|
#if DEBUG_FIFO
|
|
display ();
|
|
#endif*/
|
|
}
|
|
|
|
void CBufFIFO::front (uint8 *&buffer, uint32 &s)
|
|
{
|
|
#if STAT_FIFO
|
|
TTicks before = CTime::getPerformanceTime ();
|
|
#endif
|
|
|
|
uint8 *tail = _Tail;
|
|
|
|
if (empty ())
|
|
{
|
|
nlwarning("BF: Try to get the front of an empty fifo!");
|
|
return;
|
|
}
|
|
|
|
_Fronted++;
|
|
|
|
if (_Rewinder != NULL && tail == _Rewinder)
|
|
{
|
|
#if DEBUG_FIFO
|
|
nldebug("%p front rewind!", this);
|
|
#endif
|
|
|
|
// need to rewind
|
|
tail = _Buffer;
|
|
}
|
|
|
|
s = *(TFifoSize *)tail;
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p front(%d)", this, s);
|
|
#endif
|
|
|
|
tail += sizeof (TFifoSize);
|
|
|
|
#if STAT_FIFO
|
|
// stat code
|
|
TTicks after = CTime::getPerformanceTime ();
|
|
_FrontedTime += after - before;
|
|
#endif
|
|
|
|
#if DEBUG_FIFO
|
|
display ();
|
|
#endif
|
|
|
|
buffer = tail;
|
|
}
|
|
|
|
|
|
|
|
void CBufFIFO::clear ()
|
|
{
|
|
_Tail = _Head = _Buffer;
|
|
_Rewinder = NULL;
|
|
_Empty = true;
|
|
}
|
|
|
|
uint32 CBufFIFO::size ()
|
|
{
|
|
if (empty ())
|
|
{
|
|
return 0;
|
|
}
|
|
else if (_Head == _Tail)
|
|
{
|
|
// buffer is full
|
|
if (_Rewinder == NULL)
|
|
return _BufferSize;
|
|
else
|
|
return (uint32)(_Rewinder - _Buffer);
|
|
}
|
|
else if (_Head > _Tail)
|
|
{
|
|
return (uint32)(_Head - _Tail);
|
|
}
|
|
else if (_Head < _Tail)
|
|
{
|
|
nlassert (_Rewinder != NULL);
|
|
return (uint32)((_Rewinder - _Tail) + (_Head - _Buffer));
|
|
}
|
|
nlstop;
|
|
return 0;
|
|
}
|
|
|
|
void CBufFIFO::resize (uint32 s)
|
|
{
|
|
#if STAT_FIFO
|
|
TTicks before = CTime::getPerformanceTime();
|
|
#endif
|
|
|
|
if (s == 0) s = 100;
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p resize(%d)", this, s);
|
|
#endif
|
|
|
|
if (s > _BiggestBuffer) _BiggestBuffer = s;
|
|
if (s < _SmallestBuffer) _SmallestBuffer = s;
|
|
|
|
_Resized++;
|
|
|
|
uint32 UsedSize = CBufFIFO::size();
|
|
|
|
// create a new array and copy the old in the new one
|
|
if (s < _BufferSize && UsedSize > s)
|
|
{
|
|
// problem, we don't have enough room for putting data => don't do it
|
|
nlwarning("BF: Can't resize the FIFO because there's not enough room in the new wanted buffer (%d bytes needed at least)", UsedSize);
|
|
return;
|
|
}
|
|
|
|
uint8 *NewBuffer = new uint8[s];
|
|
if (NewBuffer == NULL)
|
|
{
|
|
nlerror("Not enough memory to resize the FIFO to %u bytes", s);
|
|
}
|
|
#ifdef NL_DEBUG
|
|
// clear the message to be sure user doesn't use it anymore
|
|
memset (NewBuffer, '-', s);
|
|
#endif
|
|
|
|
#if DEBUG_FIFO
|
|
nldebug("%p new %d bytes", this, s);
|
|
#endif
|
|
|
|
// copy the old buffer to the new one
|
|
// if _Tail == _Head => empty fifo, don't copy anything
|
|
if (!empty())
|
|
{
|
|
if (_Tail < _Head)
|
|
{
|
|
CFastMem::memcpy (NewBuffer, _Tail, UsedSize);
|
|
}
|
|
else if (_Tail >= _Head)
|
|
{
|
|
nlassert (_Rewinder != NULL);
|
|
|
|
uint size1 = (uint)(_Rewinder - _Tail);
|
|
CFastMem::memcpy (NewBuffer, _Tail, size1);
|
|
uint size2 = (uint)(_Head - _Buffer);
|
|
CFastMem::memcpy (NewBuffer + size1, _Buffer, size2);
|
|
|
|
nlassert (size1+size2==UsedSize);
|
|
}
|
|
}
|
|
|
|
// resync the circular pointer
|
|
// Warning: don't invert these 2 lines position or it ll not work
|
|
_Tail = NewBuffer;
|
|
_Head = NewBuffer + UsedSize;
|
|
_Rewinder = NULL;
|
|
|
|
// delete old buffer if needed
|
|
if (_Buffer != NULL)
|
|
{
|
|
delete []_Buffer;
|
|
#if DEBUG_FIFO
|
|
nldebug ("delete", this);
|
|
#endif
|
|
}
|
|
|
|
// affect new buffer
|
|
_Buffer = NewBuffer;
|
|
_BufferSize = s;
|
|
|
|
#if STAT_FIFO
|
|
TTicks after = CTime::getPerformanceTime();
|
|
_ResizedTime += after - before;
|
|
#endif
|
|
|
|
#if DEBUG_FIFO
|
|
display ();
|
|
#endif
|
|
}
|
|
|
|
void CBufFIFO::displayStats (CLog *log)
|
|
{
|
|
log->displayNL ("%p CurrentQueueSize: %d, TotalQueueSize: %d", this, size(), _BufferSize);
|
|
log->displayNL ("%p InQueue: %d", this, _Pushed - _Fronted);
|
|
|
|
log->displayNL ("%p BiggestBlock: %d, SmallestBlock: %d", this, _BiggestBlock, _SmallestBlock);
|
|
log->displayNL ("%p BiggestBuffer: %d, SmallestBuffer: %d", this, _BiggestBuffer, _SmallestBuffer);
|
|
log->displayNL ("%p Pushed: %d, PushedTime: total %"NL_I64"d ticks, mean %f ticks", this, _Pushed, _PushedTime, (_Pushed>0?(double)(sint64)_PushedTime / (double)_Pushed:0.0));
|
|
log->displayNL ("%p Fronted: %d, FrontedTime: total %"NL_I64"d ticks, mean %f ticks", this, _Fronted, _FrontedTime, (_Fronted>0?(double)(sint64)_FrontedTime / (double)_Fronted:0.0));
|
|
log->displayNL ("%p Resized: %d, ResizedTime: total %"NL_I64"d ticks, mean %f ticks", this, _Resized, _ResizedTime, (_Resized>0?(double)(sint64)_ResizedTime / (double)_Resized:0.0));
|
|
}
|
|
|
|
void CBufFIFO::display ()
|
|
{
|
|
int s = 64;
|
|
int gran = s/30;
|
|
|
|
char str[1024];
|
|
|
|
smprintf(str, 1024, "%p %p (%5d %5d) %p %p %p ", this, _Buffer, _BufferSize, CBufFIFO::size(), _Rewinder, _Tail, _Head);
|
|
|
|
int i;
|
|
for (i = 0; i < (sint32) _BufferSize; i+= gran)
|
|
{
|
|
uint8 *pos = _Buffer + i;
|
|
if (_Tail >= pos && _Tail < pos + gran)
|
|
{
|
|
if (_Head >= pos && _Head < pos + gran)
|
|
{
|
|
if (_Rewinder != NULL && _Rewinder >= pos && _Rewinder < pos + gran)
|
|
{
|
|
strncat (str, "*", 1);
|
|
}
|
|
else
|
|
{
|
|
strncat (str, "@", 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strncat (str, "T", 1);
|
|
}
|
|
}
|
|
else if (_Head >= pos && _Head < pos + gran)
|
|
{
|
|
strncat (str, "H", 1);
|
|
}
|
|
else if (_Rewinder != NULL && _Rewinder >= pos && _Rewinder < pos + gran)
|
|
{
|
|
strncat (str, "R", 1);
|
|
}
|
|
else
|
|
{
|
|
if (strlen(str) < 1023)
|
|
{
|
|
uint32 p = (uint32)strlen(str);
|
|
if (isprint(*pos))
|
|
str[p] = *pos;
|
|
else
|
|
str[p] = '$';
|
|
|
|
str[p+1] = '\0';
|
|
}
|
|
}
|
|
}
|
|
|
|
for (; i < s; i+= gran)
|
|
{
|
|
strncat (str, " ", 1);
|
|
}
|
|
#ifdef NL_DEBUG
|
|
strncat (str, "\n", 1);
|
|
#else
|
|
strncat (str, "\r", 1);
|
|
#endif
|
|
DebugLog->display (str);
|
|
}
|
|
|
|
bool CBufFIFO::canFit (uint32 s)
|
|
{
|
|
if (_Tail == _Head)
|
|
{
|
|
if (empty())
|
|
{
|
|
// is the buffer large enough?
|
|
if (_BufferSize >= s)
|
|
{
|
|
// reset the pointer
|
|
#if DEBUG_FIFO
|
|
nldebug("%p reset tail and head", this);
|
|
#endif
|
|
_Head = _Tail = _Buffer;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// buffer not big enough
|
|
#if DEBUG_FIFO
|
|
nldebug("%p buffer full buffersize<size", this);
|
|
#endif
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// buffer full
|
|
#if DEBUG_FIFO
|
|
nldebug("%p buffer full h=t", this);
|
|
#endif
|
|
return false;
|
|
}
|
|
}
|
|
else if (_Tail < _Head)
|
|
{
|
|
if (_Buffer + _BufferSize - _Head >= (sint32) s)
|
|
{
|
|
// can fit after _Head
|
|
#if DEBUG_FIFO
|
|
nldebug("%p fit after", this);
|
|
#endif
|
|
return true;
|
|
}
|
|
else if (_Tail - _Buffer >= (sint32) s)
|
|
{
|
|
// can fit at the beginning
|
|
#if DEBUG_FIFO
|
|
nldebug("%p fit at beginning", this);
|
|
#endif
|
|
_Rewinder = _Head;
|
|
#if DEBUG_FIFO
|
|
nldebug("%p set the rewinder", this);
|
|
#endif
|
|
_Head = _Buffer;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// can't fit
|
|
#if DEBUG_FIFO
|
|
nldebug("%p no room t<h", this);
|
|
#endif
|
|
return false;
|
|
}
|
|
}
|
|
else // the last case is : if (_Tail > _Head)
|
|
{
|
|
if (_Tail - _Head >= (sint32) s)
|
|
{
|
|
#if DEBUG_FIFO
|
|
nldebug("%p fit t>h", this);
|
|
#endif
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
#if DEBUG_FIFO
|
|
nldebug("%p no room t>h", this);
|
|
#endif
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef BUFFIFO_TRACK_ALL_BUFFERS
|
|
NLMISC_CATEGORISED_COMMAND(misc, dumpAllBuffers, "Dump all the fifo buffer", "no args")
|
|
{
|
|
log.displayNL("Dumping %u FIFO buffers :", CBufFIFO::_AllBuffers.size());
|
|
|
|
CBufFIFO::TAllBuffers::iterator first(CBufFIFO::_AllBuffers.begin()), last(CBufFIFO::_AllBuffers.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CBufFIFO *buf = *first;
|
|
|
|
log.displayNL("Dumping buffer %p:", buf);
|
|
|
|
buf->displayStats(&log);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
|
|
} // NLMISC
|