C / C++ / MFC

Re: One genneral question on dual buffers design with multi-threading

15-Oct-10 1:40

You're speking of a technique called flip-flop double buffering:
while one thread writes data to one buffer, the other thread
reads from the second buffer, then you swap buffers and start again.

This is in fact a circular buffer with only two entries.

I attach here two classes, one for the double buffer, the other for the
n-buffer circular ring buffer, both of them may be used to solve the
communication problem between the two threads.

Note that the circular buffer works with pointers to buffers that you
allocate and free outside the buffer itself, while the double buffer
works with copying data from outside buffers to buffers preallocate
inside it.

You may also wish to get a read of the article:
Lock-Free Single-Producer - Single Consumer Circular Queue for the circular ring buffer

--- double buffer include ---

#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)

--- double buffer include end ---

--- double buffer body ---

#include "stdafx.h"
#include "DoubleBuffer.h"

CDoubleBuffer::CDoubleBuffer( unsigned int unAlloc /* = 0x000FFFFF */ )
{
   pAlloc = NULL;
   pAlloc = (void **) ::HeapAlloc(::GetProcessHeap(), 0, 2 * sizeof(void*));
   if (!pAlloc) throw;
   pAlloc[0] = NULL;
   pAlloc[0] = (void *) ::HeapAlloc(::GetProcessHeap(), 0, unAlloc * sizeof(BYTE));
   if (!pAlloc[0]) throw;
   pAlloc[1] = NULL;
   pAlloc[1] = (void *) ::HeapAlloc(::GetProcessHeap(), 0, unAlloc * sizeof(BYTE));
   if (!pAlloc[1]) throw;
   ::FillMemory((void*) pAlloc[0], unAlloc, 0);
   ::FillMemory((void*) pAlloc[1], unAlloc, 0);

   unRead  = 0;
   unWrite = 0;
   unSize = unAlloc;
}

CDoubleBuffer::~CDoubleBuffer(void)
{
   ::HeapFree(::GetProcessHeap(), 0, pAlloc[0]);
   ::HeapFree(::GetProcessHeap(), 0, pAlloc[1]);
   ::HeapFree(::GetProcessHeap(), 0, pAlloc);
}

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

void CDoubleBuffer::Read(void* pBuf, unsigned int unBytesFrom)
{
   while( unRead == unWrite ) { ::Sleep(10); }
   unsigned int unTryRead = (unRead++)%2;
   ::MoveMemory(pBuf, pAlloc[unTryRead], __min(unBytesFrom,unSize));
   unRead = unTryRead;
}

--- double buffer body end ---

--- circular buffer include ---

// Light Weight Circular Buffer with elementary locking

#ifndef CBUFFER_H
#define CBUFFER_H

#if _MSC_VER > 1000
#pragma warning (disable: 4786)
#pragma warning (disable: 4748)
#pragma warning (disable: 4103)
#endif /* _MSC_VER > 1000 */

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

// Default number of elements in buffer
#define CBUFFER_NELEM		      0x0000FFFF

// The Circular Buffer errors
#define CBUFFER_ERRCODE_OK               0
#define CBUFFER_ERRCODE_NO_MEMORY        1
#define CBUFFER_ERRCODE_READ_ERROR       2
#define CBUFFER_ERRCODE_WRITE_ERROR      3
#define CBUFFER_ERRCODE_NO_DATA          4

#define CBUFFER_NULL_PTR                 0xFFFFFFFF

class CCircBuffer
{
// Constructors, Destructor
public:
   CCircBuffer(UINT32 unElements = CBUFFER_NELEM);
   ~CCircBuffer(void);

// Operations
public:
   // Read  the data
   UINT32 GetTheData(void*& lpData);
   // Write the data
   UINT32 SetTheData(void*  lpData);
   // Increment the read pointer
   UINT32 IncTheReadPtr(void);
   // Increment the write pointer
   UINT32 IncTheWritePtr(void);
   // Check if there is any space for reading data
   bool IsReadyForRead(void);
   // Check if there is any space for writing new data
   bool IsReadyForWrite(void);
   // Get the last known value for the read pointer
   UINT32 GetLastReadPtr(void);
   // Get the last known value for the write pointer
   UINT32 GetLastWritePtr(void);

// Attributes
private:
   // The Circular Buffer of void pointers
   void**  TheCircularBuffer;
   SIZE_T unElems;
   // The Circular Buffer pointers
   UINT32 unReadPtr, unWritePtr;
   // The Circular Buffer last error
   UINT32 unLastErrorCode;
};

