static_memory_gremlin.h

Go to the documentation of this file.

#ifndef STATIC_MEMORY_GREMLIN_CLASS
#define STATIC_MEMORY_GREMLIN_CLASS

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

#include <basis/callstack_tracker.h>
#include <basis/memory_checker.h>
#include <basis/mutex.h>
#include <basis/portable.h>

// forward:
class object_base;
class object_base_record;


class DATA_STRUCTURE_CLASS_STYLE static_memory_gremlin
{
public:
  static_memory_gremlin();

  ~static_memory_gremlin();
  void enable_debugging(bool verbose) { _show_debugging = verbose; }

  bool put(const char *unique_name, object_base *ptr);

  object_base *get(const char *unique_name);

  const char *find(const object_base *ptr);

  void ensure_space_exists();
private:
  mutex *_lock;  
  int _top_index;  
  int _actual_size;  
  object_base_record **_pointers_held;  
  bool _show_debugging;  

  int locate(const char *unique_name);
};


bool DATA_STRUCTURE_FUNCTION_STYLE program_is_dying();

static_memory_gremlin DATA_STRUCTURE_FUNCTION_STYLE &HOOPLE_GLOBALS();



mutex DATA_STRUCTURE_FUNCTION_STYLE &__memory_gremlin_synchronizer();



// the following functions are for internal use only.  do not mess around
// with these unless you enjoy program deadlocks or other bizarre crashes.

bool DATA_STRUCTURE_FUNCTION_STYLE program_is_dying();

const char DATA_STRUCTURE_FUNCTION_STYLE *EXCEPTION_INFO_FOR_SHUTTING_DOWN();



// historical note: the SAFE_STATIC approach has existed since about 1998.
// however, the static_memory_gremlin's role in this started much later.
// so the following portions should be considered GPL with copyright 1998
// and onwards.


#define SAFE_STATIC(type, func_name, parms) \
  type &func_name() { SAFE_STATIC_IMPLEMENTATION(type, parms, __LINE__); }

#define SAFE_STATIC_CONST(type, func_name, parms) \
  const type &func_name() \
  { SAFE_STATIC_IMPLEMENTATION(type, parms, __LINE__); }


#define STATIC_STRING(str) \
  SAFE_STATIC_IMPLEMENTATION(istring_object, (str), __LINE__)

#define UNIQUE_NAME_BASED_ON_SOURCE(name, linenum) \
  static const char *name = "file:" __FILE__ ":line:" #linenum


#define SAFE_STATIC_IMPLEMENTATION(type, parms, linenum) \
  const char *func = "allocation"; \
  frame_tracking_instance __trail_of_function("safe_static", func, \
      __FILE__, __LINE__, true); \
  UNIQUE_NAME_BASED_ON_SOURCE(__uid_name, linenum); \
  program_wide_memories(); \
  static object_base *_hidden = NIL; \
  /* if haven't initialized yet, then definitely need to lock carefully. */ \
  if (program_is_dying() || !_hidden) { \
    auto_synchronizer l(__memory_gremlin_synchronizer()); \
    if (program_is_dying()) { \
      /* we can't rely on the pointer since we're shutting down currently. */ \
      _hidden = HOOPLE_GLOBALS().get(__uid_name); \
    } \
    if (!_hidden) {  /* make sure no one scooped us. */ \
      /* try to retrieve an existing one first and use it if there. */ \
      _hidden = HOOPLE_GLOBALS().get(__uid_name); \
      if (!_hidden) { \
        _hidden = new type parms ; /* create the object finally. */ \
        /* store our object using the unique name for it. */ \
        if (!HOOPLE_GLOBALS().put(__uid_name, _hidden)) { \
          /* we failed to allocate space.  this is serious. */ \
          throw __uid_name; \
        } \
      } \
    } \
  } \
  if (!_hidden) { \
    /* grab the pointer that was stored, in case we're late getting here. */ \
    /* another thread might have scooped the object creation. */ \
    _hidden = HOOPLE_GLOBALS().get(__uid_name); \
  } \
  return *dynamic_cast<type *>(_hidden)



class DATA_STRUCTURE_CLASS_STYLE library_wide_cleanup
{
public:
  library_wide_cleanup();

  ~library_wide_cleanup();

private:
  static_memory_gremlin *_shared_chunks;  
};



class DATA_STRUCTURE_CLASS_STYLE program_wide_cleanup
{
public:
  program_wide_cleanup();
  ~program_wide_cleanup();
};


/*
  The HOOPLE_STARTUP_CODE macro must be deployed once and only once in
  each program that uses the HOOPLE libraries.  If it isn't provided, then
  link errors may result.  The macro ensures that some of the critical internal
  objects are defined and created properly for the program's use.
*/


#define HOOPLE_STARTUP_CODE_DLL \
  DEFINE_ARGC_AND_ARGV;  /* any OS specific code. */ \
  DEFINE_INSTANCE_HANDLE;  /* set up the instance handle. */ \
  static library_wide_cleanup _jean_reno


#define HOOPLE_STARTUP_CODE \
  HOOPLE_STARTUP_CODE_DLL; \
  /* the creation of this static cleanup object also establishes the \
   * static objects that are provided as global hoople services. */ \
  static program_wide_cleanup _harvey_keitel

#define BASIS_STARTUP_CODE_DLL HOOPLE_STARTUP_CODE_DLL
#define BASIS_STARTUP_CODE HOOPLE_STARTUP_CODE

#endif

---