t_auto_synch.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_auto_synch                                                   *
*  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 <basis/chaos.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <basis/mutex.h>
#include <data_struct/amorph.cpp>
#include <mechanisms/ithread.h>
#include <mechanisms/safe_roller.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 = 142 * SECOND_ms;
  // 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 mutex.

mutex *guard;
  // the guard ensures that the grab lock isn't molested by two fish at
  // once... hopefully.

//hmmm: this should use a safe chaos object.

const istring LOGFILE_NAME = path_configuration::make_logfile_name
    ("t_auto_synch.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(0), log(LOGFILE_NAME)
  {
    safe_add(concurrent_biters, 1);
LOG(istring(istring::SPRINTF, "there are %d biters.", concurrent_biters));
  }

  ~piranha() { safe_add(concurrent_biters, -1); }

  void perform_activity(void *formal(data)) {
    auto_synchronizer l(*guard);

LOG("locked guard!");
    safe_add(grab_lock, 1);
    if (grab_lock > 1)
      deadly_error("auto_synch test", "piranha", "grab lock was already active");

    portable::sleep_ms(rando.inclusive(20, 140));

    safe_add(grab_lock, -1);

LOG("unlocking guard!");
  }

private:
  file_logger log;
};

class barracuda : public ithread
{
public:
  barracuda() : ithread(0), log(LOGFILE_NAME) {
    safe_add(concurrent_biters, 1);
LOG(istring(istring::SPRINTF, "there are %d biters.", concurrent_biters));
  }

  ~barracuda() { safe_add(concurrent_biters, -1); }

  void perform_activity(void *formal(data)) {
    auto_synchronizer l(*guard);

LOG("locked guard!");
    safe_add(grab_lock, 1);
    if (grab_lock > 1)
      deadly_error("auto_synch test", "barracuda", "grab lock was already active");

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

LOG("unlocking guard!");
  }

private:
  file_logger log;
};

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

  guard = new mutex();

  amorph<ithread> thread_list;

  for (int i = 0; i < DEFAULT_FISH; i++) {
    if (i % 2) thread_list.append(new piranha);
    else thread_list.append(new barracuda);
    // start the thread we added.
    thread_list[thread_list.elements() - 1]->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....");

  // stop all the threads.  if we just reset the amorph, bad things happen,
  // possibly because a destructor can't manage threads in this way?  or
  // because the thread is using a mutex inside a destructor???
  for (int j = 0; j < thread_list.elements(); j++) thread_list[j]->stop();
  thread_list.reset();  // should stop and whack all threads.

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

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

  delete guard;

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

---