RingBuffer Class Reference

Class to manage a Ring Buffer placed in an IPC shared memory. More...

#include <RingBuffer.h>

Public Member Functions
	RingBuffer (int nwords=c_DefaultSize)
	Constructor to create a new shared memory in private space.
	RingBuffer (const std::string &name, unsigned int nwords=0)
	Constructor to create/attach named shared memory in global space.
	~RingBuffer ()
	Destructor.
void	openSHM (int nwords)
	open shared memory
void	cleanup ()
	Function to detach and remove shared memory.
int	insq (const int *buf, int size, bool checkTx=false)
	Append a buffer to the RingBuffer.
int	remq (int *buf)
	Pick up a buffer from the RingBuffer.
int	spyq (int *buf) const
	Prefetch a buffer from the RingBuffer w/o removing it.
int	numq () const
	Returns number of entries/buffers in the RingBuffer.
void	txAttached ()
	Increase the number of attached Tx counter.
void	txDetached ()
	Decrease the number of attached Tx counter.
void	kill ()
	Cause termination of reading processes (if they use isDead()).
bool	isDead () const
	If True, the ring buffer is empty and has no attached Tx modules (i.e.
bool	allRxWaiting () const
	True if and only if buffer is empty and nbusy == 0.
int	clear ()
	Clear the RingBuffer.
void	forceClear ()
	Forcefully clear the RingBuffer with resetting semaphore.
int	tryClear ()
	Clear the RingBuffer, if the semaphore isn't locked at the moment.
int	shmid () const
	Return ID of the shared memory.
void	dump_db ()
	Print some info on the RingBufInfo structure.
int	ninsq () const
	Return number of insq() calls for current buffer.
int	nremq () const
	Return number of remq() calls for current buffer.
int	insq_counter () const
	Return number of insq() calls.
int	remq_counter () const
	Return number of remq() calls.
void	dumpInfo () const
	Dump contents of RingBufInfo metadata.

Static Public Attributes
static const int	c_DefaultSize = 15000000
	Standard size of buffer, in integers (~60MB).

Private Attributes
bool	m_new {true}
	True if we created the ring buffer ourselves (and need to clean it).
bool	m_file {false}
	True if m_pathfd needs to be closed.
std::string	m_pathname {""}
	Path for identifying shared memory if named ring buffer is created.
int	m_pathfd { -1}
	Associated file descriptor.
key_t	m_shmkey {IPC_PRIVATE}
	SHM key, see shmget(2).
key_t	m_semkey {IPC_PRIVATE}
	Semaphore key, see semget(2).
std::string	m_semshmFileName {""}
	file path containing ids of shm and sema for private shared mem, used for easier cleanup if we fail to do things properly
bool	m_procIsBusy {false}
	Is this process currently processing events from this RingBuffer?
int	m_shmid { -1}
	ID of shared memory segment.
int *	m_shmadr {nullptr}
	Address of attached shared memory segment.
int	m_shmsize { -1}
	Size of shared memory segment, in bytes.
struct RingBufInfo *	m_bufinfo {nullptr}
	structure to manage ring buffer.
int *	m_buftop {nullptr}
	Points to memory after the end of m_bufinfo.
int	m_semid { -1}
	Semaphore ID.
int	m_remq_counter {0}
	count remq() calls.
int	m_insq_counter {0}
	count insq() calls.

Detailed Description

Class to manage a Ring Buffer placed in an IPC shared memory.

Definition at line 39 of file RingBuffer.h.

Constructor & Destructor Documentation

RingBuffer() [1/2]

RingBuffer ( int  nwords = c_DefaultSize )

explicit

Constructor to create a new shared memory in private space.

Parameters

nwords

Ring buffer size in integers

Definition at line 32 of file RingBuffer.cc.

{
  openSHM(size);
  B2DEBUG(32, "RingBuffer initialization done");
}

RingBuffer() [2/2]

RingBuffer ( const std::string &  name, unsigned int  nwords = 0  )

explicit

Constructor to create/attach named shared memory in global space.

Definition at line 39 of file RingBuffer.cc.

{
  // 0. Determine shared memory type
  if (name != "private") { // Global
    m_file = true;
    m_pathname = std::string(std::filesystem::temp_directory_path() / getenv("USER")) + "_RB_" + name;
    m_pathfd = open(m_pathname.c_str(), O_CREAT | O_EXCL | O_RDWR, 0644);
    if (m_pathfd > 0) {   // a new shared memory file created
      B2DEBUG(32, "[RingBuffer] Creating a ring buffer with key " << name);
      m_new = true;
    } else if (m_pathfd == -1 && errno == EEXIST) { // shm already there
      B2DEBUG(32, "[RingBuffer] Attaching the ring buffer with key " << name);
      m_new = false;
    } else {
      B2FATAL("RingBuffer: error opening shm file: " << m_pathname);
    }
    m_shmkey = ftok(m_pathname.c_str(), 1);
    m_semkey = ftok(m_pathname.c_str(), 2);
  } else { // Private
    B2DEBUG(32, "[RingBuffer] Opening private ring buffer");
  }
 
  openSHM(nwords);
 
  if (m_pathfd > 0) {
    B2DEBUG(32, "First global RingBuffer creation: writing SHM info to file.");
    char rbufinfo[256];
    snprintf(rbufinfo, sizeof(rbufinfo), "%d\n", m_shmid);
    int is = write(m_pathfd, rbufinfo, strlen(rbufinfo));
    if (is < 0) perror("write");
    snprintf(rbufinfo, sizeof(rbufinfo), "%d\n", m_semid);
    is = write(m_pathfd, rbufinfo, strlen(rbufinfo));
    if (is < 0) perror("write");
    close(m_pathfd);
  }
 
 
  B2DEBUG(32, "RingBuffer initialization done with shm=" << m_shmid);
}

~RingBuffer()

~RingBuffer

(

)

Destructor.

Definition at line 79 of file RingBuffer.cc.

{
  cleanup();
}

Member Function Documentation

allRxWaiting()

bool allRxWaiting

(

)

const

True if and only if buffer is empty and nbusy == 0.

Called in Tx to see if all events of the current run have been processed

Definition at line 400 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
  return (m_bufinfo->nbusy == 0) and (m_bufinfo->nbuf == 0);
}

