PDG_WorkItemStateTracker.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.
*
* COMMENTS:
*/

#ifndef __PDG_WORKITEM_STATETRACKER_H__
#define __PDG_WORKITEM_STATETRACKER_H__

#include "PDG_API.h"
#include "PDG_NodeTypes.h"
#include "PDG_WorkItemTypes.h"

#include <UT/UT_TBBSpinLock.h>

/*
 * Helper class that maintains a list of work item state counts
 */
class PDG_API PDG_WorkItemStateTracker
{
public:
                            PDG_WorkItemStateTracker()
                                { reset(); }

    inline void             reset()
                                {
                                    UT_TBBSpinLock::Scope lock(myLock);

                                    myWorkItemCount = 0;
                                    for (int i = 0;
                                        i < (int)PDG_WorkItemState::eStateCount;
                                        i++)
                                    {
                                        myStateCounts[i] = 0;
                                    }
                                }

    inline int              workItemCount() const
                                { return myWorkItemCount; }

    inline int              stateCount(PDG_WorkItemState state) const
                                { return stateCounter(state); }

    inline void             addWorkItem(PDG_WorkItemState state)
                                {
                                    UT_TBBSpinLock::Scope lock(myLock);
                                    stateCounter(state) += 1;
                                    myWorkItemCount += 1;
                                }

    inline void             removeWorkItem(PDG_WorkItemState state)
                                {
                                    UT_TBBSpinLock::Scope lock(myLock);
                                    stateCounter(state) -= 1;
                                    myWorkItemCount -= 1;
                                }

    inline void             updateWorkItem(
                                    PDG_WorkItemState prev,
                                    PDG_WorkItemState cur)
                                {
                                    UT_TBBSpinLock::Scope lock(myLock);
                                    stateCounter(prev) -= 1;
                                    stateCounter(cur) += 1;
                                }

    template <typename T>
    inline void             stateCounts(UT_Array<T>& array) const
                                {
                                    exint size =
                                        (exint)PDG_WorkItemState::eStateCount;
                                    array.setSize(size);

                                    for (exint i = 0; i < size; i++)
                                        array[i] = (T)(myStateCounts[i]);
                                }

    PDG_NodeState           nodeState(bool is_active, bool is_generated) const;
    fpreal                  nodeProgress() const;

private:
    inline exint&           stateCounter(PDG_WorkItemState state)
                                { return myStateCounts[(int)state]; }
    inline const exint&     stateCounter(PDG_WorkItemState state) const
                                { return myStateCounts[(int)state]; }

private:
    exint                   myWorkItemCount;
    exint                   myStateCounts[(int)PDG_WorkItemState::eStateCount];
    mutable UT_TBBSpinLock  myLock;
};

#endif