--- /dev/null
+/*****************************************************************************\
+* *
+* 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 <application/hoople_main.h>
+#include <basis/astring.h>
+#include <basis/guards.h>
+#include <basis/mutex.h>
+#include <configuration/application_configuration.h>
+#include <loggers/critical_events.h>
+#include <loggers/program_wide_logger.h>
+#include <mathematics/chaos.h>
+#include <processes/ethread.h>
+#include <processes/safe_roller.h>
+#include <structures/amorph.h>
+#include <structures/static_memory_gremlin.h>
+#include <timely/time_control.h>
+#include <timely/time_stamp.h>
+#include <unit_test/unit_base.h>
+
+#ifdef __WIN32__
+ #include <process.h>
+#endif
+
+using namespace application;
+using namespace basis;
+using namespace loggers;
+using namespace mathematics;
+using namespace timely;
+using namespace processes;
+using namespace structures;
+using namespace unit_test;
+
+//#define DEBUG_MUTEX
+ // uncomment for a verbose test run.
+
+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 = 2 * 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.
+
+astring protected_string;
+ // this string is protected only by the mutex of guard().
+
+#define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger::get(), 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.
+
+#undef UNIT_BASE_THIS_OBJECT
+#define UNIT_BASE_THIS_OBJECT c_testing
+
+class piranha : public ethread
+{
+public:
+ chaos _rando; // our randomizer.
+ unit_base &c_testing; // provides for test recording.
+
+ piranha(unit_base &testing) : ethread(0), c_testing(testing) {
+ FUNCDEF("constructor");
+ safe_add(concurrent_biters, 1);
+ ASSERT_TRUE(concurrent_biters >= 1, "the piranha is very noticeable");
+//LOG(astring(astring::SPRINTF, "there are %d biters.", concurrent_biters));
+ }
+
+ virtual ~piranha() {
+ FUNCDEF("destructor");
+ safe_add(concurrent_biters, -1);
+//LOG("reached piranha destructor.");
+ }
+
+ DEFINE_CLASS_NAME("piranha");
+
+ void perform_activity(void *formal(data)) {
+ FUNCDEF("perform_activity");
+ {
+ // we grab the lock.
+ auto_synchronizer locked(guard());
+ // in this case, we make use of auto-synchronizer, handily testing it as well.
+ ASSERT_TRUE(&locked != NIL, "auto_synchronizer should grab the mutex object's lock");
+ // this is not a real test, but indicates that we did actually increase the number of
+ // unit tests by one, since we're using auto_synchronizer now.
+ safe_add(grab_lock, 1);
+ ASSERT_TRUE(grab_lock <= 1, "grab lock should not already be active");
+ protected_string += char(_rando.inclusive('a', 'z'));
+
+ test_recursive_locking(_rando);
+
+ safe_add(grab_lock, -1);
+ }
+ // dropped the lock. snooze a bit.
+ if (!should_stop())
+ time_control::sleep_ms(_rando.inclusive(THREAD_PAUSE_LOWEST, THREAD_PAUSE_HIGHEST));
+ }
+
+};
+
+class barracuda : public ethread
+{
+public:
+ chaos _rando; // our randomizer.
+ unit_base &c_testing; // provides for test recording.
+
+ barracuda(unit_base &testing) : ethread(0), c_testing(testing) {
+ FUNCDEF("constructor");
+ safe_add(concurrent_biters, 1);
+ ASSERT_TRUE(concurrent_biters >= 1, "our presence should have been noticed");
+//LOG(astring(astring::SPRINTF, "there are %d biters.", concurrent_biters));
+ }
+
+ virtual ~barracuda() {
+ FUNCDEF("destructor");
+ safe_add(concurrent_biters, -1);
+//LOG("reached barracuda destructor.");
+ }
+
+ DEFINE_CLASS_NAME("barracuda");
+
+ void perform_activity(void *formal(data)) {
+ FUNCDEF("perform_activity");
+ // we grab the lock.
+ guard().lock();
+ safe_add(grab_lock, 1);
+ ASSERT_TRUE(grab_lock <= 1, "grab lock should not already be 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())
+ time_control::sleep_ms(_rando.inclusive(THREAD_PAUSE_LOWEST, THREAD_PAUSE_HIGHEST));
+ }
+};
+
+//////////////
+
+#undef UNIT_BASE_THIS_OBJECT
+#define UNIT_BASE_THIS_OBJECT (*this)
+
+class test_mutex : virtual public unit_base, virtual public application_shell
+{
+public:
+ chaos _rando; // our randomizer.
+
+ test_mutex() : application_shell() {}
+
+ DEFINE_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;
+ double run_count = MAX_MUTEX_TIMING_TEST;
+ double full_run_time = (mutt_out.value() - mutt_in.value()) / SECOND_ms;
+ double time_per_lock = (mutt_out.value() - mutt_in.value()) / run_count;
+ log(a_sprintf("%.0f mutex lock & unlock pairs took %.3f seconds,",
+ run_count, full_run_time));
+ log(a_sprintf("or %f ms per (lock+unlock).", time_per_lock));
+ ASSERT_TRUE(time_per_lock < 1.0, "mutex lock timing should be super fast");
+ }
+
+ // make sure the guard is initialized before the threads run.
+ guard().lock();
+ guard().unlock();
+
+ amorph<ethread> thread_list;
+
+ for (int i = 0; i < DEFAULT_FISH; i++) {
+ ethread *t = NIL;
+ if (i % 2) t = new piranha(*this);
+ else t = new barracuda(*this);
+ thread_list.append(t);
+ ethread *q = thread_list[thread_list.elements() - 1];
+ ASSERT_EQUAL(q, t, "amorph pointer equivalence is required");
+ // 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()) {
+ time_control::sleep_ms(100);
+ }
+
+//hmmm: try just resetting the amorph;
+// that should work fine.
+
+#ifdef DEBUG_MUTEX
+ LOG("now cancelling all threads....");
+#endif
+
+ for (int j = 0; j < thread_list.elements(); j++) thread_list[j]->cancel();
+
+#ifdef DEBUG_MUTEX
+ LOG("now stopping all threads....");
+#endif
+
+ for (int k = 0; k < thread_list.elements(); k++) thread_list[k]->stop();
+
+ int threads_active = 0;
+ for (int k = 0; k < thread_list.elements(); k++) {
+ if (thread_list[k]->thread_active()) threads_active++;
+ }
+ ASSERT_EQUAL(threads_active, 0, "threads should actually have stopped by now");
+
+#ifdef DEBUG_MUTEX
+ LOG("resetting thread list....");
+#endif
+
+ thread_list.reset(); // should whack all threads.
+
+ ASSERT_EQUAL(concurrent_biters, 0, "threads should all be gone by now");
+
+#ifdef DEBUG_MUTEX
+ LOG("done exiting from all threads....");
+
+ LOG(astring(astring::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));
+#endif
+
+ return final_report();
+}
+
+HOOPLE_MAIN(test_mutex, )
+
projects / feisty_meow.git / blobdiff