#endif /* ! defined(CBUFFER_H) */

--- circular buffer include end ---

--- circular buffer body ---

#include "StdAfx.h"
#include "CircBuffer.h"

CCircBuffer::CCircBuffer(UINT32 unElements /* = CBUFFER_NELEM */)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   // Allocate the Buffer
   unElems = (SIZE_T) unElements;
   if ( unElems >= CBUFFER_NULL_PTR ) // max size
      unElems = CBUFFER_NULL_PTR - 1;
   TheCircularBuffer = (void **) HeapAlloc(GetProcessHeap(), 0, unElems * sizeof(void*));
   // Cannot allocate memory
   if(!TheCircularBuffer)
   {
      unLastErrorCode = CBUFFER_ERRCODE_NO_MEMORY;
   }
   else
   {
      SecureZeroMemory(TheCircularBuffer, sizeof(TheCircularBuffer));
   }
   // Set Pointers
   unReadPtr = unWritePtr = 0;
}

CCircBuffer::~CCircBuffer(void)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   BOOL bResult = HeapFree(GetProcessHeap(), 0, TheCircularBuffer);
   if( bResult != TRUE )
   {
      unLastErrorCode = CBUFFER_ERRCODE_NO_MEMORY;
   }
}

// Operations

// Read the data
UINT32 CCircBuffer::GetTheData(void*& lpData)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   // Check if there is any data to be read in the buffer
   if( ! IsReadyForRead() )
   {
      // No data to be read in buffer
      unLastErrorCode = CBUFFER_ERRCODE_NO_DATA;
      return CBUFFER_NULL_PTR;
   }
   // Get the data
   lpData = (void*) TheCircularBuffer[unReadPtr];
   // Increment the read pointer
   unReadPtr++;
   if( unReadPtr >= unElems )
      unReadPtr = 0;	// Restart
   return unReadPtr;
}

// Write the data
UINT32 CCircBuffer::SetTheData(void* lpData)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   // Check if there is any way of writing the data
   if( ! IsReadyForWrite() )
   {
      // No way to write data in Buffer
      unLastErrorCode = CBUFFER_ERRCODE_NO_DATA;
      return CBUFFER_NULL_PTR;
   }
   // Set the data
   TheCircularBuffer[unWritePtr] = (void*) lpData;
   // Increment the write pointer
   unWritePtr++;
   if( unWritePtr >= unElems )
      unWritePtr = 0; // Restart
   return unWritePtr;
}

// Increment the read pointer
UINT32 CCircBuffer::IncTheReadPtr(void)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   // Check if there is any data to be read in the buffer
   if ( ! IsReadyForRead() )
   {
      // No data available to be read
      unLastErrorCode = CBUFFER_ERRCODE_NO_DATA;
      return CBUFFER_NULL_PTR;
   }
   // Increment the read pointer
   unReadPtr++;
   if( unReadPtr >= unElems )
      unReadPtr = 0; // restart
   return unReadPtr;
}

// Increment the write pointer
UINT32 CCircBuffer::IncTheWritePtr(void)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   // Checks if there is any way of writing the data
   if( ! IsReadyForWrite() )
   {
      // No way to write data
      unLastErrorCode = CBUFFER_ERRCODE_NO_DATA;
      return CBUFFER_NULL_PTR;
   }
   // Increment the write pointer
   unWritePtr++;
   if( unWritePtr >= unElems )
      unWritePtr = 0; // restart
   return unWritePtr;
}

