t_safe_list.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_safe_list                                                    *
*  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/chaos.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <data_struct/amorph.cpp>
#include <mechanisms/ithread.h>
#include <mechanisms/safe_roller.h>
#include <mechanisms/time_stamp.h>
#include <nodes/node.h>
#include <nodes/safe_list.h>
#include <nodes/safe_node.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;

using namespace nodes;

#define DEBUG_SAFE_LIST
  // uncomment this line to get more debugging output (into a file called
  // LOGFILE_NAME).

const int DEFAULT_LIFE_TIME = 4 * MINUTE_ms;
  // the amount of time the program runs by default.

chaos rando;

// the type we're storing in the list.

class t_node : public safe_node
{
public:
  int _int;

  t_node(int a = 0) : _int(a) {}
  operator int() const { return _int; }
  operator int() { return _int; }
  t_node &operator =(const t_node &to_copy)
      { _int = to_copy._int; return *this; }
  t_node &operator =(int to_copy) { _int = to_copy; return *this; }
};

#define CASTER(bare_node) static_cast<const t_node *>(bare_node)
  // takes a node pointer and turns it back into a pointer to a t_node.

static int thread_count = 0;
  // a variable that will be used to track how many threads are active.

const istring LOGFILE_NAME = path_configuration::make_logfile_name
    ("t_safe_list.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.

const int NUMBER_OF_CHECKERS = 8;
  // the number of threads checking the list simultaneously.

class adder_thread : public ithread
{
public:
  safe_list &_the_list;

  adder_thread(safe_list &the_list) : ithread(), _the_list(the_list) {}

  void perform_activity(void *) {
    safe_add(thread_count, 1);
//    safe_list *the_list = (safe_list *)hidden_pointer;
    file_logger log(LOGFILE_NAME);
LOG(istring(istring::SPRINTF, "adder is thread %d.", thread_count));

    // seek the correct insertion place to keep the list ordered.
    safe_list_write_iterator *iter = _the_list.open_writer();
    // select a random number to add to the list.
    int to_add = rando.inclusive(0, 100000);
    LOG(istring(istring::SPRINTF, "entering adder (%d).", to_add));
    while (!iter->is_tail() && iter->access()
        && (CASTER(iter->access())->operator int() <= to_add) )
      iter->next();
    _the_list.insert(*iter, new t_node(to_add));
    LOG("exiting adder.");
    _the_list.close_writer(iter);
    safe_add(thread_count, -1);
  }
};

class deleter_thread : public ithread
{
public:
  safe_list &_the_list;

  deleter_thread(safe_list &the_list) : ithread(), _the_list(the_list) {}

  void perform_activity(void *) {
    safe_add(thread_count, 1);
    file_logger log(LOGFILE_NAME);
LOG(istring(istring::SPRINTF, "deleter is thread %d.", thread_count));

    // start at the head of the list...
    safe_list_write_iterator *iter = _the_list.open_writer();
    LOG("entering deleter.");
    int elem = _the_list.elements(*iter);
    if (elem > 0) {
      int to_whack = rando.inclusive(0, elem - 1);
LOG(istring(istring::SPRINTF, "deleter sees %d items and will whack #%d.", elem, to_whack));
      // jump to the element we chose.
      while (--to_whack > 0) iter->next();
      if (!iter->access())
        deadly_error("deleter", "movement code", "not at the right index");
      LOG(istring(istring::SPRINTF, "zap (%d).",
          CASTER(iter->access())->operator int()));
      bool zap_it = rando.inclusive(0, 1);
      if (zap_it) _the_list.zap(*iter);
      else {
        safe_node *to_whack = _the_list.remove(*iter);
        WHACK(to_whack);
      }
    }
    LOG("exiting deleter.");
    _the_list.close_writer(iter);
    safe_add(thread_count, -1);
  }
};

static bool exit_now = false;
  // true if the program is in a shutting down state.

class checker_thread : public ithread
{
public:
  safe_list &_the_list;

  checker_thread(safe_list &the_list) : ithread(), _the_list(the_list) {}

  void perform_activity(void *) {
    safe_add(thread_count, 1);
    file_logger log(LOGFILE_NAME);
    LOG("entering checker.");
LOG(istring(istring::SPRINTF, "checker is thread %d.", thread_count));

    while (!exit_now) {
      // test the list invariant (which is that all elements should be sorted
      // in non-decreasing order).
      safe_list_read_iterator *iter = _the_list.open_reader(safe_list::TAIL);
LOG("thread got access with iter.");
      LOG("started checking list.");
      // we only bother to check the list if it's not empty.
      if (!_the_list.empty(*iter)) {
        // initialize our comparator.
        int bigger = CASTER(iter->observe())->operator int();
        // loop backwards until we hit the head.
        while (!iter->is_head()) {
          // check that the last value is not less than the current value.
          if (bigger < CASTER(iter->observe())->operator int())
            deadly_error("t_list", "invariant check",
                "found a mal-ordering in the list");
          bigger = CASTER(iter->observe())->operator int();
          iter->previous();
        }
      }
      LOG("finished checking list.");
LOG("thread giving up access with iter.");
      _the_list.close_reader(iter);
      int milliseconds_to_sleep = rando.inclusive(200, 828);
      time_stamp wake_up_time(milliseconds_to_sleep);
        // pause the thread until it's time to wake up (or leave).
      while (!exit_now && (time_stamp() < wake_up_time)) {
LOG("checker zzzz...");
        portable::sleep_ms(72);
      }
    }
    LOG("exiting checker.");
    safe_add(thread_count, -1);
  }
};
  
int main(int formal(argc), char *formal(argv)[])
{
  safe_list the_list;
  int time_to_run = DEFAULT_LIFE_TIME;
    // the time to run is how long the test will last.
//hmmm: get time to run from command line.

  file_logger log(LOGFILE_NAME);
  log.log(""); log.log(""); log.log("");  // some blank lines.
  LOG("starting test.");

  amorph<ithread> thread_list;

  // start the threads that check list integrity.
  for (int i = 0; i < NUMBER_OF_CHECKERS; i++)
    thread_list.append(new checker_thread(the_list));

  bool sleep_time = false;
    // are we in a sleepy mode where we don't create new threads?
  time_stamp run_until(time_to_run);
    // this is the time when we should get out of here.
  while (run_until > time_stamp()) {
    // do some random things to the list until it's time to get out.
    if (sleep_time) {
LOG("main loop zzzz...");
      portable::sleep_ms(84);
      // we have a chance to get out of sleep mode next time around.
      if (rando.inclusive(1, 100) > 95) {
        sleep_time = false;
        LOG("<waking up.>");
        exit_now = false;
      }
      continue;  // crank through loop again.
    }
    if (rando.inclusive(0, 100) == 58) {
      // we hit the magical sleeper period.
      sleep_time = true;
      LOG("<going to sleep.>");
      exit_now = true;  // tell all threads to exit during snoozy time.
      continue;
    }
    int selector = rando.inclusive(1, 100);
    // there's currently a 15% chance of adding an item, a 6% chance of
    // removing an item and a 21% chance of starting a checker..
    if ( (selector >= 14) && (selector <= 28) ) {
      LOG("launching an adder.");
      thread_list.append(new adder_thread(the_list));
    } else if ( (selector >= 69) && (selector <= 74) ) {
      LOG("launching a deleter.");
      thread_list.append(new deleter_thread(the_list));
    } else if ( (selector >= 29) && (selector <= 49) ) {
       LOG("launching a checker.");
      thread_list.append(new checker_thread(the_list));
    }
//hmmm: add more types of threads we could call.
  }

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

#ifdef DEBUG_SAFE_LIST
  safe_list_read_iterator *iter = the_list.open_reader();
  LOG("");
  LOG("safe_list contents:");
  if (the_list.empty(*iter)) {
    LOG("the list is empty.");
  } else {
    int indy = 0;
    while (!iter->is_tail()) {
      int item = CASTER(iter->observe())->operator int();
      LOG(istring(istring::SPRINTF, "item #%d: %d", indy, item));
      indy++;
      iter->next();
    }
  }
  the_list.close_reader(iter);
#endif
  LOG("exiting test");

  thread_list.reset();  // stop all the threads.

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

---