ipc.simple.sem.H

Go to the documentation of this file.

#ifndef IPC_SIMPLE_SEMAPHORE_H
#define IPC_SIMPLE_SEMAPHORE_H

//
// example source at:  http://docs.linux.cz/unix_examples/semab.html
// 

#include "simple.sem.H"

#ifdef linux

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>

// XXX - why not in sys/sem.h ???
union semun {
  int val;
  struct semid_ds *buf;
  unsigned short *array;
  struct seminfo *__buf;
};

class IPC_SimpleSemaphore : public SimpleSemaphore
{
 protected:
  int _id;

  int v_op()
  {
    struct sembuf sops[1];
    sops[0].sem_num = 0;
    sops[0].sem_op  = 1;
    sops[0].sem_flg = 0;
    if (semop(_id, sops, 1) == -1)
      return 0;
    else
      return 1;
  }
  
  int p_op()
  {
    struct sembuf sops[1];
    sops[0].sem_num = 0;
    sops[0].sem_op  = -1;
    sops[0].sem_flg = 0;
    
    if (semop(_id, sops, 1) == -1)
      return 0;
    else
      return 1;
  }

  // Added by dlemmerm 6/10/05. Using sem_op = 0 means that the calling 
  // process will block (at least) until the semaphore becomes 0. 
  int wait_op() 
  {
    struct sembuf sops[1];
    sops[0].sem_num = 0;
    sops[0].sem_op  = 0;
    sops[0].sem_flg = 0;
    
    if (semop(_id, sops, 1) == -1)
      return 0;
    else
      return 1;
  }

 public:
  IPC_SimpleSemaphore(int key) : SimpleSemaphore(key), _id(0) {}
  
  // Added by dlemmerm to make it like Tannenbaum
  inline int up()   { return v_op();    }
  inline int down() { return p_op();    }
  
  // Added by dlemmerm
  inline int wait() { return wait_op(); }

  // Creates a semaphore with initial value of 1
  virtual int create() {
    int nsems = 1;
    _id = semget((key_t)_key, nsems, IPC_CREAT | IPC_EXCL | 0666);
    if (_id == -1) {
      return 0;
    } else {
      // set the value of the number 0 semaphore to 0
      union semun argument;
      argument.val = 0;
      if (semctl(_id, 0, SETVAL, argument) < 0) {
    cerr << "IPC_SimpleSemaphore: constructor cannot set semaphore value." << endl;
    return 0;
      }
      
      // perform v-operation one time so resource is available
      if (!v_op()) {
    cerr << "IPC_SimpleSemaphore: constructor couldn't do initial v-operation" << endl;
    return 0;
      }

      _valid = 1;
      return 1;
    }
  }

  virtual int attach() {
    _id = semget((key_t)_key, 0, 0);

    if (_id == -1)
      return 0;

    _valid = 1;
    return 1;
  }

  virtual int remove() {
    if (semctl(_id, 0, IPC_RMID) == -1)
      return 0;
    else
      return 1;
  }

  // once initialized, use these methods to lock & unlock the semaphore
  virtual int lock() {
    return p_op();
  }

  virtual int unlock() {
    return v_op();
  }

  virtual void print( int do_wait=1 )
  {
    // check how much memory was allocated
    struct semid_ds buf;
    union semun arg;
    arg.buf = &buf;
    
    int s = semctl(_id, 0, IPC_STAT, &arg);
    if (s==0) {
      cerr << "  value: " << semctl(_id, 0, GETVAL) << endl;
      cerr << "  permissions:" << endl;
      cerr << "    uid:  " << int(buf.sem_perm.uid) << endl;
      cerr << "    mode: " << int(buf.sem_perm.mode) << endl;
      cerr << "  nsems: " << int(buf.sem_nsems) << endl;
    } else {
      cerr << "unable to get IPC_STAT info..." << endl;
    }
    
    system ("ipcs -s");
    
    if (do_wait) {
      cerr << "Type a number and <return> to continue..." << endl;
      int tmp;
      cin >> tmp;
    }
  }
};


// 
// More sample code from: http://engr.smu.edu/~mihai/cse5343/
// 
// #include <sys/types.h>
// #include <sys/stat.h>
// #include <sys/sem.h>
// #include <fcntl.h>
// #include <unistd.h>

// 'SemaphorePair' can be used for ProducerConsumer,
// and a situation where object A signals it's done and
// waits for object B to report some group of others are
// done (i.e., ALL_DONE).
class SemaphorePair
{
 protected:
  int _semid;
  int _creator;
  int _key;

 public:
  enum {EMPTY=0, FULL=1};
  enum {ALL_DONE =0, DONE=1}; // NOTE: order is important!

  SemaphorePair( int key ) : _semid(-1), _creator(0), _key(key) {}

  virtual ~SemaphorePair() {
    if (_creator)
      semctl(_semid, 2, IPC_RMID, 0);
  }
  
  int semid() const { return _semid; }

  int create() {
    if ((_semid = semget(_key, 2, 0777 | IPC_CREAT)) == -1)
      perror("SemaphorePair: semget");

    ushort init_values[2] = {1, 0};
    if(semctl(_semid, 2, SETALL, init_values) == -1)
      perror("SemaphorePair: semctl");

    _creator = 1;

    return _semid;
  }

  int attach() {
    _semid = semget(_key, 0, 0);
    return (_semid!=-1);
  }

  /* Semaphore wait. Decrements the semaphore value by 1 */
  int wait(int index) {
    struct sembuf operation;
    
    operation.sem_num = index; /* The index in the semaphore array id */
    operation.sem_op = -1; /* Decrement with 1 */
    operation.sem_flg = 0; /* No flags */
    
    return semop(_semid, & operation, 1); /* Execute operation */
  }

  /* Semaphore signal. Increments the semaphore value by 1 */
  int signal(int index) {
    struct sembuf operation;
    
    operation.sem_num = index; /* The index in the semaphore array id */
    operation.sem_op = 1; /* Increment with 1 */
    operation.sem_flg = 0; /* No flags */
    
    return semop(_semid, & operation, 1); /* Execute operation */
  }
};


#endif

#endif

---