mlTrace.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_TRACE_H
#define ML_TRACE_H
 
 
#include "mlTypeDefs.h"
#include "mlUtilsSystem.h"
#include <cstring>
 
ML_UTILS_START_NAMESPACE
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <typename INDEXTYPE> class TraceBuffer {
  public:
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline TraceBuffer()
    {
      // Initialize both buffers with NULL pointers.
      std::memset(_traceStack, 0, _numBufBytes);
      std::memset(_traceList,  0, _numBufBytes);
 
      // Reset indices into stack and list.
      _traceStackTop = 0;
      _traceListEnd  = 0;
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline void add(const char* const traceInString){
      // Push string address onto the stack. Be sure that
      // _stackTop is incremented after storing the pointer to
      // make memory access and incrementation of index independent.
      // This way, the CPU can execute both statements in parallel.
      // Also make sure to increment the index \e not within [ and ]
      // to avoid that indexing works on 32-bit integers, which would
      // access areas outside buffers
      _traceStack[_traceStackTop] = traceInString;
 
      // Do not increment inside [ and ] because that could be evaluated
      // to an integer, which would lead to illegal out of range accesses.
      ++_traceStackTop;
 
      // Append string address to end of trace list. For optimizing
      // performance, also see _traceStack push above.
      _traceList[_traceListEnd] = traceInString;
 
      // Do not increment inside [ and ] because that could be evaluated
      // to an integer, which would lead to illegal out of range accesses.
      ++_traceListEnd;
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline void remove(){
      // Decrement trace stack top. Be sure that integer index
      // is really limited to size of INDEXTYPE since passing
      // decremented _traceStackTop without masking it could
      // lead to usage of 32-bit index in index [ ] and
      // accesses outside buffers. Note that mask calculation
      // is constant and probably will be evaluated on compile
      // time.
      _traceStackTop = static_cast<INDEXTYPE>((_traceStackTop - 1) & _bufferIndexMask);
 
      // Reset stack entry. This way, unused entries do not use
      // invalid information.
      _traceStack[_traceStackTop] = NULL;
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline INDEXTYPE getTraceStackTop() const { return _traceStackTop; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline INDEXTYPE getTraceListEnd()  const { return _traceListEnd;  }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline const char* const *getTraceStack()    const { return _traceStack;    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline const char* const *getTraceList()     const { return _traceList;     }
 
  private:
 
    enum { _numBufEntries   = (1L << (sizeof(INDEXTYPE) << 3)) ,
           _numBufBytes     = _numBufEntries * sizeof(const char *),
           _bufferIndexMask = _numBufEntries - 1
    };
 
    INDEXTYPE   _traceStackTop;
 
    INDEXTYPE   _traceListEnd;
 
    const char *_traceStack[_numBufEntries];
 
    const char *_traceList[_numBufEntries];
  };
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <typename INDEXTYPE> class Trace {
  public:
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline Trace(const char * const traceInString, TraceBuffer<INDEXTYPE> &traceBuf) :
      _traceBuf(traceBuf)
    {
      // Push string address on stack and at end of trace list.
      traceBuf.add(traceInString);
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline ~Trace()
    {
      _traceBuf.remove();
    }
 
  private:
 
    TraceBuffer<INDEXTYPE> &_traceBuf;
 
 
    inline Trace(const Trace &trace) : _traceBuf(trace._traceBuf){ }
 
    inline Trace<INDEXTYPE> &operator=(const Trace & /* trace */){ return *this; }
  };
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  typedef MLuint16 MLGlobalTraceBufferType;
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  extern ML_UTILS_EXPORT TraceBuffer<MLGlobalTraceBufferType> MLGlobalTraceBuffer;
 
 
ML_UTILS_END_NAMESPACE
 
 
#endif // __mlTrace_H