// Check if there is any way of reading the data
bool CCircBuffer::IsReadyForRead(void)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   // Check if there is any way of reading the data
   // The test pointer
   UINT32 unCheckReadPtr = unReadPtr;
   if( unCheckReadPtr >= unElems )
      unCheckReadPtr = 0;	// Restart
   if( unCheckReadPtr == unWritePtr )
   {
      // No way to read data
      unLastErrorCode = CBUFFER_ERRCODE_NO_DATA;
      return false;
   }
   return true;
}

// Check if there is any space for writing new data
bool CCircBuffer::IsReadyForWrite(void)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   // Checks if there is any way of writing the data
   // Increment the test pointer
   UINT32 unCheckWritePtr = unWritePtr;
   unCheckWritePtr++;
   if( unCheckWritePtr >= unElems )
      unCheckWritePtr = 0;	// Restart
   if( unCheckWritePtr == unReadPtr )
   {
      // No way to write data
      unLastErrorCode = CBUFFER_ERRCODE_NO_DATA;
      return false;
   }
   return true;
}

// Get the last known value for the read pointer
UINT32 CCircBuffer::GetLastReadPtr(void)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   return unReadPtr;
}

// Get the last known value for the write pointer
UINT32 CCircBuffer::GetLastWritePtr(void)
{
   unLastErrorCode = CBUFFER_ERRCODE_OK;
   return unWritePtr;
}

--- circular buffer body end ---

Hope that helps

Cheers
Federico

federico-strati [at] libero [dot] it

SAMZC15-Oct-10 20:51

SAMZC

15-Oct-10 20:51

Ohh...Great.Thanks to Federico.
It really what I want to say... I am not sure whether it is good soluiton with double buffers working in circular way in my case.
----------------------------------------------------
>>You're speking of a technique called flip-flop double buffering:
>>while one thread writes data to one buffer, the other thread
>>reads from the second buffer, then you swap buffers and start again.
>>This is in fact a circular buffer with only two entries.
----------------------------------------------------

Thanks, Federico. I am studying your posted codes here.

The world is fine.

Re: One genneral question on dual buffers design with multi-threading

SAMZCN15-Oct-10 23:31

SAMZCN

15-Oct-10 23:31

I read the CDoubleBuffer class you write. It's a very good implementation on the double buffer usage. Here I have some questions on the buffer class. Would you please give some comments?Thanks in advance.
1. Is it thread-safe of CDoubleBuffer? In Read/Write function, each of them will access the target buffer.If in multi-thread case, the reader thread will use Read() and the writer thread will use Write() simutaneously. Both of the function will access unRead/unWrite variables. Is it necessary to declare the variable with key word of volatile?
2. About the CCircBuffer, I have the same question of CDoubleBuffer. Besides, what's the purpose of the following two functions?

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

From the implemention of the two funcitons, I see it does nothing except only increasing the pointer. And the pointer increasement has been done in GetTheData()/SetTheData() functions.

Appreciated for your share. It's very usefull for me to understand the problem of my case furthermore. And I get big confidence to start my job on this case.

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)

Re: One genneral question on dual buffers design with multi-threading

federico.strati17-Oct-10 20:45

Re: One genneral question on dual buffers design with multi-threading

17-Oct-10 20:45

Answers:

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 two functions IncTheReadPtr(void) and IncTheWritePtr(void) are there
only if you want to skip some entries in the circular buffer in reading
or writing for some particular reason you know.

Hope that helps

Cheers
Federico

SAMZC16-Oct-10 7:57

SAMZC

16-Oct-10 7:57

Two changes on the code to make an ATOM operation.And seems that the following declaration should be declared as volatile.

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 />

If any error, please make me know.Thanks. Good job.

The world is fine.

Re: One genneral question on dual buffers design with multi-threading

federico.strati17-Oct-10 20:50

Re: One genneral question on dual buffers design with multi-threading

17-Oct-10 20:50

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 Smile | :)

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

SAMZCN18-Oct-10 2:16

SAMZCN

18-Oct-10 2:16

Hello Federico,

Thanks for your great help. It makes me clear on the problems I met recently.
Many many thanks for your kind help. Big Grin | :-D

Sam/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

Re: One genneral question: there were errors in my code !!!

