COP2/COP2_DebugTiming.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 Alexander
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        COP2_DebugTiming.h
 *
 * COMMENTS:
 *      This class allows for timing of specific nodes within a series of 
 *      cooks.
 */
#ifndef COP2_DebugTiming_H
#define COP2_DebugTiming_H

#include <iostream.h>
#include <UT/UT_Lock.h>
#include <UT/UT_String.h>
#include <UT/UT_SymbolTable.h>
#include <SYS/SYS_Math.h>
#include <OP/OP_Node.h>

#include "COP2_API.h"

class COP2_DebugTimingTable;

class COP2_API COP2_DebugTimingNode
{
public:
    COP2_DebugTimingNode(const char *nodepath)
        : myNodePath(nodepath, 1),
          myNumCooks(0),
          myTotalCookTime(0.0),
          myMinCookTime(0.0),
          myMaxCookTime(0.0)
        { }

    void        addCookTime(double time)
    {
        if(myNumCooks == 0)
        {
            myMinCookTime = time;
            myMaxCookTime = time;
        }
        else
        {
            myMinCookTime = SYSmin(time, myMinCookTime);
            myMaxCookTime = SYSmax(time, myMaxCookTime);
        }
        myTotalCookTime += time;
        myNumCooks++;
    }

    void        print(ostream &os) const
    {
        if(myNumCooks > 0.0)
            os << myNodePath << "\n  " << myNumCooks << "   "
               << myTotalCookTime <<"s   min " << myMinCookTime << "s   max "
               << myMaxCookTime << "s   avg "
               << (myTotalCookTime / myNumCooks) << "s";
        else
            os << myNodePath << " not cooked.";
    }

    UT_String myNodePath;
    int       myNumCooks;
    double    myTotalCookTime;
    double    myMinCookTime;
    double    myMaxCookTime;
};

struct cop2_timing_entry_data
{
    ostream *os;
    double total_time;
};


inline int printEntry(UT_Thing &data, const char *, void *vdata)
{
    COP2_DebugTimingNode *node = (COP2_DebugTimingNode *) ((void *)data);
    cop2_timing_entry_data *pdata = (cop2_timing_entry_data *) vdata;
    
    node->print(*pdata->os);
    *pdata->os << endl;
    pdata->total_time += node->myTotalCookTime;
    return 1;
}

inline int clearEntry(UT_Thing &data, const char *, void *)
{
    COP2_DebugTimingNode *node = (COP2_DebugTimingNode *) ((void *)data);
    delete node;
    return 1;
}
                                  

class COP2_API COP2_DebugTimingTable
{
public:
    COP2_DebugTimingTable() : myTotal(0.0) {}
    ~COP2_DebugTimingTable()
    {
        myTable.traverse(clearEntry, NULL);
    }

    void        addCopTiming(OP_Node *copnode, double time)
    {
        UT_String path;
        UT_Thing data;
        COP2_DebugTimingNode *tnode = NULL;

        copnode->getFullPath(path);
        
        myTableLock.lock();

        if(myTable.findSymbol(path, &data))
        {
            tnode = (COP2_DebugTimingNode *) ((void *)data);
        }
        else
        {
            tnode = new COP2_DebugTimingNode(path);
            data = (void *) tnode;
            myTable.addSymbol(path, data);
        }           

        tnode->addCookTime(time);

        myTableLock.unlock();
    }

    void        printTable(ostream &os)
    {
        cop2_timing_entry_data pdata;
        pdata.os = &os;
        pdata.total_time = 0.0;
        myTable.traverse(printEntry, &pdata);
        os.flush();
        os << "Total time: " << pdata.total_time << "s" << endl;
        os.flush();
    }

    UT_SymbolTable      myTable;
    UT_Lock             myTableLock;
    double              myTotal;
};



#endif

---