cleanup()

void cleanup

(

)

Function to detach and remove shared memory.

Definition at line 162 of file RingBuffer.cc.

{
  if (m_procIsBusy) {
    SemaphoreLocker locker(m_semid);
    m_bufinfo->nbusy--;
    m_procIsBusy = false;
  }
 
  shmdt(m_shmadr);
  B2DEBUG(32, "RingBuffer: Cleaning up IPC");
  if (m_new) {
    shmctl(m_shmid, IPC_RMID, (struct shmid_ds*) nullptr);
    SemaphoreLocker::destroy(m_semid);
    if (m_file) {
      unlink(m_pathname.c_str());
    }
    unlink(m_semshmFileName.c_str());
  }
}

clear()

int clear

(

)

Clear the RingBuffer.

Definition at line 426 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
  //  m_bufinfo->size = m_shmsize - sizeof ( struct RingBufInfo );
  m_bufinfo->remain = m_bufinfo->size;
  m_bufinfo->wptr = 0;
  m_bufinfo->prevwptr = 0;
  m_bufinfo->rptr = 0;
  m_bufinfo->nbuf = 0;
  m_bufinfo->ninsq = 0;
  m_bufinfo->nremq = 0;
 
  return 0;
}

dump_db()

void dump_db

(

)

Print some info on the RingBufInfo structure.

Definition at line 182 of file RingBuffer.cc.

{
  printf("bufsize=%d, remain=%d, wptr=%d, rptr=%d, nbuf=%d\n",
         m_bufinfo->size, m_bufinfo->remain,
         m_bufinfo->wptr, m_bufinfo->rptr, m_bufinfo->nbuf);
}

dumpInfo()

void dumpInfo

(

)

const

Dump contents of RingBufInfo metadata.

Definition at line 463 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
 
  // Dump control parameters
  printf("***** Ring Buffer Information ***\n");
  printf("path = %s\n", m_pathname.c_str());
  printf("shmsize = %d\n", m_shmsize);
  printf("[Buffer Info]\n");
  printf("bufsize = %d\n", m_bufinfo->size);
  printf("remain = %d\n", m_bufinfo->remain);
  printf("wptr = %d\n", m_bufinfo->wptr);
  printf("prevwptr = %d\n", m_bufinfo->prevwptr);
  printf("rptr = %d\n", m_bufinfo->rptr);
  printf("nbuf = %d\n", m_bufinfo->nbuf);
  printf("nattached = %d\n", m_bufinfo->nattached);
  printf("nbusy = %d\n", m_bufinfo->nbusy);
  printf("errtype = %d\n", m_bufinfo->errtype);
  printf("numAttachedTx = %d\n", m_bufinfo->numAttachedTx);
  printf("ninsq = %d\n", m_bufinfo->ninsq);
  printf("nremq = %d\n", m_bufinfo->ninsq);
}

