t_object_catalog.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_object_catalog                                               *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1998-$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 <basis/portable.h>
#include <data_struct/unique_id.h>
#include <mechanisms/ithread.h>
#include <mechanisms/safe_roller.h>
#include <mechanisms/time_stamp.h>
#include <nodes/node.h>
#include <nodes/catalogable.h>
#include <nodes/object_catalog.h>
#include <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <loggers/file_logger.h>
#include <opsystem/path_configuration.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/string_manipulation.h>

using namespace nodes;

//#define DEBUG_OBJECT_CATALOG
  // uncomment this line to get more debugging output.

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

const int SHELL_SLEEP = 100;
  // the interval between the main shell's awakenings.  it will only check
  // whether it's time to leave at this rate.

const int PRESIDENT_SLEEP = 142;
  // pause between calls of president, in ms.

const int LOGGING_INTERVAL = 500;
  // the number of milliseconds between each dump of the log.

// our macro for logging with a timestamp.
#define LOG(to_print) program_wide_logger().log(timestamp(true) \
    + istring(to_print))
#ifdef DEBUG_OBJECT_CATALOG
  #define MAYBE_LOG(to_print) LOG(to_print)
#else
  #define MAYBE_LOG(to_print) {}
#endif


chaos rando;  // generates random numbers.

istring random_name()
{
  static mutex muttzilla;
  auto_synchronizer l(muttzilla);
  return string_manipulation::make_random_name(4, 28);
}

static safe_roller rollo(1, MAXINT - 2);


static int president_thread_id = 0;
  // this holds onto the president thread's identity so we can stop the whole
  // process when we want to.

static bool exit_now = false;
  // true when the main shell decides the run time has elapsed.

// these are the shelves and bins that the workers manage.
static object_catalog east_shelf;
static object_catalog new_product_bin;
static object_catalog north_shelf;
static object_catalog trash_bin;
static object_catalog west_shelf;

// here's where all the assistants are "stored".
static object_catalog *thread_bin = new object_catalog;


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

class inventory_item : public nodes::catalogable
{
public:
  inventory_item(const unique_int &id, const istring &name, int count)
      : nodes::catalogable(id), _count(count), _name(name) {}

  bool valid() const { return !!_name && (_count > 0); }

  istring catalogable_name() const { return _name; }

  istring text_form() const { return istring(istring::SPRINTF, "O: id %d, "
      "name %s, count %d", id().raw_id(), _name.s(), _count); }

  int count() const { return _count; }
  void count(int new_count) { _count = new_count; }
  istring name() const { return _name; }
  void name(const istring &new_name) { _name = new_name; }

  inventory_item *split_off(int to_split);
    // returns an inventory item by splitting out "to_split" items from this
    // inventory_item.  if there are not enough items to do that, the item
    // will be invalid.

  bool join(inventory_item &to_join);
    // merges the inventory_item in "to_join" with this one.  the item "to_join"
    // is drained of its count and invalidated.  this fails if "to_join" is
    // a different type of item than this; only items with the same name and
    // id can be joined.

private:
  int _count;  // how many of this object there are.
  istring _name;  // the name of this type of object.
};


inventory_item *inventory_item::split_off(int to_split)
{
  if (to_split <= 0) return NIL;
  if (to_split > count()) return NIL;
  inventory_item *to_return = new inventory_item(id(), "", 0);
  to_return->name(_name);
  to_return->count(to_split);
  count(count() - to_split);
  return to_return;
}

bool inventory_item::join(inventory_item &to_join)
{
  if (to_join.id() != id()) return false;
  if (to_join.name() != name()) return false;
  count(count() + to_join.count());
  to_join.count(0);
  to_join.name("");
  return true;
}


