semaphore.cpp

Go to the documentation of this file.

#ifndef SEMAPHORE_IMPLEMENTATION_FILE
#define SEMAPHORE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : semaphore                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1998-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "mechanisms_implementation_only.h"
#include "semaphore.h"

#include <basis/function.h>
#include <basis/istring.h>
#include <basis/mutex.h>
#include <basis/portable.h>

//#define DEBUG_SEMAPHORE
  // uncomment if you want the debugging version.

// the state of the threads using or trying to use the semaphore is reported
// by "_current_state".  it is positive if there are still slots that are
// available, zero if no slots are available, and negative if all the slots
// are used _and_ processes are waiting for the semaphore.

semaphore::semaphore(int concurrent_locks, int initial_locks_available)
: _max_users(0),
  _locks_available(0),
  _wait_guard(new mutex),
  _signal_guard(new mutex),
  _current_state(0)
{
  if (concurrent_locks < 1) concurrent_locks = 1;
  _max_users = concurrent_locks;
  if (initial_locks_available < 0) initial_locks_available = 0;
  else if (initial_locks_available > concurrent_locks)
    initial_locks_available = concurrent_locks;
  _locks_available = initial_locks_available;
  _current_state = _locks_available;
}

semaphore::~semaphore()
{
  delete _wait_guard;
  _wait_guard = NIL;
  delete _signal_guard;
  _signal_guard = NIL;
}

void semaphore::establish_lock() { wait(); }

void semaphore::repeal_lock() { signal(); }

void semaphore::wait()
{
  _wait_guard->lock();
  // if the semaphore's count is negative, we need to snooze.
  while (non_positive(_current_state)) portable::sleep_ms(10);
  // we're guaranteed that the state is now above zero; this function's the
  // only one that can decrement the state (other than by rollover).
  _current_state--;  // record that this thread got a lock.
  _wait_guard->unlock();
}

void semaphore::signal()
{
  FUNCDEF("signal");
  _signal_guard->lock();
  _current_state++;  // release the lock that this thread had.
  if (_current_state > _max_users)
    LOG("semaphore::signal: logic error!  the semaphore is greater than "
        "its maximum!");
  _signal_guard->unlock();
}


#endif //SEMAPHORE_IMPLEMENTATION_FILE

---