forceClear()

void forceClear

(

)

Forcefully clear the RingBuffer with resetting semaphore.

Definition at line 441 of file RingBuffer.cc.

{
  int val = 1;
  if (semctl(m_semid, 0, SETVAL, val) == -1) { //set 0th semaphore to semval
    B2ERROR("Initializing semaphore with semctl() failed.");
  }
  clear();
}

insq()

int insq	(	const int *	buf,
		int	size,
		bool	checkTx = false
	)

Append a buffer to the RingBuffer.

Definition at line 189 of file RingBuffer.cc.

{
  if (size <= 0) {
    B2FATAL("RingBuffer::insq() failed: invalid buffer size = " << size);
  }
  if (m_bufinfo->numAttachedTx == 0 and checkTx) {
    //safe abort was requested
    B2WARNING("Number of attached Tx is 0, so I will not go on with the processing.");
    exit(0);
  }
  SemaphoreLocker locker(m_semid);
  if (m_bufinfo->nbuf == 0) {
    m_bufinfo->wptr = 0;
    m_bufinfo->rptr = 0;
    if (size > m_bufinfo->size + 2) {
      throw std::runtime_error("[RingBuffer::insq ()] Inserted item (size: " + std::to_string(size) +
                               ") is larger than RingBuffer (size: " + std::to_string(m_bufinfo->size + 2) + ")!");
    }
    m_bufinfo->errtype = 0;
    int* wptr = m_buftop + m_bufinfo->wptr;
    *wptr = size;
    *(wptr + 1) = m_bufinfo->wptr + (size + 2);
    memcpy(wptr + 2, buf, size * sizeof(int));
    m_bufinfo->prevwptr = m_bufinfo->wptr;
    m_bufinfo->wptr += (size + 2);
    m_bufinfo->nbuf++;
    m_bufinfo->ninsq++;
    m_insq_counter++;
    return size;
  } else if (m_bufinfo->wptr > m_bufinfo->rptr) {
    if (m_bufinfo->errtype != 4 &&
        m_bufinfo->errtype != 3 && m_bufinfo->errtype != 0) {
      B2ERROR("insq: Error in errtype 0; current=" << m_bufinfo->errtype);
      return -1;
    }
    if (m_bufinfo->errtype == 3) {
      //      printf ( "---> errtype is 3, still remaining buffers\n" );
      B2DEBUG(32, "[RingBuffer] errtype 3");
      return -1;
    } else if (m_bufinfo->errtype == 4) {
      //      printf ( "---> errtype returned to 0, wptr=%d, rptr=%d\n",
      //         m_bufinfo->wptr, m_bufinfo->rptr );
    }
    m_bufinfo->errtype = 0;
    if (size + 2 < m_bufinfo->size - m_bufinfo->wptr) { // normal case
      int* wptr = m_buftop + m_bufinfo->wptr;
      *wptr = size;
      *(wptr + 1) = m_bufinfo->wptr + (size + 2);
      memcpy(wptr + 2, buf, size * sizeof(int));
      m_bufinfo->prevwptr = m_bufinfo->wptr;
      m_bufinfo->wptr += (size + 2);
      m_bufinfo->nbuf++;
      m_bufinfo->ninsq++;
      m_insq_counter++;
      return size;
    } else {
      if (m_bufinfo->rptr >= size + 2) { // buffer full and wptr>rptr
        // this should be dead code but I don't understand it well enough to delete it
        if (m_bufinfo->errtype != 0) {
          B2ERROR("insq: Error in errtype 1; current=" << m_bufinfo->errtype);
          return -1;
        }
        m_bufinfo->errtype = 1;
        int* wptr = m_buftop;
        memcpy(wptr + 2, buf, size * sizeof(int));
        *wptr = size;
        *(wptr + 1) = size + 2;
        m_bufinfo->wptr = *(wptr + 1);
        int* prevptr = m_buftop + m_bufinfo->prevwptr;
        *(prevptr + 1) = 0;
        m_bufinfo->prevwptr = 0;
        if (m_bufinfo->nbuf == 0) {
          m_bufinfo->errtype = 4;
          m_bufinfo->rptr = 0;
        }
        m_bufinfo->nbuf++;
        //  printf ( "insq: no more space, space below rptr; prev=%d, new=%d\n",
        //         m_bufinfo->prevwptr, m_bufinfo->wptr );
        m_bufinfo->ninsq++;
        m_insq_counter++;
        return size;
      } else {
        //  printf ( "insq: wptr>rptr, no more space, no space below rptr(%d), readbuf=%d\n",
        //     m_bufinfo->rptr, m_bufinfo->readbuf );
        return -1;
      }
    }
  } else {  // wptr < rptr
    if (m_bufinfo->wptr + size + 2 < m_bufinfo->rptr &&
        size + 2 < m_bufinfo->size - m_bufinfo->rptr) {
      if (m_bufinfo->errtype != 1 && m_bufinfo->errtype != 2 &&
          m_bufinfo->errtype != 3) {
        B2ERROR("insq: Error in errtype 2; current=" << m_bufinfo->errtype);
        return -1;
      }
      m_bufinfo->errtype = 2;
      int* wptr = m_buftop + m_bufinfo->wptr;
      *wptr = size;
      *(wptr + 1) = m_bufinfo->wptr + (size + 2);
      memcpy(wptr + 2, buf, size * sizeof(int));
      m_bufinfo->prevwptr = m_bufinfo->wptr;
      m_bufinfo->wptr += (size + 2);
      m_bufinfo->nbuf++;
      //      printf ( "insq: wptr<rptr and enough space below rptr; curr=%d, next=%d, rptr=%d\n", m_bufinfo->prevwptr, m_bufinfo->wptr, m_bufinfo->rptr );
      if (m_bufinfo->wptr > m_bufinfo->rptr) {
        B2DEBUG(32, "next pointer will exceed rptr.....");
        m_bufinfo->errtype = 3;
      }
      m_bufinfo->ninsq++;
      m_insq_counter++;
      return size;
    } else {
      //      printf ( "insq: wptr<rptr; no more space below rptr(%d), wptr(%d)\n",
      //         m_bufinfo->rptr, m_bufinfo->wptr );
      return -1;
    }
  }
}

