t_memory_limiter.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_memory_limiter                                               *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Tests that the memory_limiter is keeping track of the memory users       *
*  accurately.                                                                *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$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                               *
\*****************************************************************************/

//#define DEBUG_MEMORY_LIMITER
  // uncomment for debugging version.

#include <basis/chaos.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <basis/set.cpp>
#include <data_struct/memory_limiter.h>
#include <data_struct/static_memory_gremlin.h>
#include <mechanisms/time_stamp.h>
#include <opsystem/application_shell.h>
#include <opsystem/ini_config.h>

#ifdef DEBUG_MEMORY_LIMITER
  #include <stdio.h>
#endif

HOOPLE_STARTUP_CODE;

const int MAXIMUM_MEM_OVERALL = 1 * GIGABYTE;
const int MAXIMUM_MEM_PER_OWNER = 20 * MEGABYTE;

const int RUN_TIME = 5 * MINUTE_ms;


class test_memory_limiter : public application_shell
{
public:
  test_memory_limiter() : application_shell(class_name()) {}

  IMPLEMENT_CLASS_NAME("test_memory_limiter");

  virtual int execute();
};


struct mem_record {
  int parent;
  int allocated;

  mem_record(int parent_in = 0, int allocated_in = 0)
      : parent(parent_in), allocated(allocated_in) {}
};

struct memorial : array<mem_record> {};


int test_memory_limiter::execute()
{
  time_stamp when_to_leave(RUN_TIME);
  time_stamp start;
  memorial wtc;
  memory_limiter to_test(MAXIMUM_MEM_OVERALL, MAXIMUM_MEM_PER_OWNER);
  int allocations = 0;
  int deletions = 0;
  u_int total_allocated = 0;
  u_int total_deleted = 0;
  while (time_stamp() < when_to_leave) {
    int to_do = randomizer().inclusive(1, 100);
    if (to_do < 50) {
      // add a new record.
      int alloc = randomizer().inclusive(1, 1 * MEGABYTE);
//isolate min max alloc
      int parent = randomizer().inclusive(1, 120);
//isolate min max parents

      if (!to_test.okay_allocation(parent, alloc))
        continue;  // no space right now.
      wtc += mem_record(parent, alloc);
      allocations++;
      total_allocated += alloc;
    } else if (to_do < 88) {
      // remove an existing record.
      if (!wtc.length()) continue;  // nothing to remove.
      int indy = randomizer().inclusive(0, wtc.length() - 1);
      mem_record to_gone = wtc[indy];
      wtc.zap(indy, indy);
      if (!to_test.record_deletion(to_gone.parent, to_gone.allocated)) {
        log(to_test.text_form());
        deadly_error(class_name(), "deletion check", "failed to record deletion!");
      }
      deletions++;
      total_deleted += to_gone.allocated;
    } else {
//do something funky, like allocate part of one into another...
    }
  }

  // now clear everything left in our list.
  for (int i = 0; i < wtc.length(); i++) {
    mem_record to_gone = wtc[i];
    if (!to_test.record_deletion(to_gone.parent, to_gone.allocated)) {
      log(to_test.text_form());
      deadly_error(class_name(), "final cleaning", "failed to record deletion!");
    }
    deletions++;
    total_deleted += to_gone.allocated;
  }

  // now check that the memory limiter has returned to camber.

  if (to_test.overall_usage()) {
    log(to_test.text_form());
    deadly_error(class_name(), "final checks", "there is still memory in use!");
  }

  if (to_test.overall_space_left() != MAXIMUM_MEM_OVERALL) {
    log(to_test.text_form());
    deadly_error(class_name(), "final checks", "the free space is not correct!");
  }

  int_set remaining = to_test.individuals_listed();
  if (remaining.elements()) {
    log(to_test.text_form());
    deadly_error(class_name(), "final checks",
        "there were still uncleared individuals!");
  }

  time_stamp end;

  log("stats for this run:");
  log(istring(istring::SPRINTF, "\trun time %f ms",
      end.value() - start.value()));
  log(istring(istring::SPRINTF, "\tallocations %d, total memory allocated %d",
      allocations, total_allocated));
  log(istring(istring::SPRINTF, "\tdeletions %d, total memory deleted %d",
      deletions, total_deleted));

  guards::alert_message("memory_limiter:: works for those functions tested.");
  return 0;
}


int main(int formal(argc), char *formal(argv)[])
{
  test_memory_limiter to_test;
  return to_test.execute();
}

---