bool restock(object_catalog &list, inventory_item *to_add)
{
  if (!to_add) return false;
  objcat_iterator *found = list.find(to_add->id());
  if (found) {
    // it's an existing item that we need to merge.
    objcat_locket *l = found->open_locket();
    inventory_item *iti = dynamic_cast<inventory_item *>(&l->cat());
    bool ret = iti->join(*to_add);
    found->close_locket(l);
    list.iter_unlock(found);
    WHACK(to_add);
    return ret;
  }
  list.add(to_add);
  return true;
}


class stocker_thread : public ithread, public nodes::catalogable
{
public:
  stocker_thread(int sleep)
      : ithread(sleep), nodes::catalogable(rollo.next_id()) {}
  void perform_activity(void *thread_data);
  IMPLEMENT_CLASS_NAME("stocker_thread");
  istring catalogable_name() const
      { return istring(istring::SPRINTF, "stocker_%d", id().raw_id()); }
};

void stocker_thread::perform_activity(void *)
{
  int do_what = rando.inclusive(1, 100);
//this might really be the inventor's task.  the buyer should look at
//what's available to buy...
  if (do_what < 40) {
    // buy an item for inventory.
    inventory_item *to_add = new inventory_item(rollo.next_id(), random_name(),
        rando.inclusive(1, 200));
    istring name = to_add->name();
    int which_bin = rando.inclusive(1, 3);
    switch (which_bin) {
      case 1: restock(east_shelf, to_add); break;
      case 2: restock(west_shelf, to_add); break;
      case 3: restock(north_shelf, to_add); break;
    }
    MAYBE_LOG(istring(istring::SPRINTF, "%s created a new \"%s\".",
        catalogable_name().s(), name.s()));
  } else {
    // drink coffee and eat doughnuts.
  }
}


class rearranger_thread : public ithread, public nodes::catalogable
{
public:
  rearranger_thread(int sleep)
      : ithread(sleep), nodes::catalogable(rollo.next_id()) {}
  void perform_activity(void *thread_data);
  IMPLEMENT_CLASS_NAME("rearranger_thread");
  istring catalogable_name() const
      { return istring(istring::SPRINTF, "rearranger_%d", id().raw_id()); }
};

void rearranger_thread::perform_activity(void *)
{
  if (rando.inclusive(1, 100) > 38) return;  // do nothing this time.
  object_catalog *source = NIL;
  istring src_name;
  object_catalog *destination = NIL;
  istring dest_name;
  int src_bin = rando.inclusive(1, 4);
  switch (src_bin) {
    case 1: source = &west_shelf; src_name = "west_shelf"; break;
    case 2: source = &east_shelf; src_name = "east_shelf"; break;
    case 3: source = &north_shelf; src_name = "north_shelf"; break;
    case 4: source = &trash_bin; src_name = "trash_bin"; break;
  }
  int dest_bin = src_bin;
  while (src_bin == dest_bin) dest_bin = rando.inclusive(1, 4);
  switch (dest_bin) {
    case 1: destination = &west_shelf; dest_name = "west_shelf"; break;
    case 2: destination = &east_shelf; dest_name = "east_shelf"; break;
    case 3: destination = &north_shelf; dest_name = "north_shelf"; break;
    case 4: destination = &trash_bin; dest_name = "trash_bin"; break;
  }
  objcat_iterator *iter = source->find_head();
  int elems = source->elements(*iter);
  if (!elems) {
    // nothing to move, so leave.
    source->iter_unlock(iter);
    return;
  }
  int which = rando.inclusive(0, elems - 1);
  for (int i = which; i > 0; i--) {
    iter->next(); 
    if (iter->is_tail())
      deadly_error("test_object_catalog", "rearranger", "iter count is at "
          "tail unexpectedly");
  }
  if (!iter->cat())
    deadly_error("test_object_catalog", "rearranger", "iter is at nil node");
  unique_int id_to_get = iter->cat()->id();
  source->iter_unlock(iter);
  inventory_item *iti = dynamic_cast<inventory_item *>
      (source->acquire(id_to_get));
  if (!iti) {
    // could not acquire an item to move; this is probably not an error but
    // it is a bit rare.
    return;
  }
  istring name = iti->name();
  unique_int id = iti->id();
  restock(*destination, iti);
  MAYBE_LOG(istring(istring::SPRINTF, "%s moved item %s with id %d "
      "from %s to %s.", catalogable_name().s(), name.s(), id.raw_id(),
      src_name.s(), dest_name.s()));
}


