memory_hog.cpp

Go to the documentation of this file.

 
// Name   : memory_hog
// Author : Chris Koeritz
// Copyright (c) 2012-$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:
//     http://www.gnu.org/licenses/gpl.html
// or under the terms of the GNU Library license:
//     http://www.gnu.org/licenses/lgpl.html
// at your preference.  Those licenses describe your legal rights to this
// software, and no other rights or warranties apply.
// Please send updates for this code to: fred@gruntose.com -- Thanks, fred.
 
 
#include <application/hoople_main.h>
#include <application/command_line.h>
#include <application/singleton_application.h>
#include <basis/enhance_cpp.h>
#include <loggers/program_wide_logger.h>
#include <structures/static_memory_gremlin.h>
#include <unit_test/unit_base.h>
 
using namespace application;
using namespace basis;
using namespace loggers;
//using namespace processes;
using namespace structures;
using namespace unit_test;
 
const int MEMORY_CHECKING_INTERVAL = 0.5 * SECOND_ms;
  // this many milliseconds elapses between checks on shutdown conditions.
 
#define BASE_LOG(to_print) EMERGENCY_LOG(program_wide_logger().get(), astring(to_print))
#define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger().get(), astring(to_print))
  // define a macro that will send diagnostic output to the app's logger.
 
 
class application_example : virtual public unit_base, virtual public application_shell
{
public:
  application_example();
  ~application_example();
 
  DEFINE_CLASS_NAME("application_example");
 
  virtual void handle_timer();
 
  virtual void handle_startup();
 
  virtual void handle_shutdown();
 
  virtual int execute();
 
  int print_instructions();
 
private:
  singleton_application _app_lock;  
};
 
 
application_example::application_example()
: application_shell(),
  _app_lock(static_class_name())
{}
 
application_example::~application_example()
{}
 
int application_example::print_instructions()
{
  FUNCDEF("print_instructions");
  BASE_LOG("\
\nUsage: memory_hog {memorySize}\n\
\n\
  This application will consume a requested amount of memory until either\n\
(1) the applications is interrupted or terminated, or (2) the application\n\
is no longer given memory when it requests it (whether due to account limits\n\
or to a lack of remaining allocatable memory), or (3) the requested amount\n\
has been allocated.\n\
  The application will then sit back idly and occasionally riffle through its\n\
big bag of memory in an attempt to keep most of it in physical memory rather\n\
than virtual memory.\n\
  This is not a hostile act unless used unwisely; this program is intended\n\
to get an unloaded machine into a predictable memory state.\n\
  **DO NOT use this program without system administrator permission.**"
);
  return 1;
}
 
void application_example::handle_startup()
{
  FUNCDEF("handle_startup");
  LOG("starting up now.");
}
 
void application_example::handle_shutdown()
{
  FUNCDEF("handle_shutdown");
  LOG("shutting down now.");
}
 
void application_example::handle_timer()
{
  FUNCDEF("handle_timer");
  LOG("timer blip.");
}
 
int application_example::execute()
{
  FUNCDEF("execute");
  command_line cmds(_global_argc, _global_argv);
 
LOG(a_sprintf("cmd line has %d entries", cmds.entries()));
 
  if (cmds.entries() < 1) {
    BASE_LOG("You need to provide a number on the command line....");
    return print_instructions();
  }
 
  astring size_as_text = cmds.get(0).text();
 
LOG(a_sprintf("hoo hah!  got a text thingy of: %s", size_as_text.s()));
 
  if (size_as_text.find('.') < 0) {
    // we don't see this as floating point, but we will move on as if it's
    // an integer and can become floating point.
    size_as_text += ".0";
  }
 
  double how_fat = size_as_text.convert(double(0.0));
 
LOG(a_sprintf("got a number from user of: %f", how_fat));
 
//okay, now that we've got that handled,
// we want to have a hash table of byte arrays.
//   int hash or whatever?  we want it indexable and fast access on a unique id.
// that will be our consumption tactic.
// we will allocate some chunk size in the byte arrays.  maybe max of a meg.
// then we just add as many byte arrays as we need to to get to the requested amount.
// don't just allocate them all at the same size; vary it a bunch, like say 20% of
//   our maximum allotance.
// so randomly pull memory until we get what we want.
// if we get a memory failure, slack off until we can try to get more.
// if we cannot get memory within certain number of failures, report this and bail out.
//   we do not want to crash the machine.
// once we've got our memory, start playing with it.
// every so often,
//   pick a random number of items to play with,
//     go to each item (which is a byte array),
//       pick a random segment of the byte array to look at,
//         read the contents of the memory there.  that's it, nothing stressful.
// repeat the memory play until forever.
//   enhancement, allow them to provide a run time.  time out after that elapses.
 
  return 0;
}
 
 
HOOPLE_MAIN(application_example, )