static_memory_gremlin.cpp

Go to the documentation of this file.

#ifndef STATIC_MEMORY_GREMLIN_IMPLEMENTATION_FILE
#define STATIC_MEMORY_GREMLIN_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : static_memory_gremlin                                             *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2004-$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 "static_memory_gremlin.h"

#include <basis/array.cpp>
#include <basis/byte_array.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <basis/mutex.h>
#include <basis/object_base.h>
#include <basis/set.cpp>

#include <stdio.h>

// these two are hierarchy violations that are allowed.  otherwise any
// SET_DEFAULT_X logger macro is going to be unavailable here in data_struct.
#include <loggers/file_logger.h>
#include <loggers/locked_logger.h>
#include <loggers/null_logger.h>

#define static_class_name() "static_memory_gremlin"

//#define DEBUG_STATIC_MEMORY_GREMLIN
  // comment this out to eliminate debugging print-outs.  otherwise they
  // are controlled by the class interface.

//#define SKIP_STATIC_CLEANUP
  // don't uncomment this unless you want all static objects to be left
  // allocated on shutdown of the program.  that's very sloppy but may
  // sometimes be needed for testing.

const char *_EXCEPTION_INFO_FOR_SHUTTING_DOWN
    = "Function must return immediately because program is shutting down.";

static bool _program_is_dying = false;
  // this is set to true when no more logging or access to static objects
  // should be allowed.

bool DATA_STRUCTURE_FUNCTION_STYLE program_is_dying() { return _program_is_dying; }

const char DATA_STRUCTURE_FUNCTION_STYLE *EXCEPTION_INFO_FOR_SHUTTING_DOWN()
{ return _EXCEPTION_INFO_FOR_SHUTTING_DOWN; }

const byte_array BASIS_EXTERN &__byte_array_empty_array()
{
  static byte_array __hidden_byte_array;
  return __hidden_byte_array;
}

const istring BASIS_EXTERN &__istring_empty_string()
{
  static istring __hidden_empty_string;
  return __hidden_empty_string;
}


const int SMG_CHUNKING_FACTOR = 32;
  // we'll allocate this many indices at a time.

class object_base_record
{
public:
  object_base *_object;
  const char *_name;
};

static_memory_gremlin::static_memory_gremlin()
: _lock(new mutex),
  _top_index(0),
  _actual_size(0),
  _pointers_held(NIL),
  _show_debugging(false)
{
  ensure_space_exists();
}

static_memory_gremlin::~static_memory_gremlin()
{
  _program_is_dying = true;
    // now the rest of the program is on notice; we're practically gone.

  if (!program_is_dying()) {
    non_continuable_error("static_memory_gremlin", "destructor",
        "program is not in dying state; this is a grievous error.");
  }
#ifdef DEBUG_STATIC_MEMORY_GREMLIN
  if (_show_debugging)
    printf("SMG: beginning static object shutdown...\n");
#endif

#ifndef SKIP_STATIC_CLEANUP
  // clean up any allocated pointers in reverse order of addition.
  while (_top_index > 0) {
    // make sure we fixate on which guy is shutting down.  some new ones
    // could be added on the end of the list as a result of this destruction.
    int zapped_index = _top_index - 1;
    object_base_record *ptr = _pointers_held[zapped_index];
    _pointers_held[zapped_index] = NIL;
      // since we know the one we're zapping, we no longer need that index.
    _top_index--;
      // this should allow us to keep chewing on items that are newly being
      // added during static shutdown, since we have taken the current object
      // entirely out of the picture.
    if (ptr) {
#ifdef DEBUG_STATIC_MEMORY_GREMLIN
      if (_show_debugging)
        printf((istring("SMG: deleting ") + ptr->_object->instance_name()
            + " called " + ptr->_name
            + isprintf(" at index %d.\n", zapped_index) ).s());
#endif
      WHACK(ptr->_object);
      WHACK(ptr);
    }
  }
#endif
  delete [] _pointers_held;
  _pointers_held = NIL;
  delete _lock;
  _lock = NIL;
}

int static_memory_gremlin::locate(const char *unique_name)
{
  auto_synchronizer l(*_lock);
  for (int i = 0; i < _top_index; i++) {
    if (!strcmp(_pointers_held[i]->_name, unique_name)) return i;
  }
  return common::NOT_FOUND;
}

object_base *static_memory_gremlin::get(const char *unique_name)
{
  auto_synchronizer l(*_lock);
  int indy = locate(unique_name);
  if (negative(indy)) return NIL;
  return _pointers_held[indy]->_object;
}

const char *static_memory_gremlin::find(const object_base *ptr)
{
  auto_synchronizer l(*_lock);
  for (int i = 0; i < _top_index; i++) {
    if (ptr == _pointers_held[i]->_object)
      return _pointers_held[i]->_name;
  }
  return NIL;
}