class inspector_thread : public ithread, public nodes::catalogable
{
public:
  inspector_thread(int sleep)
      : ithread(sleep), nodes::catalogable(rollo.next_id()) {}
  void perform_activity(void *thread_data);
  IMPLEMENT_CLASS_NAME("inspector_thread");
  istring catalogable_name() const
      { return istring(istring::SPRINTF, "inspector_%d", id().raw_id()); }
};

void inspector_thread::perform_activity(void *)
{
  if (rando.inclusive(1, 100) > 32) return;  // do nothing this time.
  object_catalog *source = NIL;
  istring src_name;
  int src_bin = rando.inclusive(1, 4);
  switch (src_bin) {
    case 1: source = &west_shelf; src_name = "west_shelf"; break;
    case 2: source = &east_shelf; src_name = "east_shelf"; break;
    case 3: source = &north_shelf; src_name = "north_shelf"; break;
    case 4: source = &trash_bin; src_name = "trash_bin"; break;
  }
  // get the ids in this list.
  array<unique_int> inspection_list;
  objcat_iterator *iter = source->find_head();
  for ( ; !iter->is_tail(); iter->next())
    if (iter->cat()) inspection_list += iter->cat()->id();
  source->iter_unlock(iter);
  // scramble the list of ids so we do them in unknown order.
  for (int i = 0; i < inspection_list.length() * 4; i++) {
    int from = rando.inclusive(0, inspection_list.length() - 1);
    int to = rando.inclusive(0, inspection_list.length() - 1);
    unique_int intermediate = inspection_list[from];
    inspection_list[from] = inspection_list[to];
    inspection_list[to] = intermediate;
  }
  while (inspection_list.length()) {
    unique_int examine = inspection_list[0];
    inspection_list.zap(0, 0);
    objcat_iterator *found = source->find(examine);
    if (!found) continue;  // moved or gone by now.
    objcat_isolater *iso = source->separate(found);
    istring name = iso->cat().catalogable_name();
    int sleep = rando.inclusive(100, 380);
    portable::sleep_ms(sleep);
    source->rejoin(iso);
    MAYBE_LOG(istring(istring::SPRINTF, "%s inspected item %s with id %d "
        "from %s.", catalogable_name().s(), name.s(), examine.raw_id(),
        src_name.s()));
    if (should_stop()) return;
  }
}


class consumer_thread : public ithread, public nodes::catalogable
{
public:
  consumer_thread(int sleep)
      : ithread(sleep), nodes::catalogable(rollo.next_id()) {}
  void perform_activity(void *thread_data);
  IMPLEMENT_CLASS_NAME("consumer_thread");
  istring catalogable_name() const
      { return istring(istring::SPRINTF, "consumer_%d", id().raw_id()); }
};

// this is a simple note of what was purchased.
struct purchase_record { int count; istring name; };

