t_debug_allocs.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_debug_allocs                                                 *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Tests the allocation support that the program is built with, not just in *
*  debug builds.  But this is most useful for a debug build in order to test  *
*  whether the debug heap problems are win32's or someone else's.             *
*                                                                             *
*******************************************************************************
* Copyright (c) 2001-$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/time_stamp.h>
#include <loggers/file_logger.h>
#include <opsystem/path_configuration.h>
#include <data_struct/static_memory_gremlin.h>

HOOPLE_STARTUP_CODE;

const int DEFAULT_FISH_LOW = 50;
const int DEFAULT_FISH_HIGH = 200;
  // the range of the number of threads used in the test.

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

const int SLEEP_LOW = 28;
const int SLEEP_HIGH = 114;
  // if the thread chooses to sleep, these are the boundaries for how long.

const istring LOGFILE_NAME = path_configuration::make_logfile_name
    ("t_debug_allocs.log");
  // where our debugging output goes by default.

const int MAX_ALLOCS_PER_THREAD = 30;
  // the most allocations that a thread can have at a time.

const int MAX_ALLOC = 20000;
  // the largest allocation we attempt at a time.

#define LOG(to_print) log.log(timestamp(true) + istring(to_print))
  // our macro for logging with a timestamp.

chaos rando;

class memory_abuser : public ithread
{
public:
  memory_abuser() : ithread(0) {}

  virtual ~memory_abuser() {
    for (int i = 0; i < _allocations.length(); i++)
      WHACK(_allocations[i]);
  }

  enum test_actions {
    FIRST_TEST,
    ALLOCATE = FIRST_TEST,
    DEALLOCATE,
    NOTHING,
    ALLOC_DEALLOC,
    DEALLOC_ALLOC,
    LAST_TEST = DEALLOC_ALLOC
  };

  void perform_activity(void *formal(data)) {
    while (!should_stop()) {
      int action = rando.inclusive(FIRST_TEST, LAST_TEST);
      switch (action) {
         case ALLOCATE: {
           if (_allocations.length() > MAX_ALLOCS_PER_THREAD)
             break;
           int size = rando.inclusive(1, MAX_ALLOC);
           byte *alloc = new byte[size];
           _allocations += alloc;
           break;
         }
         case DEALLOCATE: {
           if (!_allocations.length()) break;
           int posn = rando.inclusive(0, _allocations.length() - 1);
           WHACK(_allocations[posn]);
           _allocations.zap(posn, posn);
           break;
         }
         case NOTHING:
           // done!
           break;
         case ALLOC_DEALLOC: {
           int size = rando.inclusive(1, MAX_ALLOC);
           byte *alloc = new byte[size];
           _allocations += alloc;
           int posn = rando.inclusive(0, _allocations.length() - 1);
           WHACK(_allocations[posn]);
           _allocations.zap(posn, posn);
           break;
         }
         case DEALLOC_ALLOC: {
           if (!_allocations.length()) break;
           int posn = rando.inclusive(0, _allocations.length() - 1);
           WHACK(_allocations[posn]);
           _allocations.zap(posn, posn);
           int size = rando.inclusive(1, MAX_ALLOC);
           byte *alloc = new byte[size];
           _allocations += alloc;
           break;
         }
//add other tests.
      }
      int might_sleep = rando.inclusive(1, 100);
      // sometimes we will sleep.
      if (might_sleep >= 98) {
        int sleepy = rando.inclusive(SLEEP_LOW, SLEEP_HIGH);
        portable::sleep_ms(sleepy);
      }
    }
  }

private:
  array<byte *> _allocations;
};

#define static_class_name() "t_debug_alloc"

#ifdef __WIN32__
int WINAPI WinMain(application_instance instance,
    application_instance prev_instance, LPSTR lpCmdLine, int nCmdShow)
#else
int main(int formal(argc), char *formal(argv)[])
#endif
{
  FUNCDEF("main");
  file_logger log(LOGFILE_NAME);

  amorph<ithread> thread_list;

  int fishies = rando.inclusive(DEFAULT_FISH_LOW, DEFAULT_FISH_HIGH);
  LOG(istring(istring::SPRINTF, "using %d fish in test.", fishies));

  for (int i = 0; i < fishies; i++) {
    ithread *t = new memory_abuser;
    thread_list.append(t);
    ithread *q = thread_list[thread_list.elements() - 1];
    if (q != t)
      deadly_error(static_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(rando.inclusive(12, 200));

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

  // stop all the threads.  if we just reset the amorph, bad things happen,
  // possibly because a destructor can't manage threads in this way?  or
  // because the thread is using a mutex inside a destructor???
  for (int j = 0; j < thread_list.elements(); j++) thread_list[j]->stop();

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

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

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

#undef static_class_name

---