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