federico.strati19-Oct-10 22:25

Hello calling function between two different processes

19-Oct-10 22:25

here you find the revised version of double buffer,
there were errors in my code, sorry!

-----------

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;
}

-----------

nah133714-Oct-10 22:42

nah1337

14-Oct-10 22:42

Well i looked a solution to call function from a process that is complitly different from another process so i readed about Interprocess Communication. Now i have only seen some data moving data copying and some text show up tutorials but there is nothing about how to call a function from another process can anyone point me somewhere...?

Re: Hello calling function between two different processes

CPallini14-Oct-10 22:47

Re: Hello calling function between two different processes

14-Oct-10 22:47

Check out Remote Procedure Call at MSDN. It's a tough topic, however.
Smile | :)

If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.

This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke

[My articles]

Rajesh R Subramanian15-Oct-10 0:52

Rajesh R Subramanian

15-Oct-10 0:52

You could use any of the IPC mechanisms to send a 'notification' from one process to another. The other process should handle this notification and execute code appropriately.

See here for an example: http://www.flounder.com/messages.htm[^]

There are some really weird people on this planet - MIM.

Encrypt / Decrypt a file

mesajflaviu14-Oct-10 21:51

mesajflaviu

14-Oct-10 21:51

In MFC it can be encrypted / decrypted a file ( any kind of file , ex. rar , mp3 , psd , avi ) ?

Re: Encrypt / Decrypt a file

CPallini14-Oct-10 22:32

14-Oct-10 22:32

See Encrypting and Decrypting at MSDN.
Smile | :)

string question

sadas232341s14-Oct-10 8:20

sadas232341s

14-Oct-10 8:20

What's the best way to find newline in char[] str and put text after this line?

Luc Pattyn14-Oct-10 8:36

Luc Pattyn

14-Oct-10 8:36

what language? C? C++? MFC? what kind of string? isn't there some documentation on the language and strings you are using?

Smile | :)

Luc Pattyn [Forum Guidelines] [Why QA sucks] [My Articles] Nil Volentibus Arduum

Please use <PRE> tags for code snippets, they preserve indentation, and improve readability.

David Crow14-Oct-10 9:15

David Crow

14-Oct-10 9:15

"Best" is a subjective term and only you can answer what is best for your situation. Have you looked at strchr()?

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"Man who follows car will be exhausted." - Confucius

CPallini14-Oct-10 9:27

14-Oct-10 9:27

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

Searching for.

Roll eyes | :rolleyes:

Luc Pattyn14-Oct-10 9:34

Luc Pattyn

14-Oct-10 9:34

you mean Google? Bing? Baidu?

Smile | :)

Luc Pattyn [Forum Guidelines] [Why QA sucks] [My Articles] Nil Volentibus Arduum

Please use <PRE> tags for code snippets, they preserve indentation, and improve readability.

CPallini14-Oct-10 9:39

what does these lines mean??

14-Oct-10 9:39

No, I meant, you know, for, if, ...
Smile | :)

AmbiguousName14-Oct-10 3:42

AmbiguousName

14-Oct-10 3:42

hello guys... what does these three lines of code mean...thnx

#if _MSC_VER > 1000
#pragma once
#endif

Cedric Moonen14-Oct-10 3:56

Cedric Moonen

14-Oct-10 3:56

#pragma once is an include guard: the file will be included only once. This is similar has having the text in the file wrapped into a

#ifndef .....
#define

#endif

section.

I think this pragma was not available in the first versions of the compiler (_MSC_VER), that is why it is wrapped into the #if/#endif section.

Cédric Moonen
Software developer

Charting control [v3.0]
OpenGL game tutorial in C++

AmbiguousName14-Oct-10 4:08

AmbiguousName

14-Oct-10 4:08

and what is this??

_MSC_VER > 1000

Cedric Moonen14-Oct-10 4:15

Cedric Moonen

14-Oct-10 4:15

If the compiler version is higher than version 10 (not sure, you have to google to see how the versions are encoded), then the pragma is used.

Cédric Moonen
Software developer

Charting control [v3.0]
OpenGL game tutorial in C++