Buffer Queue class of fixed size memory block and C + + implementation source code

--------------------------------------------------------------------------------
Title: Buffer Queue Class of fixed size memory block and implement source code
Author: Ye Feihu
Date: 2014.10.21
--------------------------------------------------------------------------------

In general linear operation applications (e.g. receive buffers), it may be necessary to allocate and free memory blocks frequently,
System overhead, how to reduce system overhead? Reduce the operation by pulling the spacing between the distribution and the release
To reduce system overhead.

There are many ways to pull the gap between distribution and release, which can be managed by a large memory block, or through memory
Block buffer queue. This article focuses on the memory block buffer queue, involving the queue will take into account the non-lock in and out of the queue, that is, into the queue and
The out queue can operate concurrently in two threads. There are many ways to implement a lock-free queue, and there are arrays of rings without locking teams
Column, there is also a link to the lock-free queue. Array mode is appropriate when the queue capacity is determined, and the linking method is more suitable for
The capacity of the queue is variable, and the applicability is better.

Array mode lock-free queue See my Blog < How does a lock-free ring queue be implemented under one-read-write limit? >
Link mode no lock queue See my post < Read-write how does a lock-free queue work? >

This article is about the buffer team as a link, the link is generally by pre-allocation of a node as a relay point to achieve No
Lock queue, the advantage is simple implementation, the disadvantage is to waste a node of memory, when the node memory block size is large waste
The How do I not waste a node memory link way without lock queue? When there is only one node in the queue, this buffer queue
The use of atomic locks in the operation, this is a balance strategy, if the reader has a better way to tell it!

Fixed size memory block buffer Queue Class (Tkycache) source code is as follows:

=======================================//Unit: Fixed-size memory block buffer//version:3.0.0.0 (build 2014.10.21)//Author:kyee Ye/ /Email:kyee_ye (at) 126.com//Copyright (C) kyee workroom//======================================= #ifndef _KYCache_H_ #define _KYCACHE_H_#INCLUDE "KYObject.h"//kylib 2.0 start using Kylib namespace namespace kylib{//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/* tkycache-Fixed size memory block buffer class *///Note://1. For multi-thread access security, the new and delete sub-two threads can be operated simultaneously without the need for lock,//But the multithreading New must be controlled with a lock, multi-threaded Delete must be controlled with a lock!//2.                This buffer class is generally applied to classes in linear operations to reduce the buffering usage of frequently allocated and freed memory. Class Tkycache{private://memory block link typedef struct {void* self;                Memory block belongs to Object void* Next; Next block} tlink, *plink;public://constructor//1. Ablocksize The fixed size of the memory block, the range of values: [0x40. 0X40000000]//2.   Amaxcount the maximum number of memory block buffers Tkycache (long ablocksize = 1024x768, long amaxcount = 256);   Virtual ~tkycache (); Attribute Long Count () const {return Fpushcount-fpopCount;   } long MaxCount () const {return fmaxcount;}  Default:amaxcount long BlockSize () const {return fblocksize;} Default:ablocksize//Set maximum number of memory block buffers void Setmaxcount (long amaxcount) {Fmaxcount = (AMax Count >= 0)? amaxcount:0;                     }//Allocate a fixed-size memory block void* New () {tlink* pitem = donew (); Return (Pitem! = NULL)?                  (char*) Pitem + sizeof (tlink): NULL;                     }//Release fixed-size memory block void Delete (void* ablock) {if (Ablock! = NULL)                        {tlink* Pitem = (tlink*) ((char*) ablock-sizeof (Tlink));                     if (pitem->self = = this) DoDelete (Pitem);   }}private://Perform allocation/release of memory block with link tlink* donew ();   void DoDelete (tlink* ALink); Perform purge buffer queue void Doclear (TLink* AHead);p rivate:tlink* fhead;               Buffered head links tlink* Ftail;               Buffered tail link long fflag;           Buffer queue flag long fmaxcount;          Buffer maximum number of long fblocksize;          The size of the memory block Longword Fpushcount;           Press-in buffer count Longword Fpopcount; Popup buffer count};} #endif

 

=======================================//Unit: Fixed-size memory block buffer//version:3.0.0.0 (build 2014.10.21)//Author:kyee Ye/ /Email:kyee_ye (at) 126.com//Copyright (C) kyee workroom//======================================= #include <malloc .h> #include "KYCache.h"//kylib 2.0 start using Kylib namespace namespace kylib{//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/* tkycache-Fixed-size memory block buffer class *///----------------constructors and destructors----------------//   Constructor Tkycache::tkycache (long ablocksize, long Amaxcount) {//Initialize fhead = NULL;   Ftail = NULL;   Fflag = 0;   Fpushcount = 0;   Fpopcount = 0; Set the maximum number of buffers Fmaxcount = (amaxcount >= 0)?   amaxcount:0;   Sets the size of the memory block if (ablocksize <= 0x40) fblocksize = 0x40;   else if (ablocksize <= 0x40000000) fblocksize = ablocksize; else fblocksize = 0x40000000;}      destructor Tkycache::~tkycache () {//execute purge buffer queue if (fpopcount! = fpushcount) {fpopcount = Fpushcount; DocleAR (Fhead); }}//----------------Private Function----------------//Perform allocation of memory blocks with links tkycache::tlink* Tkycache::D onew () {//Initialize tlink* result = NU   LL;   Determines whether the buffer queue is empty if (Fpopcount = = Fpushcount) result = (tlink*) malloc (sizeof (Tlink) + fblocksize);      else if (fpushcount-fpopcount! = 1) {//Take first item, and count plus 1 result = Fhead;      Fhead = (tlink*) result->next;   fpopcount++;      } else {//take the first result = Fhead;         Determine if you need to wait to prevent DoDelete conflict if (interlockedincrement (&fflag) = = 1) {fpopcount++;            if (Fpopcount = = fpushcount) {fhead = NULL;         Ftail = NULL;      } interlockeddecrement (&fflag);         } else {fpopcount++;         InterlockedDecrement (&fflag);      The loop waits for Fpushcount change while (Fpopcount = = Fpushcount) Sleep (1);   }//Modify the Buffered Header link if (result->next! = NULL) Fhead = (tlink*) result->next; }//Initialize the link item if (ResULt! = NULL) {result->self = this;   Result->next = NULL; }//Returns the result of return results;}      Execute free memory block with link void Tkycache::D odelete (tlink* ALink) {//determines if full if (Fpushcount-fpopcount >= (longword) fmaxcount)   Free (ALink);      else {//empty alink->next = null; The reference count plus 1, if not equal to 1, waits for donew to become 1 if (InterlockedIncrement (&fflag)! = 1) while (Fflag! = 1) Sl      EEP (0);         Determines whether the first item if (Ftail = = NULL) {ftail = ALink;      Fhead = ALink;         } else {ftail->next = ALink;      Ftail = ALink;      }//Count plus 1, and reference count minus 1 (note: The order can not be changed, otherwise it may lead to donew dead Loop) fpushcount++;   InterlockedDecrement (&fflag);   }}//perform purge buffer queue void Tkycache::D oclear (tlink* AHead) {//Initialize void* Pcurr;      Loop release while (AHead! = NULL) {Pcurr = AHead;      AHead = (tlink*) ahead->next;   Release free (PCURR); }}}

--------------------------------------------------------------------------------

Buffer Queue class of fixed size memory block and C + + implementation source code