insq_counter()

int insq_counter

(

)

const

Return number of insq() calls.

Definition at line 416 of file RingBuffer.cc.

{
  return m_insq_counter;
}

isDead()

bool isDead

(

)

const

If True, the ring buffer is empty and has no attached Tx modules (i.e.

no new data is going to be added). Processes should then stop.

Definition at line 394 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
  //NOTE: numAttachedTx == -1 also means we should read data (i.e. initialization pending)
  return (m_bufinfo->numAttachedTx == 0) and (m_bufinfo->nbuf <= 0);
}

kill()

void kill

(

)

Cause termination of reading processes (if they use isDead()).

Assumed to be atomic.

Definition at line 389 of file RingBuffer.cc.

{
  m_bufinfo->numAttachedTx = 0;
  m_bufinfo->nbuf = 0;
}

ninsq()

int ninsq

(

)

const

Return number of insq() calls for current buffer.

Definition at line 406 of file RingBuffer.cc.

{
  return m_bufinfo->ninsq;
}

nremq()

int nremq

(

)

const

Return number of remq() calls for current buffer.

Definition at line 411 of file RingBuffer.cc.

{
  return m_bufinfo->nremq;
}

numq()

int numq

(

)

const

Returns number of entries/buffers in the RingBuffer.

Definition at line 368 of file RingBuffer.cc.

{
  return m_bufinfo->nbuf;
}

openSHM()

void openSHM

(

int

nwords

)

open shared memory

Definition at line 84 of file RingBuffer.cc.

