stk_util/stk_util/diag/Trace.hpp

#ifndef STK_UTIL_SIERRA_TRACE_HPP
#define STK_UTIL_SIERRA_TRACE_HPP
 
#include <cstring>
#include <vector>
#include <map>
#include <string>
#include <functional>
 
#include <stk_util/diag/Writer_fwd.hpp>
 
#include <ostream>
 
#define SLIB_TRACE_COVERAGE
 
namespace stk_classic {
namespace diag {
 
 
class Tracespec
{
public:
  explicit Tracespec(const char *function_spec)
    : m_functionSpec(function_spec)
  {}
 
  inline const char *getFunctionSpec() const {
    return m_functionSpec;
  }
 
  std::string getFunctionName() const;
 
  std::string getFunctionShortName() const;
 
  std::string getFunctionClass() const;
 
  std::string getFunctionNamespace() const;
 
  std::string getFunctionShortClass() const;
 
protected:
  const char *      m_functionSpec;    
};
 
typedef std::vector<const char *> TracebackStack;
 
class Traceback : public Tracespec
{
public:
  enum TracebackState{RUNNING, THROWING};
 
  enum {STACK_SIZE = 2048};        
  typedef const char *Stack[STACK_SIZE] ;    
  typedef const char * const *  const_stack_iterator;  
  typedef const char **  stack_iterator;      
 
  typedef std::map<const char *, int> Coverage;
 
  class Preserve
  {
  public:
    Preserve() {
      Traceback::preserveStack();
    }
 
    ~Preserve() {
      Traceback::releaseStack();
    }
  };
 
  explicit Traceback(const char *function_spec)
    : Tracespec(function_spec)
  {
    if (s_top >= &s_stack[STACK_SIZE - 1] || s_top == 0)
      s_top = s_stack;
    *s_top++ = function_spec;
 
    if (s_tracebackState == THROWING && !s_tracebackPreserve && !std::uncaught_exception())
      s_tracebackState = RUNNING;
 
#ifdef SLIB_TRACE_COVERAGE
    if (s_coverageEnabled)
      ++s_coverage[function_spec];
#endif
  }
 
 
  ~Traceback() {
    if (!s_tracebackPreserve && std::uncaught_exception() && s_tracebackState == RUNNING) {
      s_tracebackState = THROWING;
      s_storedTop = s_storedStack + (s_top - s_stack);
      std::copy(s_stack, s_top, s_storedStack);
    }
    if (s_top > &s_stack[0])
      --s_top;
  }
 
  static TracebackStack snapshot();
 
  inline static void enableTracebackDisplay() {
    --s_tracebackDisplay;
  }
 
  inline static void disableTracebackDisplay() {
    ++s_tracebackDisplay;
  }
 
  inline static bool displayTraceback() {
    return s_tracebackDisplay == 0;
  }
 
  inline static void preserveStack() {
    ++s_tracebackPreserve;
  }
 
  inline static void releaseStack() {
    --s_tracebackPreserve;
  }
 
  inline static void enableCoverage(bool coverage_enabled = true) {
    s_coverageEnabled = coverage_enabled;
  }
 
  inline static bool coverageEnabled() {
    return s_coverageEnabled;
  }
 
  inline static TracebackState getTracebackState() {
    return s_tracebackState;
  }
 
  struct PrintCoverage
  {};
 
  static PrintCoverage printCoverage() {
    return PrintCoverage();
  }
 
  static std::ostream &printCoverage(std::ostream &os);
 
  static std::string printTraceback(const TracebackStack &traceback_stack);
 
  Writer &verbose_print(Writer &dout) const;
 
private:
  static TracebackState    s_tracebackState;  
  static int      s_tracebackPreserve;  
  static int      s_tracebackDisplay;  
  static const char **    s_top;      
  static Stack      s_stack;    
  static const char **    s_storedTop;    
  static Stack      s_storedStack;    
  static bool     s_coverageEnabled;  
  static Coverage   s_coverage;   
};
 
 
class Trace : public Traceback
{
public:
  typedef Writer & (*ExtraFuncPtr)(Writer &);
 
  struct TraceList : public std::vector<const char *> {
  public:
    TraceList() {
      s_traceListExists = true;
    }
 
    ~TraceList() {
      s_traceListExists = false;
    }
  };
 
  enum {
    IN_TRACE_LIST  = 0x01    
  };
 
  Trace(Writer &dout, const char *function_name, int print_mask = LOG_TRACE, bool do_trace = true);
 
  ~Trace();
 
  inline static ExtraFuncPtr setExtra(ExtraFuncPtr extra) {
    ExtraFuncPtr x = s_extra;
    s_extra = extra;
    return x;
  }
 
  inline static void addTraceFunction(const std::string &function_prefix) {
    char *s = std::strcpy(new char[function_prefix.length() + 1], function_prefix.c_str());
 
    s_traceList.push_back(s);
  }
 
  inline static void clearTraceFunctions() {
    for (std::vector<const char *>::iterator it = s_traceList.begin(); it != s_traceList.end(); ++it)
      delete[] (*it);
 
    s_traceList.clear();
  }
 
  Writer &verbose_print(Writer &dout) const;
 
private:
  Writer &      m_diagWriter;    
  double      m_startCpuTime;    
  size_t      m_startMemAlloc;  
  PrintMask      m_lineMask;    
  bool                          m_do_trace;             
  int        m_flags;    
 
  static ExtraFuncPtr    s_extra;    
  static TraceList    s_traceList;    
  static bool                   s_traceListExists;      
};
 
inline Writer &operator<<(Writer &dout, const Trace &diag_trace) {
  return diag_trace.verbose_print(dout);
}
 
inline std::ostream &operator<<(std::ostream &os, const Traceback::PrintCoverage &) {
  return Traceback::printCoverage(os);
}
 
 
} // namespace diag
} // namespace stk_classic
 
namespace sierra {
namespace Diag {
 
typedef stk_classic::diag::Tracespec Tracespec;
typedef stk_classic::diag::Traceback Traceback;
typedef stk_classic::diag::Trace Trace;
 
} // namespace sierra 
} // namespace Diag 
 
 
 
#endif // STK_UTIL_SIERRA_TRACE_HPP