Semaphores.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 2000 Yoshua Bengio and University of Montreal
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org

/* *******************************************************      
   * $Id: Semaphores.h,v 1.2 2004/02/20 21:11:49 chrish42 Exp $
   * This file is part of the PLearn library.
   ******************************************************* */

// Object-friendly interface to the POSIX semaphore utilities.
// Here we have defined two types of semaphores: ResourceSemaphore
// and CountEventsSemaphore. In both cases multiple semaphores
// of the same type can be managed by the same object.
//
// A ResourceSemaphore allows to control exclusive access to
// some resources (each controlled independently of the others),
// using the lock/unlock methods. When a process tries to
// take the lock while another has it, it will wait until
// the controlling process releases the lock.
//
// A CountEventsSemaphore allows to count the number of occurences
// of one or more events. Some processes can signal the occurence
// of an event of a given type, without waiting. Other processes
// may wait for the count for an event type to reach a certain
// value (and then this value is reset to 0).
//


#ifndef SEMAPHORES_INC
#define SEMAPHORES_INC

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

namespace PLearn {
using namespace std;


#if (defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)) || defined(_NO_XOPEN4)

#else

union semun {
               int val;                    
               struct semid_ds *buf;       
               unsigned short int *array;  
               struct seminfo *__buf;      
};
#endif

 class SemId {
   public:
     int id;
     SemId(int i = -1) : id(i) {} 
     SemId(SemId& semid) : id(semid.id) {}
 };

class ResourceSemaphore {
protected:
  SemId id; 
  bool owner; 

  int n_semaphores; 

public:

  ResourceSemaphore(int nb_semaphores=1);

  ResourceSemaphore(SemId semid);

  void lock(int resource=0);

  void unlock(int resource=0);

  bool locked(int resource=0);

  void clearAnyLock();
  void clearAnyLock(int resource);

  ~ResourceSemaphore();
};

class CountEventsSemaphore {
protected:
  SemId id; 
  bool owner; 

  int n_semaphores; 

public:

  CountEventsSemaphore(int nb_semaphores=1);

  CountEventsSemaphore(SemId semid);

  void signal(int type=0);

  void wait(int n_occurences, int type=0);

  int value(int type=0);

  void setValue(int value,int resource=0);

  ~CountEventsSemaphore();
};

template <class T>
class SharedMemory {
protected:
  SemId id; 
  bool owner; 

  int size_; 
  T* segment; 
public:
  SharedMemory(int n_items=1) : owner(true) {
    size_ = n_items*sizeof(T);
    int rv=shmget(IPC_PRIVATE, size_, 0666 | IPC_CREAT);
    if (rv == -1) PLERROR("SharedMemory::SharedMemory, shmget failed:%s",strerror(errno));
    else id.id=rv;
    segment = (T*)shmat(id.id,0,0);
    if (segment == 0) 
      PLERROR("SharedMemory::SharedMemory, shmat failed trying to allocate %d bytes: err=%s",
            size_,strerror(errno));

  }

  SharedMemory(SemId semid) : id(semid), owner(false) {
    struct shmid_ds buf;
    int r = shmctl(id.id,IPC_STAT,&buf);
    if (r == -1)
      PLERROR("SharedMemory:: slave SharedMemory(%d) shmctl returns -1, %s",
            id.id,strerror(errno));
    size_ = buf.shm_segsz;
    segment = (T*)shmat(id.id,0,0);
  }

  T* data() const { return segment; }

  int size() const { return size_ / sizeof(T); }

  ~SharedMemory() {
    int rv=shmdt((char*)segment);
    if (rv == -1)
      PLERROR("SharedMemory::~SharedMemory (id=%d) shmdt failed, %s", 
            id.id,strerror(errno));
    if (owner)
    {
      rv=shmctl(id.id,IPC_RMID,0);
      if (rv == -1)
        PLERROR("SharedMemory::~SharedMemory (id=%d) shmctl failed, %s", 
              id.id,strerror(errno));
      cout << "released shared memory segment ID = " << id.id << endl;
    }
  }
};

} // end of namespace PLearn

#endif

---