MeVis/Foundation/Sources/MLUtilities/mlTrace.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __mlTrace_H
#define __mlTrace_H

#ifndef __mlUtilsSystem_H
#include "mlUtilsSystem.h"
#endif


ML_UTILS_START_NAMESPACE

  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <typename INDEXTYPE> class TraceBuffer {
  public:
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    inline TraceBuffer()
    {
      // Initialize both buffers with NULL pointers.
      memset(_traceStack, 0, _numBufBytes);
      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 pointer to 
      // make memory access and incrementation of index independent. 
      // So the CPU can execute both statements in parallel.
      // Also be sure to increment index NOT within "[" and "]"
      // to avoid that indexing works on 32bit 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. So 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