startup_code.cpp

Go to the documentation of this file.

#ifndef STARTUP_CODE_IMPLEMENTATION_FILE
#define STARTUP_CODE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : hoople startup support                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1994-$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 "critical_events.h"
#include "path_configuration.h"
#include "startup_code.h"
#ifndef OMIT_PROGRAM_WIDE_LOGGER
  #include "console_logger.h"
  #include "file_logger.h"
  #include "locked_logger.h"
  #include "null_logger.h"
#endif
#include "system_values.h"

#include <basis/byte_array.h>
#include <basis/chaos.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <basis/memory_checker.h>
#include <data_struct/static_memory_gremlin.h>

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

//#define DEBUG_STARTUP_CODE
  // uncomment for additional checks and noises.

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

#define static_class_name() "startup_code"


namespace startup_code {
  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 BASIS_EXTERN program_is_dying() { return _program_is_dying; }

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


#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


#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


locked_logger OPSYSTEM_FUNCTION_STYLE &real_program_wide_logger()
{
  SAFE_STATIC_IMPLEMENTATION(locked_logger, , __LINE__);
}

#ifndef OMIT_PROGRAM_WIDE_LOGGER
// provides the more generic version of the real logger.
log_base OPSYSTEM_FUNCTION_STYLE &program_wide_logger()
{
  if (!real_program_wide_logger().established()) {
    SET_DEFAULT_NULL_LOGGER;
    critical_events::write_to_critical_events((timestamp(true, true)
        + "the program-wide logger isn't set!").s());
  }
  return real_program_wide_logger(); 
}

log_base OPSYSTEM_FUNCTION_STYLE *retask_program_wide_logger
    (log_base *new_logger)
{
  return real_program_wide_logger().swap(new_logger);
}
#endif


namespace startup_code {

// 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_STARTUP_CODE
    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;
}


library_wide_cleanup::library_wide_cleanup()
: _shared_chunks(&HOOPLE_GLOBALS())  // create the memory chunk if needed.
{
  startup_code::__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();

  _program_is_dying = true;
    // now the rest of the program is on notice; we're practically gone.

  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;
}

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

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

} // namespace


// we hide our static methods from basis here, since we do not want to
// see multiple instances of these (one per dll in windows).

const byte_array &startup_code::byte_array_empty_array()
{
  static byte_array __hidden_byte_array;
  return __hidden_byte_array;
}

const istring &startup_code::istring_empty_string()
{
  static istring __hidden_empty_string;
  return __hidden_empty_string;
}

#undef static_class_name


#endif //STARTUP_CODE_IMPLEMENTATION_FILE

---