void consumer_thread::perform_activity(void *)
{
  if (rando.inclusive(1, 100) > 28) return;  // do nothing this time.
  object_catalog *source = NIL;
  istring src_name;
  int src_bin = rando.inclusive(1, 4);
  switch (src_bin) {
    case 1: source = &west_shelf; src_name = "west_shelf"; break;
    case 2: source = &east_shelf; src_name = "east_shelf"; break;
    case 3: source = &north_shelf; src_name = "north_shelf"; break;
    case 4: source = &trash_bin; src_name = "trash_bin"; break;
  }
  object_catalog shopping_basket;
  int purchase_count = rando.inclusive(0, 30);
  if (!purchase_count) return;
  while (purchase_count--) {
    objcat_iterator *iter = source->find_head();
    int elems = source->elements(*iter);
    if (!elems) {
      // nothing to move, so leave.
      source->iter_unlock(iter);
      break;
    }
    int which = rando.inclusive(0, elems - 1);
    for (int i = which; i > 0; i--) {
      iter->next(); 
      if (iter->is_tail())
        deadly_error("test_object_catalog", "consumer", "iter count is at "
            "tail unexpectedly");
    }
    if (!iter->cat())
      deadly_error("test_object_catalog", "consumer", "iter is at nil node");
    unique_int id_to_get = iter->cat()->id();
    objcat_locket *l = iter->open_locket();
    inventory_item *to_buy = dynamic_cast<inventory_item *>(&l->cat());
    inventory_item *purchase = to_buy->split_off(1);
    iter->close_locket(l);
    restock(shopping_basket, purchase);
    if (!to_buy->valid()) {
      // get rid of the empty item on the shelf.
      source->zap(*iter);
      iter->previous();
    }
    source->iter_unlock(iter);
  }

  array<purchase_record> purchases;
  objcat_iterator *iter = shopping_basket.find_head();
  int elems = shopping_basket.elements(*iter);
  for ( ; !iter->is_tail(); iter->next()) {
    if (!iter->cat()) break;
    const inventory_item *got = dynamic_cast<const inventory_item *>
        (iter->cat());
    purchase_record new_record;
    new_record.name = got->name();
    new_record.count = got->count();
    purchases += new_record;
  }
  shopping_basket.iter_unlock(iter);
  
  if (elems) {
    istring info(istring::SPRINTF, "%s bought %d items:",
        catalogable_name().s(), elems);
    for (int i = 0; i < purchases.length(); i++)
      info += istring(istring::SPRINTF, " %d of %s,", purchases[i].count,
          purchases[i].name.s());
    info.zap(info.end(), info.end());  // remove last comma.
    info += ".";
    MAYBE_LOG(info);
  }

  // clean out what we bought now.
  iter = shopping_basket.find_head();
  for ( ; !iter->is_tail(); iter->next()) {
    shopping_basket.zap(*iter);
    iter->previous();
  }
  shopping_basket.iter_unlock(iter);
}


/* this might be avoided if we could figure out why the stupid names are
  coming up identical.
class conjoiner_thread : public ithread, public nodes::catalogable
{
public:
  conjoiner_thread(int sleep)
      : nodes::catalogable(rollo.next_id()), ithread(sleep) {}
  void perform_activity(void *thread_data);
  istring catalogable_name() const
      { return istring(istring::SPRINTF, "conjoiner_%d", id().raw_id()); }
};

void conjoiner_thread::perform_activity(void *)
{
  if (rando.inclusive(1, 100) > 48) return;  // do nothing this time.
  object_catalog *source = NIL;
  istring src_name;
  int src_bin = rando.inclusive(1, 4);
  switch (src_bin) {
    case 1: source = &west_shelf; src_name = "west_shelf"; break;
    case 2: source = &east_shelf; src_name = "east_shelf"; break;
    case 3: source = &north_shelf; src_name = "north_shelf"; break;
    case 4: source = &trash_bin; src_name = "trash_bin"; break;
  }
  int processed = 0;
  int maximum_allowed = rando.inclusive(20, 40);
  objcat_iterator *iter = source->find_head();
  for ( ; !iter->is_tail(); iter->next()) {
    if (!iter->cat()) break;
    catalogable *past_position = iter->cat();
    const inventory_item *got = dynamic_cast<const inventory_item *>
        (iter->cat());
    istring to_find = got->name();
    iter->next();  // skip the item we're at.
    for ( ; !iter->is_tail(); iter->next()) {
      // try to find other items with the same name, but different ids.
      const inventory_item *got = dynamic_cast<const inventory_item *>
          (iter->cat());
      if (got->name() == to_find) {
        // we have an entry with the same name as ours.
      }
    }
  }
  source->iter_unlock(iter);
}
*/


