C / C++ / MFC

// Increment the read pointer
UINT32 IncTheReadPtr(void);
// Increment the write pointer
UINT32 IncTheWritePtr(void);

federico.strati wrote:

#ifndef DOUBLE_BUFFER_H
#define DOUBLE_BUFFER_H

#include <afx.h>
#include <afxwin.h>

class CDoubleBuffer
{
public:
CDoubleBuffer( unsigned int unAlloc = 0x000FFFFF );
~CDoubleBuffer(void);

void Write(void* pBuf, unsigned int unBytesTo);
void Read (void* pBuf, unsigned int unBytesFrom);

private:
void** pAlloc;
unsigned int unRead;
unsigned int unWrite;
unsigned int unSize;
};

#endif // ! defined (DOUBLE_BUFFER_H)

volatile unsigned int unRead;   <br />
volatile unsigned int unWrite;

<br />
void CDoubleBuffer::Write(void* pBuf, unsigned int unBytesTo)<br />
{   <br />
//unsigned int unTryWrite = (unWrite++)%2;<br />
unsigned int unTryWrite = (unWrite+1)%2;<br />
while( unRead == unTryWrite ) { ::Sleep(10); }   <br />
::MoveMemory( pAlloc[unTryWrite], pBuf, __min(unBytesTo,unSize) );   <br />
unWrite = unTryWrite;<br />
}<br />
<br />
void CDoubleBuffer::Read(void* pBuf, unsigned int unBytesFrom)<br />
{   <br />
while( unRead == unWrite ) { ::Sleep(10); }   <br />
//unsigned int unTryRead = (unRead++)%2;<br />
unsigned int unTryRead = (unRead+1)%2;   <br />
::MoveMemory(pBuf, pAlloc[unTryRead], __min(unBytesFrom,unSize));   <br />
unRead = unTryRead;<br />
}<br />

federico.strati wrote:

Note:

1. it is necessary to declare the variables volatile on some systems
to prevent using cached values, you'll be fine by declaring all the
integer indexes unRead/unWrite etc... as volatile

2. the classes are thread safe for the single situation where you have a single
producer (writer) and a single consumer (reader) in different
threads. It is NOT safe for multiple consumers / multiple producers.

3. The modifs you've done are good even if don't understand why
you changed the way you increment the pointers
it is not important to increment pointers in an atomic manner
as there will be only two threads: one writer and one reader.
If you want atomicity then you shall use InterlockedIncrement
/ Decrement functions. But it is a wasted effort here.

Hope that helps

Cheers
Federico

void CDoubleBuffer::Write(void* pBuf, unsigned int unBytesTo)
{
   unsigned int unTryWrite = (unWrite+1)%2;
   while( unRead == unTryWrite ) { ::Sleep(10); }
   // use current unWrite !
   ::CopyMemory( pAlloc[unWrite], pBuf, __min(unBytesTo,unSize) );
   unWrite = unTryWrite;
}

void CDoubleBuffer::Read(void* pBuf, unsigned int unBytesFrom)
{
   while( unRead == unWrite ) { ::Sleep(10); }
   // use current unRead !
   ::CopyMemory(pBuf, pAlloc[unRead], __min(unBytesFrom,unSize));
   unRead = (unRead+1)%2;
}

TCPMem wrote:

What's the best way to find newline in char[]

#ifndef .....
#define

#endif

_MSC_VER > 1000

CPallini wrote:

They hide it inside the documentation.