{
  // 1. Open shared memory
  unsigned int sizeBytes = nwords * sizeof(int);
  const auto mode = IPC_CREAT | 0644;
  m_shmid = shmget(m_shmkey, sizeBytes, mode);
  if (m_shmid < 0) {
    unsigned int maxSizeBytes = sizeBytes;
    ifstream shmax("/proc/sys/kernel/shmmax");
    if (shmax.good())
      shmax >> maxSizeBytes;
    shmax.close();
 
    B2WARNING("RingBuffer: shmget(" << sizeBytes << ") failed, limiting to system maximum: " << maxSizeBytes);
    sizeBytes = maxSizeBytes;
    nwords = maxSizeBytes / sizeof(int);
    m_shmid = shmget(m_shmkey, sizeBytes, mode);
    if (m_shmid < 0) {
      B2FATAL("RingBuffer: shmget(" << sizeBytes <<
              ") failed. Most likely the system doesn't allow us to reserve the needed shared memory. Try 'echo 500000000 > /proc/sys/kernel/shmmax' as root to set a higher limit (500MB).");
    }
  }
  m_shmadr = (int*) shmat(m_shmid, nullptr, 0);
  if (m_shmadr == (int*) - 1) {
    B2FATAL("RingBuffer: Attaching to shared memory segment via shmat() failed");
  }
 
  // 2. Open Semaphore
  m_semid = SemaphoreLocker::create(m_semkey);
  if (m_semid < 0) {
    cleanup();
    B2FATAL("Aborting execution because we couldn't create a semaphore (see previous error messages for details).");
  }
  SemaphoreLocker locker(m_semid); //prevent simultaneous initialization
 
  // 3. Initialize control parameters
  m_shmsize = nwords;
  m_bufinfo = reinterpret_cast<RingBufInfo*>(m_shmadr);
  m_buftop = m_shmadr + sizeof(struct RingBufInfo);
  if (m_new) {
    m_bufinfo->size = m_shmsize - sizeof(struct RingBufInfo);
    m_bufinfo->remain = m_bufinfo->size;
    m_bufinfo->wptr = 0;
    m_bufinfo->prevwptr = 0;
    m_bufinfo->rptr = 0;
    m_bufinfo->nbuf = 0;
    m_bufinfo->semid = m_semid;
    m_bufinfo->nattached = 1;
    m_bufinfo->nbusy = 0;
    m_bufinfo->errtype = 0;
    m_bufinfo->numAttachedTx = -1;
    m_bufinfo->ninsq = 0;
    m_bufinfo->nremq = 0;
  } else {
    m_bufinfo->nattached++;
 
    B2DEBUG(32, "[RingBuffer] check entries = " << m_bufinfo->nbuf);
    B2DEBUG(32, "[RingBuffer] check size = " << m_bufinfo->size);
  }
 
  m_remq_counter = 0;
  m_insq_counter = 0;
 
  if (m_new) {
    // Leave id of shm and semaphore in file name
    m_semshmFileName = std::string(std::filesystem::temp_directory_path() / "SHM") + to_string(m_shmid) + "-SEM" + to_string(
                         m_semid) + "-UNNAMED";
    int fd = open(m_semshmFileName.c_str(), O_CREAT | O_TRUNC | O_RDWR, 0644);
    if (fd < 0) {
      B2WARNING("RingBuffer ID file could not be created.");
    } else {
      close(fd);
    }
  }
 
  B2DEBUG(35, "buftop = " << m_buftop << ", end = " << (m_buftop + m_bufinfo->size));
}

remq()

int remq

(

int *

buf

)

Pick up a buffer from the RingBuffer.

Definition at line 308 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
  if (m_bufinfo->nbuf < 0) {
    throw std::runtime_error("[RingBuffer::remq ()] number of entries is negative: " + std::to_string(m_bufinfo->nbuf));
  }
  if (m_bufinfo->nbuf == 0) {
    if (m_procIsBusy) {
      m_bufinfo->nbusy--;
      m_procIsBusy = false;
    }
    return 0;
  }
  int* r_ptr = m_buftop + m_bufinfo->rptr;
  int nw = *r_ptr;
  if (nw <= 0) {
    printf("RingBuffer::remq : buffer size = %d, skipped\n", nw);
    printf("RingBuffer::remq : entries = %d\n", m_bufinfo->nbuf);
    if (m_procIsBusy) {
      m_bufinfo->nbusy--;
      m_procIsBusy = false;
    }
    return 0;
  }
  if (buf)
    memcpy(buf, r_ptr + 2, nw * sizeof(int));
  m_bufinfo->rptr = *(r_ptr + 1);
  if (m_bufinfo->rptr == 0)
    m_bufinfo->errtype = 4;
  m_bufinfo->nbuf--;
  m_bufinfo->nremq++;
  m_remq_counter++;
 
  if (not m_procIsBusy) {
    m_bufinfo->nbusy++;
    m_procIsBusy = true;
  }
  return nw;
}

remq_counter()

int remq_counter

(

)

const

Return number of remq() calls.

Definition at line 421 of file RingBuffer.cc.

{
  return m_remq_counter;
}

shmid()

int shmid

(

)

const

Return ID of the shared memory.

Definition at line 458 of file RingBuffer.cc.

{
  return m_shmid;
}

spyq()

int spyq

(

int *

buf

)

const

Prefetch a buffer from the RingBuffer w/o removing it.

