t_rw_lock.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_reader_writer_lock                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1997-$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 <basis/mutex.h>
#include <mechanisms/ithread.h>
#include <mechanisms/safe_roller.h>
#include <mechanisms/rw_lock.h>
#include <mechanisms/time_stamp.h>
#include <opsystem/application_shell.h>
#include <opsystem/path_configuration.h>
#include <data_struct/static_memory_gremlin.h>

HOOPLE_STARTUP_CODE;

//#define DEBUG_RW_LOCK
  // uncomment if you want a noisy debugging version.  careful; this can
  // change the interaction properties of the threads because it introduces
  // some delays and some file lockings where there would be none otherwise.

typedef int protectee;
  // the type we're protecting with a reader / writer lock.

const int DEFAULT_LIFE_TIME = 2 * MINUTE_ms;
  // the length of time the test runs.

const int NUMBER_OF_CHECKERS = 28;
  // the guys who check the value.

//hmmm: fix the logging to use the real debug macros.


chaos rando;


// this class could easily be part of the tester object but is separate for
// no real reason.

class hold_globals
{
public:
  hold_globals();
  ~hold_globals();
  
  // data accessed by the threads...

  time_stamp when_to_exit; // when the program should vamoose by.
  bool sleep_mode;  // are we in sleepy mode where we don't create new threads?
  reader_writer_lock protection;
    // the synchronization mechanism we're testing.
  bool exit_now;  // true if the program is in a shutting down state.
  int thread_count;
    // a variable that will be used to track how many threads are active.
  protectee safe_guy;
    // the object protected by our lock.
};

hold_globals::hold_globals()
: when_to_exit(DEFAULT_LIFE_TIME),
//hmmm: get time to run from command line.
  sleep_mode(false),
  protection(),
  exit_now(false),
  thread_count(0),
  safe_guy(0)
{
}

hold_globals::~hold_globals()
{
}

static hold_globals global_data;


// forward.
class test_rw_lock;

// the thread that keeps the test doing stuff occasionally.
class rw_lock_thread : public ithread
{
public:
  test_rw_lock &_parent;  // the main class.
  rw_lock_thread(test_rw_lock &parent) : ithread(100), _parent(parent) {}
  void perform_activity(void *unused);
};

// the thread that adds to the thingy.
class adder_thread : public ithread
{
public:
  test_rw_lock &_parent;
  adder_thread(test_rw_lock &parent) : ithread(), _parent(parent) {}
  void perform_activity(void *non);
};

class checker_thread : public ithread
{
public:
  test_rw_lock &_parent;
  checker_thread(test_rw_lock &parent) : ithread(), _parent(parent) {}
  void perform_activity(void *non);
};


class test_rw_lock : public application_shell
{
public:
  test_rw_lock() : application_shell("t_rw_lock"), _periodic(*this) {}

  IMPLEMENT_CLASS_NAME("test_rw_lock");

  virtual ~test_rw_lock() {
    _periodic.stop();
    for (int i = 0; i < _threads.length(); i++) _threads[i]->stop();
    for (int k = 0; k < _threads.length(); k++) WHACK(_threads[k]);
  }

  int execute();

  void add_thread(ithread *to_add);
    // the thread "to_add" is added to our list and started.

private:
  rw_lock_thread _periodic;  // drives the periodic activities here.
  mutex _list_lock;  // protects the threads list.
  array<ithread *> _threads;  // tracks our guys.
};


#undef LOG
#ifdef DEBUG_RW_LOCK
  // our thread's macro for logging with a timestamp.
  #define LOG(to_print) _parent.log(timestamp(true) + istring(to_print))
#else
  #define LOG(to_print) {}
#endif

