t_semaphore.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_semaphore                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Puts the semaphore object through a reasonably rigorous multi-threaded   *
*  test.                                                                      *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$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 <basis/array.cpp>
#include <basis/chaos.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <mechanisms/ithread.h>
#include <mechanisms/safe_roller.h>
#include <mechanisms/semaphore.h>
#include <mechanisms/time_stamp.h>
#include <loggers/file_logger.h>
#include <opsystem/path_configuration.h>
#include <data_struct/static_memory_gremlin.h>

#ifdef __WIN32__
  #include <process.h>
#endif

HOOPLE_STARTUP_CODE;

const int DEFAULT_FISH = 64;
  // the number of threads, by default.

const int DEFAULT_RUN_TIME = 142000;
  // the length of time to run the program.

int concurrent_biters = 0;
  // the number of threads that are currently active.

int grab_lock = 0;
  // this is upped whenever a fish obtains access to the semaphore.

const int MAX_GRABBERS = 8;
  // the maximum number of biters with a lock on the resource.

semaphore *guard;
  // the guard ensures that the grab lock isn't molested by more than the
  // allowed number of fish at once... hopefully.

bool exit_now = false;
  // set to true when the program's ready to leave.

const istring LOGFILE_NAME = path_configuration::make_logfile_name
    ("t_semaphore.log");
  // where our debugging output goes by default.

#define LOG(to_print) log.log(timestamp(true) + istring(to_print))
  // our macro for logging with a timestamp.

chaos rando;

class piranha : public ithread
{
public:
  piranha() : ithread() {}

  void perform_activity(void *) {
    file_logger log(LOGFILE_NAME);
    safe_add(concurrent_biters, 1);
LOG(istring(istring::SPRINTF, "there are %d biters.", concurrent_biters));
    while (!exit_now) {
      guard->wait();

LOG(istring(istring::SPRINTF, "locked guard!"));
      safe_add(grab_lock, 1);
      if (grab_lock > MAX_GRABBERS)
        deadly_error("semaphore test", "piranha", "grab lock was already active");

      portable::sleep_ms(rando.inclusive(20, 140));
  
      safe_add(grab_lock, -1);

LOG(istring(istring::SPRINTF, "unlocking guard!"));
      guard->signal();
    }
    safe_add(concurrent_biters, -1);
  }
};

class barracuda : public ithread
{
public:
  barracuda() : ithread() {}

  void perform_activity(void *) {
    file_logger log(LOGFILE_NAME);
    safe_add(concurrent_biters, 1);
LOG(istring(istring::SPRINTF, "there are %d biters.", concurrent_biters));
    while (!exit_now) {
      guard->wait();

LOG(istring(istring::SPRINTF, "locked guard!"));
      safe_add(grab_lock, 1);
      if (grab_lock > MAX_GRABBERS)
        deadly_error("semaphore test", "barracuda", "grab lock was already active");

      portable::sleep_ms(rando.inclusive(20, 140));
//do something different?
  
      safe_add(grab_lock, -1);

LOG(istring(istring::SPRINTF, "unlocking guard!"));
      guard->signal();
    }
    safe_add(concurrent_biters, -1);
  }
};

int main(int formal(argc), char *formal(argv)[])
{
  file_logger log(LOGFILE_NAME);

  guard = new semaphore(MAX_GRABBERS, MAX_GRABBERS);

  array<ithread *> threads;

  for (int i = 0; i < DEFAULT_FISH; i++) {
    if (i % 2) threads += new piranha;
    else threads += new barracuda;
  }
  for (int j = 0; j < threads.length(); j++) threads[j]->start(NIL);

  time_stamp when_to_leave(DEFAULT_RUN_TIME);
  while (when_to_leave > time_stamp()) { portable::sleep_ms(rando.inclusive(12, 200)); }

  LOG("now exiting from all threads....");

  exit_now = true;
  while (concurrent_biters > 0) { portable::sleep_ms(42); }

  LOG("done exiting from all threads....");

  delete guard;

  for (int k = 0; k < threads.length(); k++) threads[k]->stop();
  for (int m = 0; m < threads.length(); m++) delete threads[m];

  guards::alert_message("semaphore:: works for all functions tested.");
  return 0;
}

---