UT/UT_Performance.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Rob Bairos,
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_Performance.h ( UT Library, C++)
 *
 * COMMENTS:
 *
 *              utility to monitor and report app use
 */

#ifndef __UT_Performance__
#define __UT_Performance__

#include "UT_API.h"
#include <SYS/SYS_Time.h>
#include "UT_PtrArray.h"
#include "UT_FloatArray.h"

enum {
    LOG_OFF = 0,
    LOG_WINDOW,
    LOG_STDOUT
};

enum {
    TIME_FORMAT_ALL = 0,
    TIME_FORMAT_MS,
    TIME_FORMAT_SEC
};

enum {
    PERFORMANCE_WINDOW_LOG      = 0,
    PERFORMANCE_ENDFRAME        = 1,
    PERFORMANCE_WINDOW_LOG_HIGH = 2     // Important message to be highlighted.
};

enum UT_PerformanceFilter
{
    UT_PERF_FILTER_OFF,
    UT_PERF_FILTER_HIGHLIGHT,           // Highlight long ops
    UT_PERF_FILTER_HIDE                 // Hide short ops
};

typedef void (*UT_PerformanceCB)(int type, void *data, const char *msg,
                                 int refresh);

class utPerfEvent;

class UT_API UT_Performance
{
    public:
         UT_Performance();
        ~UT_Performance();

        void            startEvent(const char *type,
                                   const char *name = 0,
                                   const char *info = 0,
                                   int count = -1);

        fpreal          stopEvent(int log = 1);
        void            logMessage(const char *m, int refresh = 1,
                                   fpreal dtime = -1,
                                   const utPerfEvent *event = 0);
        void            logAccumulatedTime(fpreal time) { myAccumTime += time; }

        void            filterLog(UT_PerformanceFilter filter,
                                  float time_threshold_ms);

        void            logEnable(int yesno)
                        { 
                            if( myLogEnable )
                                frameComplete(myLastFrame);
                            myLogEnable = yesno; 
                            myFrameState = 0;
                        }
        int             logEnabled() const
                        { return myLogEnable && myLogType; }

        int             opTiming() const
                        { 
                            return 
                             (myOpInfo || myOpHighlight ||
                             (myLogEnable && myLogType && myLogCookTime));
                        }

        int             frameTiming() const
                        { 
                            return logEnabled() && myLogFLength;
                        }

        void            setCallback(UT_PerformanceCB func, void *data)
                        {
                            myFunc = func; 
                            myData = data;
                        }

        //
        // frame methods
        //


        /// frameChange is for automatically timing a series of frames.
        /// it stops timing the previous frame and starts timing the given one
        void            frameChange(fpreal frame);

        /// use frameStart and frameComplete for single-frame timing
        void            frameStart(fpreal frame);
        void            frameComplete(fpreal frame);
        fpreal          getLastFrame() const { return myLastFrame; }

        //
        // op methods
        //


        int             opInfo() const          { return myOpInfo; }
        void            opInfo(int yesno)       { myOpInfo = yesno; }

        int             opHighlight() const     { return myOpHighlight; }
        void            opHighlight(int yesno)  { myOpHighlight = yesno; }

        //
        // memory methods
        //
        void            startMemoryLog();
        void            stopMemoryLog(const char *label);

        //
        // log query methods
        //

        int             logType() const { return myLogType; }
        void            logType(int type);
        void            logPause(int yesno);
        void            logSorted(int yesno);

        int             logTimeFormat() const { return myTimeFormat; }
        void            logTimeFormat( int format ) { myTimeFormat = format; }

        int             logCookTime() const     
                        { return logEnabled() && myLogCookTime; }
        void            logCookTime(int yesno)  
                        { myLogCookTime = yesno; }

        bool            logSolveTime() const
                        { return logEnabled() && myLogSolveTime; }
        void            logSolveTime(bool enable)
                        { myLogSolveTime = enable; }

        int             logLongCHOPs() const    
                        { return logEnabled() && myLogLongCHOPs; }
        void            logLongCHOPs(int yesno) 
                        { myLogLongCHOPs = yesno; }
        
        int             logObjectViewTime() const
                        { return logEnabled() && myLogObjectViewTime; }
        void            logObjectViewTime(int yesno)
                        { myLogObjectViewTime = yesno; }

        int             logViewPortTime() const
                        { return logEnabled() && myLogViewPortTime; }
        void            logViewPortTime(int yesno)
                        { myLogViewPortTime = yesno; }

        int             logFLength() const
                        { return logEnabled() && myLogFLength; }
        void            logFLength(int yesno)
                        { myLogFLength = yesno; }

        int             logMemory() const       
                        { return logEnabled() && myLogMemory; }
        void            logMemory(int yesno)    
                        { myLogMemory = yesno; }

        int             logErrors() const
                        { return logEnabled() && myLogErrors; }
        void            logErrors(int yesno)
                        { myLogErrors = yesno; }

        void            clearFrameAverage()
                        { myFrameCount = 0; myFrameTotal = 0.0f; }


        //
        // misc

        static const char       *formatTime(fpreal t, 
                                            const char *prefix,
                                            const char *suffix = "\n\r",
                                            int format = TIME_FORMAT_ALL);
        static const char       *formatFrequency(fpreal t, const char *prefix,
                                            const char *suffix = "\n\r");

    private:

        // decomposition of frameChange
        void             logFrameAverage();
        void             startFrame(fpreal frame);
        void             endFrame(fpreal dtime);
        fpreal           elapsedTime(SYS_TimeVal &etime);

        int              myLogType;
        int              myTimeFormat;
        int              myFrameState;

        unsigned int     myLogEnable : 1,

                         myOpInfo : 1,
                         myOpHighlight : 1,

                         myLogPause : 1,
                         myLogSorted : 1,
                         myLogCookTime : 1,
                         myLogLongCHOPs : 1,
                         myLogViewPortTime : 1,
                         myLogObjectViewTime : 1,
                         myLogFLength : 1,
                         myLogMemory : 1,
                         myLogErrors : 1,
                         myLogSolveTime : 1;

        void             appendMessage(const char *m, fpreal dtime,
                                       const utPerfEvent *event);

        void             clearMessages();
        void             flushMessages();
        void             clearEvents();


        UT_PtrArray<char *>              myMessage;
        UT_PtrArray<utPerfEvent *>       myMessageEvent;
        UT_FloatArray                    myMessageTime;
        int                              myMessageCount;

        UT_PerformanceCB         myFunc;
        void                    *myData;

        float                    myAccumTime;
        SYS_TimeVal              myLastTime;

        int                      myFrameCount;
        float                    myFrameTotal;

        size_t                   myMemoryUsage;

        UT_PtrArray<utPerfEvent *>      myEvents;
        int                             myEventCount;

        fpreal                          myLastFrame;
        SYS_TimeVal                     myStartTime;

        /// am i currently timing a frame?
        bool                            myTiming;
        
        UT_PerformanceFilter            myFilter;
        fpreal                          myFilterThreshold;
        int                             myFilterHiddenEvents;
};

UT_API extern UT_Performance    *UTgetPerformance(); // Get the application ptr

#endif

---