bool static_memory_gremlin::put(const char *unique_name, object_base *to_put)
{
  auto_synchronizer l(*_lock);
  int indy = locate(unique_name);
  // see if that name already exists.
  if (non_negative(indy)) {
#ifdef DEBUG_STATIC_MEMORY_GREMLIN
    if (_show_debugging)
      printf((istring("SMG: cleaning out old object ")
          + _pointers_held[indy]->_object->instance_name()
          + " called " + _pointers_held[indy]->_name 
          + " in favor of object " + to_put->instance_name()
          + " called " + unique_name
          + isprintf(" at index %d.\n", indy)).s());
#endif
    WHACK(_pointers_held[indy]->_object);
    _pointers_held[indy]->_object = to_put;
    return true;
  }
#ifdef DEBUG_STATIC_MEMORY_GREMLIN
  if (_show_debugging)
    printf((istring("SMG: storing ") + to_put->instance_name()
        + " called " + unique_name
        + isprintf(" at index %d.\n", _top_index)).s());
#endif
  ensure_space_exists();
  _pointers_held[_top_index] = new object_base_record;
  _pointers_held[_top_index]->_object = to_put;
  _pointers_held[_top_index]->_name = unique_name;
  _top_index++;
  return true;
}

void static_memory_gremlin::ensure_space_exists()
{
  auto_synchronizer l(*_lock);
  if (!_pointers_held || (_top_index + 1 >= _actual_size) ) {
    // never had any contents yet or not enough space exists.
#ifdef DEBUG_STATIC_MEMORY_GREMLIN
    if (_show_debugging)
      printf(isprintf("SMG: adding space for top at %d.\n", _top_index).s());
#endif
    _actual_size += SMG_CHUNKING_FACTOR;
    typedef object_base_record *base_ptr;
    object_base_record **new_ptr = new base_ptr[_actual_size];
    if (!new_ptr) {
      non_continuable_error("static_memory_gremlin", "ensure_space_exists",
          "failed to allocate memory for pointer list");
    }
    for (int i = 0; i < _actual_size; i++) new_ptr[i] = NIL;
    for (int j = 0; j < _actual_size - SMG_CHUNKING_FACTOR; j++) 
      new_ptr[j] = _pointers_held[j];
    if (_pointers_held) delete [] _pointers_held;
    _pointers_held = new_ptr;
  }
}

// this function ensures that the space for the global objects is kept until
// the program goes away.  if it's the first time through, then the gremlin
// gets created; otherwise the existing one is used.  this function should
// always be called by the main program before any attempts to use global
// features like SAFE_STATIC or the program wide logger.  it is crucial that no
// user-level threads have been created in the program before this is called.
static_memory_gremlin &HOOPLE_GLOBALS()
{
  static bool _initted = false;  // tells whether we've gone through yet.
  static static_memory_gremlin *_internal_gremlin = NIL;
    // holds our list of shared pieces...

  if (!_initted) {
#ifdef DEBUG_STATIC_MEMORY_GREMLIN
    printf("%s: initializing HOOPLE_GLOBALS now.\n", __argv[0]); 
#endif

#ifdef ENABLE_MEMORY_HOOK
    void *temp = program_wide_memories().provide_memory(1, __FILE__, __LINE__);
      // invoke now to get memory engine instantiated.
    program_wide_memories().release_memory(temp);  // clean up junk.
#endif

#ifdef ENABLE_CALLSTACK_TRACKING
    program_wide_stack_trace().full_trace_size();
      // invoke now to get callback tracking instantiated.
#endif
    FUNCDEF("HOOPLE_GLOBALS remainder");
      // this definition must be postponed until after the objects that would
      // track it actually exist.

    // this simple approach is not going to succeed if the SAFE_STATIC macros
    // are used in a static library which is then used in more than one dynamic
    // library on win32.  this is because each dll in win32 will have a
    // different version of certain static objects that should only occur once
    // per program.  this problem is due to the win32 memory model, but in
    // hoople at least this has been prevented; our only static library that
    // appears in a bunch of dlls is basis and it is not allowed to use the
    // SAFE_STATIC macro.
    _internal_gremlin = new static_memory_gremlin;
    _initted = true;
  }

  return *_internal_gremlin;
}


//hmmm: chunk to move elsewhere.

#ifdef ENABLE_MEMORY_HOOK

static memory_checker *__exposed_hidden_memories = NIL;
  // set once the real memory object is created below.  not to be used by
  // anyone else besides the atexit method.

void hoople_atexit()
{
  if (__exposed_hidden_memories) {
    __exposed_hidden_memories->destruct();
      // this renders the object useless but leaves it able to alloc/dealloc.
    __exposed_hidden_memories = NIL;
  }
}


