t_thread.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_thread                                                       *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Checks that the ithread behaves properly.                                *
*                                                                             *
*******************************************************************************
* 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/guards.h>
#include <data_struct/amorph.cpp>
#include <mechanisms/ithread.h>
#include <mechanisms/time_stamp.h>
#include <loggers/console_logger.h>
#include <data_struct/static_memory_gremlin.h>

#include <stdio.h>

HOOPLE_STARTUP_CODE;

const int MAX_SIMULTANEOUS_THREADS = 432;
  // we will create this many threads simultaneously.

const int THREAD_INTERVAL = 84;  // how frequently the thread runs.

#define PWL program_wide_logger()

class one_shot : public ithread
{
public:
  one_shot() : ithread() {}

  virtual void perform_activity(void *) {
    PWL.log("one shot in.");
    portable::sleep_ms(20);
    PWL.log("one shot out.");
  }

private:
};

class periodontic : public ithread
{
public:
  periodontic(int interval, timed_thread_types eval)
      : ithread(interval, eval) {}

  virtual void perform_activity(void *) {
    PWL.log(istring("bing at: ") + timestamp(false, true));
    portable::sleep_ms(200);
  }
};

class sporadicus : public ithread
{
public:
  sporadicus(timed_thread_types eval)
      : ithread(20, eval) {}

  virtual void perform_activity(void *) {
    PWL.log(".");
  }
};

class snoozer : public ithread
{
public:
  snoozer() : ithread(THREAD_INTERVAL, ithread::SLACK_INTERVAL) {}

  virtual void perform_activity(void *) {
    // do something.
    time_stamp quit;
  }
};

int main(int formal(argc), char *formal(argv)[])
{
  SET_DEFAULT_CONSOLE_LOGGER;

  one_shot once_thread;
  once_thread.start(NIL);
  portable::sleep_ms(200);
  once_thread.stop();
  PWL.log("two messages should be above from one shot thread.\n");

  once_thread.start(NIL);
  portable::sleep_ms(200);
  once_thread.stop();
  PWL.log("two messages should be above from one shot thread.\n");

  periodontic tighty(1000, ithread::TIGHT_INTERVAL);
  tighty.start(NIL);
  portable::sleep_ms(10 * SECOND_ms);
  tighty.stop();
  PWL.log("messages above should tightly adhere to one second clicks.\n");

  periodontic slacky(1400, ithread::SLACK_INTERVAL);
  slacky.start(NIL);
  portable::sleep_ms(10 * SECOND_ms);
  slacky.stop();
  PWL.log("messages above should be about 1.4 seconds apart.\n");

  sporadicus spood(ithread::TIGHT_INTERVAL);
  PWL.eol(log_base::NO_ENDING);
  spood.start(NIL);
  portable::sleep_ms(14 * SECOND_ms);
  PWL.eol(log_base::CRLF_AT_END);
  PWL.log("");
  PWL.log("stopping spood");
  spood.stop();
  PWL.log("stopped spood");

  amorph<snoozer> snoozies;
  for (int i = 0; i < MAX_SIMULTANEOUS_THREADS; i++) {
    snoozer *newby = new snoozer;
    snoozies += newby;
  }
  PWL.log(isprintf("created %d threads.", snoozies.elements()));
  for (int i = 0; i < MAX_SIMULTANEOUS_THREADS; i++) {
    snoozies.borrow(i)->start(NIL);
  }
  PWL.log(isprintf("started %d threads.", snoozies.elements()));

  time_stamp when_to_leave(1 * MINUTE_ms);
  PWL.log("now running the threads...");
  while (time_stamp() < when_to_leave) {
    portable::sleep_ms(200);
  }

  guards::alert_message("ithread:: works for all functions tested (if messages seem appropriate).");

  return 0;
}

---