Definition at line 348 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
  if (m_bufinfo->nbuf <= 0) {
    return 0;
  }
  int* r_ptr = m_buftop + m_bufinfo->rptr;
  int nw = *r_ptr;
  if (nw <= 0) {
    printf("RingBuffer::spyq : buffer size = %d, skipped\n", nw);
    printf("RingBuffer::spyq : entries = %d\n", m_bufinfo->nbuf);
    return 0;
  }
  //  printf ( "remq : taking buf from %d(%d)\n", m_bufinfo->rptr, nw );
  // Copy buffer without modifying management parameters.
  memcpy(buf, r_ptr + 2, nw * sizeof(int));
  // Exit
  return nw;
}

tryClear()

int tryClear

(

)

Clear the RingBuffer, if the semaphore isn't locked at the moment.

See SemaphoreLocker::isLocked() for details

Definition at line 450 of file RingBuffer.cc.

{
  if (SemaphoreLocker::isLocked(m_semid))
    return 0;
 
  return clear();
}

txAttached()

void txAttached

(

)

Increase the number of attached Tx counter.

Definition at line 373 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
  if (m_bufinfo->numAttachedTx == -1) //first attach
    m_bufinfo->numAttachedTx = 0;
 
  m_bufinfo->numAttachedTx++;
}

txDetached()

void txDetached

(

)

Decrease the number of attached Tx counter.

Definition at line 381 of file RingBuffer.cc.

{
  SemaphoreLocker locker(m_semid);
  m_bufinfo->numAttachedTx--;
  if (m_bufinfo->numAttachedTx < 0) {
    m_bufinfo->numAttachedTx = 0;
  }
}

Member Data Documentation

c_DefaultSize

const int c_DefaultSize = 15000000

static

Standard size of buffer, in integers (~60MB).

Needs to be large enough to contain any event, but adds to total memory use of basf2.

Definition at line 42 of file RingBuffer.h.

m_bufinfo

struct RingBufInfo* m_bufinfo {nullptr}

private

structure to manage ring buffer.

Placed on top of the shared memory.

Definition at line 129 of file RingBuffer.h.

m_buftop

int* m_buftop {nullptr}

private

Points to memory after the end of m_bufinfo.

Definition at line 130 of file RingBuffer.h.

m_file

bool m_file {false}

private

True if m_pathfd needs to be closed.

Definition at line 111 of file RingBuffer.h.

m_insq_counter

int m_insq_counter {0}

private

count insq() calls.

Definition at line 133 of file RingBuffer.h.

m_new

bool m_new {true}

private

True if we created the ring buffer ourselves (and need to clean it).

Definition at line 110 of file RingBuffer.h.

m_pathfd

int m_pathfd { -1}

private

Associated file descriptor.

Definition at line 113 of file RingBuffer.h.

m_pathname

std::string m_pathname {""}

private

Path for identifying shared memory if named ring buffer is created.

Definition at line 112 of file RingBuffer.h.

m_procIsBusy

bool m_procIsBusy {false}

private

Is this process currently processing events from this RingBuffer?

set during remq() with value depending on wether data was returned. Always false for a process that is only using insq().

Definition at line 124 of file RingBuffer.h.

m_remq_counter

int m_remq_counter {0}

private

count remq() calls.

Definition at line 132 of file RingBuffer.h.

m_semid

int m_semid { -1}

private

Semaphore ID.

Definition at line 131 of file RingBuffer.h.

m_semkey

key_t m_semkey {IPC_PRIVATE}

private

Semaphore key, see semget(2).

Definition at line 115 of file RingBuffer.h.

m_semshmFileName

std::string m_semshmFileName {""}

private

file path containing ids of shm and sema for private shared mem, used for easier cleanup if we fail to do things properly

Definition at line 117 of file RingBuffer.h.

m_shmadr

int* m_shmadr {nullptr}

private

Address of attached shared memory segment.

(See shmat(2))

Definition at line 127 of file RingBuffer.h.

m_shmid

int m_shmid { -1}

private

ID of shared memory segment.

(See shmget(2))

Definition at line 126 of file RingBuffer.h.

m_shmkey

key_t m_shmkey {IPC_PRIVATE}

private

SHM key, see shmget(2).

Definition at line 114 of file RingBuffer.h.

m_shmsize

int m_shmsize { -1}

private

Size of shared memory segment, in bytes.

Definition at line 128 of file RingBuffer.h.

---

The documentation for this class was generated from the following files:

• framework/pcore/include/RingBuffer.h
• framework/pcore/src/RingBuffer.cc