class president_thread : public ithread, public nodes::catalogable
{
public:
  president_thread()
      : ithread(PRESIDENT_SLEEP), nodes::catalogable(rollo.next_id())
      { president_thread_id = id().raw_id(); }
  void perform_activity(void *thread_data);
  IMPLEMENT_CLASS_NAME("president_thread");
  istring catalogable_name() const { return "president"; }

  void fire_an_employee();
    // gets rid of one randomly chosen employee.

  void close_up_shop();
    // shuts down the business completely and clears out all of the workers.
};

void president_thread::perform_activity(void *)
{
  if (exit_now) {
    // it's time for us to exit.
    close_up_shop();
    return;
  }

  int do_what = rando.inclusive(1, 100);
// maybe want the managers to do this kind of stuff.
  if (do_what < 10) {
    // start a stocker.
    int sleep = rando.inclusive(60, 180);
    stocker_thread *new_stocker = new stocker_thread(sleep);
    thread_bin->add(new_stocker);
    new_stocker->start(this);
    MAYBE_LOG(istring(istring::SPRINTF, "%s started a new stocker.",
        catalogable_name().s()));
  } else if (do_what < 20) {
    // start a consumer.
    int sleep = rando.inclusive(60, 180);
    consumer_thread *new_consumer = new consumer_thread(sleep);
    thread_bin->add(new_consumer);
    new_consumer->start(this);
    MAYBE_LOG(istring(istring::SPRINTF, "%s started a new consumer.",
        catalogable_name().s()));
  } else if (do_what < 30) {
    // start a rearranger.
    int sleep = rando.inclusive(60, 180);
    rearranger_thread *new_rearranger = new rearranger_thread(sleep);
    thread_bin->add(new_rearranger);
    new_rearranger->start(this);
    MAYBE_LOG(istring(istring::SPRINTF, "%s started a new rearranger.",
        catalogable_name().s()));
//hmmm: fix percentages when these threads exist.
  } else if (do_what < 31) {
    // start a defunctulater.
  } else if (do_what < 32) {
    // start an inventor.
  } else if (do_what < 33) {
    // start a manager.
  } else if (do_what < 50) {
    // start an inspector.
    int sleep = rando.inclusive(60, 180);
    inspector_thread *new_inspector = new inspector_thread(sleep);
    thread_bin->add(new_inspector);
    new_inspector->start(this);
    MAYBE_LOG(istring(istring::SPRINTF, "%s started a new inspector.",
        catalogable_name().s()));
  } else if (do_what < 69) {
    // fire someone.
    fire_an_employee();
  } else {
    // do nothing.
  }

  objcat_iterator *iter = thread_bin->find_head();
  static int _num_threads = -1;
  if (_num_threads < 0)
    _num_threads = thread_bin->elements(*iter);
  if (thread_bin->elements(*iter) != _num_threads) {
    MAYBE_LOG(isprintf("%d threads active.", thread_bin->elements(*iter)));
    _num_threads = thread_bin->elements(*iter);
  }
  thread_bin->iter_unlock(iter);
}