void rw_lock_thread::perform_activity(void *formal(unused)) {
  // make sure it's not time to leave.
  if (global_data.when_to_exit < time_stamp()) {
    // get out now.
//      PostMessage(WM_CLOSE);
    cancel();
    return;
  }

  // do something random to the list.
  if (global_data.sleep_mode) {
    // we have a chance to get out of sleep mode next time around.
LOG("main loop zzzz...");
    if (rando.inclusive(1, 100) > 95) global_data.sleep_mode = false;
    if (!global_data.sleep_mode) { LOG("<waking up.>"); }
  } else if (rando.inclusive(0, 100) == 58) {
    // we hit the magical sleeper period.
    global_data.sleep_mode = true;
    LOG("<going to sleep.>");
  } else {
    int selector = rando.inclusive(1, 100);
    // there's currently a 15% chance of adding an item and a 6% chance of
    // removing an item.
    if ( (selector >= 14) && (selector <= 28) ) {
      LOG("launching an adder.");
      _parent.add_thread(new adder_thread(_parent));
//    } else if ( (selector >= 69) && (selector <= 74) ) {
//       LOG("launching a deleter.");
//      _beginthread(deleter_thread, 0, this);
    }
//hmmm: add more types of threads we could call.
  }
}


void adder_thread::perform_activity(void *)
{
  safe_add(global_data.thread_count, 1);
LOG(istring(istring::SPRINTF, "adder is thread %d.", global_data.thread_count));

  global_data.protection.begin_write();
  global_data.safe_guy++;
LOG(istring(istring::SPRINTF, "in write: adder incrementing to %d.", global_data.safe_guy));
  global_data.protection.end_write();

LOG("exiting adder");
  safe_add(global_data.thread_count, -1);
}


void checker_thread::perform_activity(void *) {
  safe_add(global_data.thread_count, 1);
LOG(istring(istring::SPRINTF, "checker is thread %d.", global_data.thread_count));

  protectee val = 0;

  while (!global_data.exit_now) {
    // test the invariant that the value is always increasing.
    global_data.protection.begin_read();
LOG("in reader: got read access.");
    if (global_data.safe_guy < val)
      deadly_error("checker", "test", "value was not increasing!");
    val = global_data.safe_guy;
LOG("in reader: giving up read access.");
    global_data.protection.end_read();
LOG("in reader: after gave up read access.");

    int milliseconds_to_sleep = rando.inclusive(200, 828);
    portable::sleep_ms(milliseconds_to_sleep);
//testing.

//    time_stamp wake_up_time(milliseconds_to_sleep);
//      // pause the thread until it's time to wake up (or leave).
//    while (!global_data.exit_now && (time_stamp() < wake_up_time)) {
//      portable::sleep_ms(0);
//    }
  }
  LOG("exiting checker.");
  safe_add(global_data.thread_count, -1);
}


#undef LOG
#ifdef DEBUG_RW_LOCK
  #define LOG(to_print) log(timestamp(true) + istring(to_print))
#else
  #define LOG(to_print) {}
#endif

void test_rw_lock::add_thread(ithread *to_add)
{
  auto_synchronizer l(_list_lock);
  _threads += to_add;
  to_add->start(NIL);
}

int test_rw_lock::execute()
{
  log(""); log(""); log("");  // some blank lines.
  LOG("starting test.");
  log("testing in progress...  please hang on.");

  _periodic.start(NIL);

  // start the threads that check list integrity.
  for (int i = 0; i < NUMBER_OF_CHECKERS; i++)
    _threads += new checker_thread(*this);

  while (time_stamp() < global_data.when_to_exit) {
    // not goodbye yet.
    portable::sleep_ms(42);
  }

  global_data.exit_now = true;  // set the thread go bye-bye state.

  // wait until all the threads have exited.
  LOG("now exiting from all threads...");
  while (global_data.thread_count > 0) { portable::sleep_ms(0); }
  LOG("done exiting from all threads.");

  LOG("ending test.");
  _periodic.stop();
  log("test completed.");

  guards::alert_message("reader_writer_lock:: works for those functions tested.");
  return 0;
}


int main(int formal(argc), char *formal(argv)[])
{
  test_rw_lock tester;
  return tester.execute();
}

---