t_mutex.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_mutex                                                        *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1994-$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 <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <opsystem/path_configuration.h>
#include <data_struct/static_memory_gremlin.h>

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

const int MAX_MUTEX_TIMING_TEST = 2000000;
  // the number of times we'll lock and unlock a mutex.

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

const int DEFAULT_RUN_TIME = 20 * SECOND_ms;
  // the length of time to run the program.

const int THREAD_PAUSE_LOWEST = 0;
const int THREAD_PAUSE_HIGHEST = 48;
  // this is the range of random sleeps that a thread will take after
  // performing it's actions.

const int MIN_SAME_THREAD_LOCKING_TESTS = 100;
const int MAX_SAME_THREAD_LOCKING_TESTS = 1000;
  // the range of times we'll test recursively locking the mutex.

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() { static mutex _muttini; return _muttini; }
  // the guard ensures that the grab lock isn't molested by two fish at
  // once... hopefully.

istring protected_string;
  // this string is protected only by the mutex of guard().

#define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger(), to_print)
  // our macro for logging with a timestamp.

// expects guardian mutex to already be locked once when coming in.
void test_recursive_locking(chaos &_rando)
{
  int test_attempts = _rando.inclusive(MIN_SAME_THREAD_LOCKING_TESTS,
      MAX_SAME_THREAD_LOCKING_TESTS);
  int locked = 0;
  for (int i = 0; i < test_attempts; i++) {
    bool lock = !!(_rando.inclusive(0, 1));
    if (lock) {
      guard().lock();
      locked++;  // one more lock.
    } else {
      if (locked > 0) {
        // must be sure we are not already locally unlocked completely.
        guard().unlock();
        locked--;
      }
    }
  }
  for (int j = 0; j < locked; j++) {
    // drop any locks we had left during the test.
    guard().unlock();
  }
}

//hmmm: how are these threads different so far?  they seem to do exactly
//      the same thing.  maybe one should eat chars from the string.

class piranha : public ithread
{
public:
  chaos _rando;  // our randomizer.

  piranha() : ithread(0) {
    FUNCDEF("constructor");
    safe_add(concurrent_biters, 1);
//LOG(istring(istring::SPRINTF, "there are %d biters.", concurrent_biters));
  }

  virtual ~piranha() {
    FUNCDEF("destructor");
    safe_add(concurrent_biters, -1); 
//LOG("reached piranha destructor.");
  }

  IMPLEMENT_CLASS_NAME("piranha");

  void perform_activity(void *formal(data)) {
    FUNCDEF("perform_activity");
    // we grab the lock.
    guard().lock();
    safe_add(grab_lock, 1);
    if (grab_lock > 1)
      deadly_error(class_name(), func, "grab lock was already active");
    protected_string += char(_rando.inclusive('a', 'z'));

    test_recursive_locking(_rando);

    safe_add(grab_lock, -1);
    guard().unlock();
    // dropped the lock.  snooze a bit.
    if (!should_stop())
      portable::sleep_ms(_rando.inclusive(THREAD_PAUSE_LOWEST, THREAD_PAUSE_HIGHEST));
  }

};

class barracuda : public ithread
{
public:
  chaos _rando;  // our randomizer.

  barracuda() : ithread(0) {
    FUNCDEF("constructor");
    safe_add(concurrent_biters, 1);
//LOG(istring(istring::SPRINTF, "there are %d biters.", concurrent_biters));
  }

  virtual ~barracuda() {
    FUNCDEF("destructor");
     safe_add(concurrent_biters, -1);
//LOG("reached barracuda destructor.");
  }

  IMPLEMENT_CLASS_NAME("barracuda");

  void perform_activity(void *formal(data)) {
    FUNCDEF("perform_activity");
    // we grab the lock.
    guard().lock();
    safe_add(grab_lock, 1);
    if (grab_lock > 1)
      deadly_error(class_name(), func, "grab lock was already active");

    test_recursive_locking(_rando);

    protected_string += char(_rando.inclusive('a', 'z'));
    safe_add(grab_lock, -1);
    guard().unlock();
    // done with the lock.  sleep for a while.
    if (!should_stop())
      portable::sleep_ms(_rando.inclusive(THREAD_PAUSE_LOWEST, THREAD_PAUSE_HIGHEST));
  }
};


class test_mutex : public application_shell
{
public:
  chaos _rando;  // our randomizer.

  test_mutex() : application_shell(class_name()) {}

  IMPLEMENT_CLASS_NAME("test_mutex");

  int execute();
};

int test_mutex::execute()
{
  FUNCDEF("execute");

  {
    // we check how long a lock and unlock of a non-locked mutex will take.
    // this is important to know so that we aren't spending much of our time
    // locking mutexes just due to the mechanism.
    mutex ted;
    time_stamp mutt_in;
    for (int qb = 0; qb < MAX_MUTEX_TIMING_TEST; qb++) {
      ted.lock();
      ted.unlock();
    }
    time_stamp mutt_out;
    log(isprintf("%d mutex lock & unlock pairs took %f seconds,",
        MAX_MUTEX_TIMING_TEST,
        (mutt_out.value() - mutt_in.value()) / SECOND_ms));
    log(isprintf("or %f ms per (lock+unlock).",
        (mutt_out.value() - mutt_in.value()) / MAX_MUTEX_TIMING_TEST));
  }

  // make sure the guard is initialized before the threads run.
  guard().lock();
  guard().unlock();

  amorph<ithread> thread_list;

  for (int i = 0; i < DEFAULT_FISH; i++) {
    ithread *t = NIL;
    if (i % 2) t = new piranha;
    else t = new barracuda;
    thread_list.append(t);
    ithread *q = thread_list[thread_list.elements() - 1];
    if (q != t)
      deadly_error(class_name(), func, "amorph has incorrect pointer!");
    // 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(100);
  }

//hmmm: try just resetting the amorph;
//      that should work fine.

  LOG("now cancelling all threads....");

  for (int j = 0; j < thread_list.elements(); j++) thread_list[j]->cancel();

  LOG("now stopping all threads....");

  for (int k = 0; k < thread_list.elements(); k++) thread_list[k]->stop();

  LOG("resetting thread list....");

  thread_list.reset();  // should whack all threads.

  if (concurrent_biters != 0)
    deadly_error(class_name(), func, "threads were still active supposedly!");

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

  LOG(istring(istring::SPRINTF, "the accumulated string had %d characters "
      "which means\nthere were %d thread activations from %d threads.",
      protected_string.length(), protected_string.length(),
      DEFAULT_FISH));

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

HOOPLE_MAIN(test_mutex, )

---