void president_thread::fire_an_employee()
{
  objcat_iterator *iter = thread_bin->find_head();
  int elems = thread_bin->elements(*iter);
  if (elems < 1) {
    // there's no one else to fire currently.
    thread_bin->iter_unlock(iter);
    return;
  }
  // pick a random thread to zap.
  int bye_bye = rando.inclusive(0, elems - 1);
  for (int i = bye_bye; i > 0; i--) {
    iter->next();
    if (iter->is_tail())
      deadly_error("test_object_catalog", "president", "iter count is at "
          "tail unexpectedly");
  }
  if (!iter->cat())
    deadly_error("test_object_catalog", "president", "iter at nil node");
  istring name = iter->cat()->catalogable_name();
  if (iter->cat()->id() == id()) {
    // don't want to whack our own thread.
    thread_bin->iter_unlock(iter);
    return;
  }
  // lock the node for access.
  objcat_locket *l = iter->open_locket();
  ithread *to_zap = dynamic_cast<ithread *>(&l->cat());
  // tell the thread to get lost and wait until it does.
  to_zap->stop();
  unique_int whack_id = iter->cat()->id();
  iter->close_locket(l);
  thread_bin->iter_unlock(iter);
  // we've unlocked the list; now quash this id.
  thread_bin->zap_id(whack_id);
  MAYBE_LOG(istring(istring::SPRINTF, "president whacked %s.", name.s()));
}

void president_thread::close_up_shop()
{
  // time to get out of business.  cancel all the threads.
  static bool printed_shutdown_start = false;
  if (!printed_shutdown_start) {
    MAYBE_LOG("president shutting down all threads.");
    printed_shutdown_start = true;
  }
  objcat_iterator *iter = thread_bin->find_head();
  for ( ; !iter->is_tail(); iter->next()) {
    // loop through and tell all of the threads to stop.
    if (!iter->cat()) continue;
    objcat_locket *l = iter->open_locket();
    ithread *t = dynamic_cast<ithread *>(&l->cat());
    if (t != (ithread *)this) t->cancel();
    iter->close_locket(l);
  }
  // start over again.  this time we're removing stopped threads.
  iter->jump_head();
  for ( ; !iter->is_tail(); iter->next()) {
    // loop through and whack any stopped threads.
    if (!iter->cat()) continue;
    const ithread *t = dynamic_cast<const ithread *>
        (iter->cat());
    if (t->thread_finished()) {
      // this thread has stopped and should get whacked.
      thread_bin->zap(*iter);
      iter->previous();  // skip back to prior guy for next iteration.
    }
  }
  // start over once more.  now we're going to make sure we're not the last
  // one in the building.
  iter->jump_head();
  bool others_remain = false;
  for ( ; !iter->is_tail(); iter->next()) {
    // loop through and whack any stopped threads.
    if (!iter->cat()) continue;
    const ithread *t = dynamic_cast<const ithread *>
        (iter->cat());
    if (t != (ithread *)this) others_remain = true;
  }
  thread_bin->iter_unlock(iter);
  if (!others_remain) {
    // we know we're the last one remaining now.
    cancel();  // close up shop.
    MAYBE_LOG("president has completely shut down all other threads.");
  }
}


class test_object_catalog : public application_shell
{
public:
  test_object_catalog();
  ~test_object_catalog();

  IMPLEMENT_CLASS_NAME("test_object_catalog");

  int execute();

private:
};


test_object_catalog::test_object_catalog()
: application_shell("t_object_catalog")
{}

test_object_catalog::~test_object_catalog() {}

int test_object_catalog::execute()
{
  president_thread *the_president = new president_thread();
  the_president->start(this);
  thread_bin->add(the_president);

  time_stamp run_until(DEFAULT_LIFE_TIME);
    // this is the time when we should get out of here.
//hmmm: get time to run from command line.

  program_wide_logger().log("");
  program_wide_logger().log("");
  program_wide_logger().log("");  // some blank lines.
  LOG("starting test of object_catalog.");

  while (run_until > time_stamp()) { portable::sleep_ms(SHELL_SLEEP); }

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

  objcat_iterator *iter = thread_bin->find_head();
  for ( ; !iter->is_tail(); iter->next()) {
    thread_bin->zap(*iter);
    iter->previous();
  }
  thread_bin->iter_unlock(iter);

  LOG("exiting test of object_catalog.");

  WHACK(thread_bin);
    // clean-up now while we have diagnostic facilities.

  guards::alert_message("object_catalog:: works for those functions tested.");

  return 0;
}


HOOPLE_MAIN(test_object_catalog, )

---