callstack_tracker.h

Go to the documentation of this file.

#ifndef CALLSTACK_TRACKER_CLASS
#define CALLSTACK_TRACKER_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : callstack_tracker                                                 *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2007-$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 <application/build_configuration.h>
#include <basis/contracts.h>
#include <basis/definitions.h>
#include <basis/mutex.h>
 
namespace application {
 
#ifdef ENABLE_CALLSTACK_TRACKING
 
// forward.
class callstack_records;
class callstack_tracker;
 
 
callstack_tracker &thread_wide_stack_trace();
 
//hmmm: maybe borked on basis of the conflict between a global stack tracker and the fact that each thread has its own callstack!  argh!
 
 
 
class callstack_tracker
{
public:
  callstack_tracker();
  virtual ~callstack_tracker();
 
//  DEFINE_CLASS_NAME("callstack_tracker");
 
  bool push_frame(const char *class_name, const char *func, const char *file,
          int line);
 
  bool pop_frame();
 
  bool update_line(int line);
 
  char *full_trace() const;
 
  int full_trace_size() const;
 
  int depth() const { return _depth; }
 
  double frames_in() const { return _frames_in; }
 
  double frames_out() const { return _frames_out; }
 
  double highest() const { return _highest; }
 
  static basis::mutex &__callstack_tracker_synchronizer();
 
private:
  callstack_records *_bt;  
  int _depth;  
  double _frames_in;  
  double _frames_out;  
  double _highest;  
  bool _unusable;  
};
 
 
#define GET_AND_TEST_STACK_TRACE(header, failure_return) { \
  int trace_size = thread_wide_stack_trace().full_trace_size(); \
  char *stack_trace = thread_wide_stack_trace().full_trace(); \
  ASSERT_TRUE(trace_size >= strlen(stack_trace) + 1, "insufficient estimated stack trace size"); \
  if (trace_size < strlen(stack_trace) + 1) { \
    /* error condition here; we are supposed to get the actual size we would need to allocate! */ \
    LOG(a_sprintf("failure in stack trace return: estimated size (%d) was less than actual (%d)", \
        trace_size, strlen(stack_trace))); \
    /* mandatory free step for newly allocated string. */ \
    free(stack_trace); \
    return failure_return; \
  } \
  ASSERT_TRUE(strlen(stack_trace) > 1, "empty stack trace"); \
  if (strlen(stack_trace) < 2) { \
    LOG("failure in stack trace return: the trace output string was empty!"); \
    return failure_return; \
  } \
  LOG(astring("\n\n################\n\n") + header + "\n" + stack_trace); \
  /* mandatory free step for newly allocated string. */ \
  free(stack_trace); \
}
 
 
 
class frame_tracking_instance
{
public:
  // these are not encapsulated, but be careful with the contents.
  bool _frame_involved;  
  char *_class, *_func, *_file;  
  int _line;
 
  frame_tracking_instance(const char *class_name = "", const char *func = "",
      const char *file = "", int line = 0, bool add_frame = false);
 
  frame_tracking_instance(const frame_tracking_instance &to_copy);
 
  ~frame_tracking_instance();
 
  frame_tracking_instance &operator =(const frame_tracking_instance &to_copy);
 
  void assign(const char *class_name, const char *func, const char *file,
          int line);
 
  void clean();
};
 
void update_current_stack_frame_line_number(int line);
 
#else // ENABLE_CALLSTACK_TRACKING
  /*
    bogus replacements for the most commonly used callstack tracking support.
    these are necessary because we don't want this enabled in all scenarios,
    and when we want the callstack tracking disabled, it must have near zero
    runtime cost.
  */
  inline void no_op() { /* do nothing. */ }
  #define frame_tracking_instance
  #define GET_AND_TEST_STACK_TRACE(header, failure_return) no_op();
  #define __trail_of_function(p1, p2, p3, p4, p5) no_op();
  inline void update_current_stack_frame_line_number(int line) { /* more nothing. */ }
#endif // ENABLE_CALLSTACK_TRACKING
 
} //namespace.
 
#endif // outer guard.