lsmp/lsmp_int.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef LSMP_INT_HH
#define LSMP_INT_HH
//
//   Ligo Shared Memory Partition internal structures.
//
#include <sys/types.h>
#include "ManyFlags.hh"
#include "lsmp.hh"

#define LSMP_VERSION 101                    // Package version number
#define LSMP_SHMBASE 32                     // shm base id
#define LSMP_MAXSHM   8                     // maximum # of shm partitions
#define LSMP_MAXCONS  32                    // maximum number of consumers
#define LSMP_CONSPWD  8                     // consumers per mask word
#define LSMP_LMASK   ((LSMP_MAXCONS-1)/LSMP_CONSPWD+1) // consumer mask length
#define CON_BIT(i)  (i%LSMP_CONSPWD)
#define CON_MASK(i) (1 << (i%LSMP_CONSPWD))
#define CON_WORD(i) (i/LSMP_CONSPWD)

//--------------------------------------  Consumer flag class
#define LSMP_CONSPWD  8
#define LSMP_LMASK   ((LSMP_MAXCONS-1)/LSMP_CONSPWD+1)
#define CON_BIT(i)  (i%LSMP_CONSPWD)
#define CON_MASK(i) (1 << (i%LSMP_CONSPWD))
#define CON_WORD(i) (i/LSMP_CONSPWD)

typedef ManyFlags<LSMP_LMASK,LSMP_CONSPWD> ConFlags;

//---------------------------------------  Buffer header structure
#define SEG_QUEUED 0x0001

struct LSMP_buffer {
    unsigned int status;

    long boff;

    ConFlags reserve_mask;

    ConFlags seen_mask;

    int use_count;

    int ldata;

    int trig;

    time_t   fill_time;

    LSMP::eventid_type data_ID;

    pid_t    owner_pid;

    int      link;

    int      evt_count;

    bool inUse(void)  const {return use_count || reserve_mask.any();}

    bool seen(void)   const {return seen_mask.any();}

    bool queued(void) const {return (status & SEG_QUEUED) != 0;}
};

//---------------------------------------  Buffer queue structure

class LSMP_BufferQ {
  public:
    int head;
    int tail;

    LSMP_BufferQ() {
        init();
    }

    void init() {
        head = -1;
        tail = -1;
    }

    bool empty() {
        return (head < 0);}

    int length(LSMP_buffer *buf) const {
        int N = 0;
        for (int i=head ; i>=0 ;i=buf[i].link) N++;
        return N;
    }

    void link(LSMP_buffer *buf, int ib) {
        buf[ib].status |= SEG_QUEUED;
        buf[ib].link = -1;
        if (head<0) head           = ib;
        else        buf[tail].link = ib;
        tail = ib;}

    int remove(LSMP_buffer *buf) {
        int i = head;
        if (i >= 0) {
            head = buf[i].link;
            if (head<0) tail = -1;
            buf[i].link = -1;
            buf[i].status &= ~SEG_QUEUED;}
        return i;}

    int remove(LSMP_buffer *buf, int ib) {
        if (ib < 0) {
            return ib;
        } else if (head == ib) {
            return remove(buf);
        } else {
            for (int i=head ; i>=0 ; i=buf[i].link) {
                if (buf[i].link == ib) {
                    buf[i].link = buf[ib].link;
                    if (buf[i].link < 0) tail = i;
                    buf[ib].link = -1;
                    buf[ib].status &= ~SEG_QUEUED;
                    return ib;
                }
            }
        }
        return -1;
    }
};

//--------------------------------------  Shared memory structure.
#define RELBUF  0x0001                     // release unrequired buffers
#define SCAVAGE 0x0002                     // search for unused buffers
#define RQSYNCH 0x0004                     // synchronize on requests
#define KEEP    0x0008                     // Keep an unaccessed partition
#define EXPOSE  0x0010                     // Expose data to all consumers

struct LSMP_global {
    int  status;                   // Status flags
    int  version;                  // LSMP version number
    int  gbl_count;                // Number of accesses
    int  gbl_semid;                // global semaphore ID
    int  nbuf;                     // Number of buffers
    int  lbuf;                     // Buffer length
    LSMP_BufferQ full;             // Full buffer queue
    LSMP_BufferQ free;             // Free buffer queue
    char name[LSMP_LNAME];         // Partition name
    int  ncons;                    // Number of active consumers
    int  con_semid[LSMP_LMASK];    // Consumer semaphore IDs
    ConFlags conmask;              // Consumer use mask
};

enum gblsem {
    gbl_gate,
    gbl_empty,
    gbl_full,
    gbl_synch,
    gbl_nsems
};

struct LSMP_consbk {
    int mxbuf;
    int trig_mask;
    int min_time;
    int min_sep;
    int time_ctr;  
    int skip_ctr;

    int seg_ctr;
    int seg_tot;
    int flags;
    pid_t pid;

    bool isReadAll(void) const {return (flags & READALL) != 0;}

    void clrWait(void) {flags &= ~EVWAIT;}

    void setWait(void) {flags |= EVWAIT;}
};

//--------------------------------------  Define the semctl union
//  Note: This is now necessary on most systems in use by LIGO: sun, linux 
//        and hpux. Other systems (e.g. AIX and Irix) may choke on this, 
//        but for now it's easier to leave it in unconditionally.
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

#endif

---