memory_checker BASIS_EXTERN &program_wide_memories()
{
  static memory_checker *_hidden_memories = NIL;
  if (!_hidden_memories) {
    static bool _already_here = false;
    if (_already_here) {
      printf("logic error in program_wide_memories: invoked after shutdown\n");
      abort();
    }
    _already_here = true;

    _hidden_memories = (memory_checker *)malloc(sizeof(memory_checker));
    _hidden_memories->construct();
    // we make an external copy of our internal object here.
    __exposed_hidden_memories = _hidden_memories;
    // register a program shutdown handler to report leaks.
    atexit(hoople_atexit); 
  }
  return *_hidden_memories;
    // there will be at least one reported memory leak if this program is
    // analyzed with external tools; the hidden memories pointer is never
    // deallocated here.
}

#endif


//hmmm: chunk to move elsewhere.

#ifdef ENABLE_CALLSTACK_TRACKING


callstack_tracker BASIS_EXTERN &program_wide_stack_trace()
{
  static callstack_tracker *_hidden_trace = NIL;
  if (!_hidden_trace) {
#ifdef ENABLE_MEMORY_HOOK
    program_wide_memories().disable();
      // we don't want infinite loops tracking the call stack during this
      // object's construction.
#endif
    _hidden_trace = new callstack_tracker;
#ifdef ENABLE_MEMORY_HOOK
    program_wide_memories().enable();
#endif
  }
  return *_hidden_trace;
}

#endif


library_wide_cleanup::library_wide_cleanup()
: _shared_chunks(&HOOPLE_GLOBALS())  // create the memory chunk if needed.
{
  __memory_gremlin_synchronizer();
    // invoke this at least once; this is our most critical synchro primitive.

  // these force static objects in the statically linked basis library to be
  // created properly on win32.  we want to ensure that the wacky memory
  // context of a static library's statics are set up properly for use in each
  // dynamic library, since there seem to be a separate static heap context in
  // each DLL.  that poses a problem in general for more complex objects if
  // they are contained in a widely-used static library.  basis is the only
  // real case of that in our system, and it's been reduced down to just the
  // following statics (which are wrapped in creator methods).
//hmmm: get these back to being exported from opsys instead; singletons.
  istring::empty_string();
  byte_array::empty_array();
}

library_wide_cleanup::~library_wide_cleanup() {}
  // nothing here yet.


program_wide_cleanup::program_wide_cleanup()
{
  // reset the random number seed.  we only do this once during startup
  // although anyone can reset it again later.
  chaos().retrain();
#ifndef OMIT_PROGRAM_WIDE_LOGGER
  // assume we're okay by creating a file + console logger until they decide
  // to set up a different type.
  SET_DEFAULT_COMBO_LOGGER;
#endif
}

program_wide_cleanup::~program_wide_cleanup()
{
#ifndef OMIT_PROGRAM_WIDE_LOGGER
  if (real_program_wide_logger().established()) {
    SET_DEFAULT_NULL_LOGGER;
      // reset to a non-asynchronous logger.  if a logger that's busy in the
      // background (like the uls) is hooked in here, it could still be trying
      // to deliver sends while the program is trying to shut down.  we just
      // ensure it gets closed before much more of static shutdown happens.
  }
#endif

  // remove our shared segments.
  static_memory_gremlin *shared = &HOOPLE_GLOBALS();

  WHACK(shared);  // now really remove the object.
}


// internal secret below: we are always planning on this function being called
// before any other functions that use it, and this object should always exist
// for program-wide synchronization needs, so we just assume it is safe to
// always take the zeroth identifier/slot from the gremlin.  we do this
// because the SAFE_STATIC macros actually use the private synchronizer.
mutex &__memory_gremlin_synchronizer()
{
  const char *hoople_static_name
      = ":" __FILE__ ":" "only___memory_gremlin_synch" ":";
  static mutex *_hidden_mutt = dynamic_cast<mutex *>
      (HOOPLE_GLOBALS().get(hoople_static_name));
  if (!_hidden_mutt) {
    _hidden_mutt = new mutex;
    HOOPLE_GLOBALS().put(hoople_static_name, _hidden_mutt);
  }
  return *_hidden_mutt;
}

int_set BASIS_EXTERN &__our_kids()
{ SAFE_STATIC_IMPLEMENTATION(int_set, , __LINE__); }

mutex BASIS_EXTERN &__uptime_synchronizer()
{ SAFE_STATIC_IMPLEMENTATION(mutex, , __LINE__); }

mutex BASIS_EXTERN &__process_synchronizer()
{ SAFE_STATIC_IMPLEMENTATION(mutex, , __LINE__); }


#undef static_class_name

#endif //STATIC_MEMORY_GREMLIN_IMPLEMENTATION_FILE

---