UT/UT_Counter.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:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_Counter.h ( UT Library, C++)
 *
 * COMMENTS:    Class to keep track of records and print out the data at the
 *              end of a render.  You simply have to declare a static printer
 *              in the file you want the printing to occur in.  The destructor
 *              will cause the stat to be printed.
 */

#ifndef __UT_Counter__
#define __UT_Counter__

#include "UT_API.h"

#ifdef UT_DEBUG

#include <stdio.h>
#include <SYS/SYS_AtomicInt.h>

#if defined(WIN32)
    typedef int UT_CounterIntType;
#else
    #include <SYS/SYS_AtomicIntImpl.h>
    typedef SYS_AtomicInt32     UT_CounterIntType;
#endif

class UT_API UT_Counter {
public:
    explicit UT_Counter(const char *msg) 
    {
        myMessage = msg;
#if defined(WIN32)
        myCount = myPeak = 0;
#else
        myCount.set(0);
        myPeak.set(0);
#endif
    }
    ~UT_Counter()
     {
        if ((int32)myPeak > 0)
        {
            printf("%s: %d [%d peak, %d increments]\n", myMessage,
                                        (int32)myCount, (int32)myPeak,
                                        (int32)myIncrements);
        }
     }

    UT_Counter  &operator+=(int v)
                 {
#if defined(WIN32)
                     myCount += v;
                     if (myCount > myPeak)
                         myPeak = myCount;
#else
                     myPeak.maximum(myCount.add(v));
                     if (v > 0)
                         myIncrements.add(v);
#endif
                     return *this;
                 }
    UT_Counter  &operator-=(int v)      { return operator+=(-v); }
    UT_Counter  &operator++(int)        { return operator+=(1); }
    UT_Counter  &operator--(int)        { return operator+=(-1); }
#if defined(WIN32)
    void         reset()                { myCount = 0; }
#else
    void         reset()                { myCount.set(0); }
#endif

private:
    UT_CounterIntType            myCount;
    UT_CounterIntType            myPeak;
    SYS_AtomicInt32              myIncrements;
    const char                  *myMessage;
};

#else           // UT_DEBUG

// When no debugging is on, we'll make a dummy class.  Hopefully, the compiler
// will optimize this right out.
class UT_API UT_Counter {
public:
     UT_Counter(const char *)   {}
    ~UT_Counter()               {}

    UT_Counter  &operator+=(int)        { return *this; }
    UT_Counter  &operator++(int)        { return *this; }
    UT_Counter  &operator-=(int)        { return *this; }
    UT_Counter  &operator--(int)        { return *this; }
    void         reset()                { }
};

#endif          // UT_DEBUG
#endif

---