PDG_Node.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_NODE_H__
#define __PDG_NODE_H__

#include "PDG_API.h"

#include "PDG_EvaluationContext.h"
#include "PDG_EventEmitter.h"
#include "PDG_EventTypes.h"
#include "PDG_File.h"
#include "PDG_NodeInterface.h"
#include "PDG_NodeOptions.h"
#include "PDG_NodeStats.h"
#include "PDG_SchedulerTypes.h"
#include "PDG_ServiceTypes.h"
#include "PDG_SortOptions.h"
#include "PDG_WorkItemDirty.h"
#include "PDG_WorkItemTypes.h"

#include <PDGE/PDGE_Dependency.h>
#include <PDGE/PDGE_DependencyOwner.h>
#include <PDGE/PDGE_PropagateGroup.h>

#include <PDGT/PDGT_Value.h>

#include <UT/UT_ArrayMap.h>
#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_RWLock.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_TBBSpinLock.h>

#include <SYS/SYS_AtomicInt.h>

class PDG_BatchWorkItem;
class PDG_Dependency;
class PDG_Filter;
class PDG_GraphContext;
struct PDG_MemoryInfo;
class PDG_NodeCallback;
class PDG_NodeCallbackType;
class PDG_Scheduler;
class PDG_WorkItemHolder;
class PDG_WorkItem;

class UT_JSONWriter;

/**
 *  Base class for all nodes that keeps track of work items and helper
 *  data structures needed by sub classes. Defines several virtual methods
 *  that are implemented in concrete node subclasses.
 */
class PDG_API PDG_Node : public PDG_NodeInterface,
                         public PDG_EventEmitter,
                         public PDGE_DependencyOwner
{
public:
    /// Bypass state for the node
    enum BypassState
    {
        /// The node is not bypassed
        eBypassNone,

        /// The node is in a bypassed subnetwork
        eBypassSubnetwork,

        /// The node itself is bypassed
        eBypassNode
    };
   
public:
                                PDG_Node(
                                    PDG_GraphContext* context,
                                    const UT_StringHolder& name,
                                    const PDG_NodeCallbackType* type_object,
                                    PDG_NodeID id = -1);

                                ~PDG_Node() override;

    /// Returns the list of supported event types
    const PDG_EventFilter&      supportedEventTypes() const override;

    /// Returns the total memory usage of the node, including any work items
    /// owned by it.
    int64                       getMemoryUsage(bool inclusive) const override;

    /// Returns the memory usage as a PDG_MemoryInfo struct
    virtual void                memoryInfo(PDG_MemoryInfo& memory_info,
                                           bool inclusive) const;

    /// Returns the memory used by all work items in this node. Pass true
    /// indicate that only attribute data should be counted.
    int64                       workItemMemory(bool attribs_only=false) const;


    /// Returns this node's id, it matches the TOP node id
    inline PDG_NodeID           getId() const
                                    { return myId; }

    /// Returns the node's unique name
    const UT_StringHolder&      name() const
                                    { return myName; }

    /// Renames the node. No uniqueness validation is done on the new name - 
    /// a unique name should be acquired from the graph.
    void                        rename(const UT_StringHolder& new_name);

    /// Returns the performance event path for the node. Returns true if the
    /// path already includes work item information.
    bool                        performancePath(
                                        UT_WorkBuffer& buffer,
                                        const UT_StringHolder& event_name,
                                        const PDG_WorkItem* work_item) const;


    /// Returns the node's type object
    const PDG_NodeCallbackType* typeObject() const;

    /// Returns the node type, e.g. processor, mapper, etc
    PDG_NodeType                nodeType() const;

    /// Returns the sub type, e.g. normal, foreach begin, foreach end, etd
    PDG_NodeSubtype             nodeSubtype() const;

    /// Returns the current state of the node
    PDG_NodeState               nodeState() const;

    /// Returns the current cook progress of the node
    fpreal                      nodeProgress() const;

    /// Returns the node's info object, which contains cook count and
    /// description information.
    const PDG_NodeOptions&      nodeOptions(bool do_update);

    /// Returns the node's sort options struct
    const PDG_SortOptions&      sortOptions() const
                                    { return mySortOptions; }

    /// Returns the node's stat object
    const PDG_NodeStats&        stats() const
                                    { return myNodeStats; }
    PDG_NodeStats&              stats()
                                    { return myNodeStats; }

    /// Gets/sets the node callback - the underlying object used to implement
    /// most of the node functionality. Can be a user defined C++ or Python
    /// instance.
    inline PDG_NodeCallback*    callback() const
                                    { return myCallback.get(); }
    inline void                 setCallback(PDG_NodeCallbackPtr callback)
                                    { myCallback = callback; }

    /// Gets/sets the per-node scheduler override
    PDG_Scheduler*              scheduler() const;
    void                        setScheduler(PDG_Scheduler* scheduler);
    void                        removeScheduler(PDG_Scheduler* scheduler);

    /// Gets/sets schedulers referenced by this node, but not used by it
    /// directly.
    const PDG_SchedulerSet&     schedulerReferences() const
                                    { return mySchedulerReferences; }
    void                        addSchedulerReference(PDG_Scheduler* scheduler)
                                    { mySchedulerReferences.insert(scheduler); }
    void                        clearSchedulerReferences()
                                    { mySchedulerReferences.clear(); }

    /// Returns the graph context that owns the node
    inline PDG_GraphContext*    context() const
                                    { return myContext; }

    /// Returns the loop dpeth of the node
    inline int                  loopDepth() const
                                    { return myLoopDepth; }

    /// Returns the loop block's service reset conditoon
    inline PDG_ServiceResetWhen loopResetWhen() const
                                    { return myLoopResetWhen; }

    /// Returns the loop block's service reset type
    inline PDG_ServiceResetType loopResetType() const
                                    { return myLoopResetType; }

    /// Returns true if the node is an error handler
    inline bool                 isErrorHandler() const
                                    { return myIsErrorHandler; }

    /// Returns true if the node is in an error handler branch
    inline bool                 isErrorHandlerBranch() const
                                    { return myIsErrorHandlerBranch; }

    /// Sets the error handler flag on this node
    inline void                 setIsErrorHandler(bool error_handler)
                                    {
                                        myIsErrorHandler = error_handler;
                                        myIsErrorHandlerBranch = error_handler;
                                    }

    /// Sets the error handler branch flag on this node
    inline void                 setIsErrorHandlerBranch(bool error_handler)
                                    { myIsErrorHandlerBranch = error_handler; }

    /// Clears and checks the error flag
    inline bool                 hasErrors() const
                                    { return myHasError; }


    /// Returns true if this node is generating. This occurs when the atomic
    /// generation counter is > 0
    inline bool                 isGenerating() const
                                    { return myActiveGenerates.relaxedLoad() > 0; }

    /// Returns true if this node is dynamic for the current evaluation, e.g. 
    /// if it should have the dynamic badge set in the UI. This means either
    /// this node or an upstream input is dynamic in some way.
    inline bool                 isDynamicEval() const
                                    { return myIsDynamicEval; }

    /// Returns true if this node itself is strictly dynamic, i.e. the work item
    /// generation requires input items to be cooked
    inline bool                 isDynamicGeneration() const
                                    { return myIsDynamicGen; }

    /// Returns true if this node should propagate the dynamic generation
    /// state to downstream processors
    inline bool                 isDynamicProp() const
                                    { return myIsDynamicProp; }

    /// Returns true if this node can possibly create work items, based on
    /// its input configuration
    inline bool                 canHaveWorkItems() const
                                    { return myCanHaveWorkItems; }

    /// Returns the name of the service that this node should use to cook
    /// work items. Returns empty string if no service has been specified
    /// in the node configuration
    const UT_StringHolder&      serviceName() const
                                    { return myServiceName; }

    /// Returns true if the node is inheriting it's service from a parent
    /// service block.
    bool                        useServiceBlock() const
                                    { return myUseServiceBlock; }

    /// Returns true if this node should run its automatic regeneration logic
    /// on the next cook. If this node has a callback with a custom
    /// onRegenerate implementation, that will always be run regardless of
    /// this flag
    inline PDG_NodeRegenerateReason
                                regenerateReason() const
                                    { return myRegenerateReason; }

    /// Sets the regenerate flag, to be called when the node should consider
    /// running automatic regeneration logic during the cook
    inline void                 setRegenerateReason(
                                        PDG_NodeRegenerateReason reason)
                                    { myRegenerateReason = reason; }

    /// Updates the regenerate flag, but only to mode that's higher in value
    /// then the current one
    inline void                 updateRegenerateReason(
                                        PDG_NodeRegenerateReason reason)
                                    {
                                        if (reason > myRegenerateReason)
                                            myRegenerateReason = reason;
                                    }

    /// Sets the bypassed flag on this node
    inline void                 setBypassState(BypassState state)
                                    { myBypassState = state; }

    /// Updates the bypass flag of this node, if the new state is higher
    inline bool                 updateBypassState(BypassState state)
                                    {
                                        if (state > myBypassState)
                                        {
                                            myBypassState = state;
                                            return true;
                                        }

                                        return false;
                                    }

    // Returns the node's bypassed state
    inline BypassState          bypassState() const
                                    { return myBypassState; }

    /// Returns true if the node is bypassed
    inline bool                 isBypassed() const
                                    { return (myBypassState != eBypassNone); }

    /// Returns true if the node is a leaf, i.e it has no descendant nodes
    bool                        isLeaf() const;

    /// Returns true if the node is cooked, i.e. all wrappers and static items
    /// are cooked.
    bool                        isCooked() const;


    /// Dirties the node by deleting all static and dynamic work items, and
    /// dirtying (but not deleting) wrappers
    void                        dirty(bool remove_outputs);

    /// Prepares a dirty operation that can be applied later
    PDG_WorkItemDirty           prepareDirty();

    /// Appends to an existing dirty operation
    void                        appendDirty(PDG_WorkItemDirty* dirty_state);


    /// Freezes all work items in the node and their associated attribute
    /// data.
    void                        freeze();

    /// Cooks the node. This is a utility method that calls the standard
    /// cook logic on the the graph context
    bool                        cook(bool blocking, UT_WorkBuffer& errors);

    /// Cancels any work items scheduled by this node
    void                        cancel();

    /// Inserts a work item into the node after it has been deserialized. Based
    /// on the type of the item, it will be added to the various structures
    /// (wrapper list, partition maps, etc).
    virtual void                deserializeWorkItem(
                                    PDG_WorkItemPtr& work_item);

    /// Inserts a batch work item into the node after it has been deserialized
    void                        deserializeBatchWorkItem(
                                    PDG_BatchWorkItemPtr& batch_item);

    /// Called after a work item is completely deserialized.
    virtual void                commitWorkItem(PDG_WorkItem* work_item);

    /// Returns the cache state of a work item in this node
    virtual PDG_WorkItemCacheState
                                outputCacheState(
                                    const PDG_WorkItem* work_item) const;

    /// Reserves a number of work item indices in a contiguous block, and
    /// returns the first index value.
    int                         reserveIndexBlock(int number);


    /// Returns the node interface/template that describes the default 
    /// parameters and connections for the node
    const PDG_NodeInterface*    templateInterface() const override;

    /// Adds a custom/spare parameter to the node and returns a pointer to the
    /// the parameter port.
    PDG_Port*                   addCustomParameter(PDGT_Value::DataType type,
                                                   const UT_StringHolder& name,
                                                   const UT_StringHolder& label,
                                                   const UT_StringArray& tags,
                                                   int size);

    /// Returns node connectivity information
    int                         connectionCount(
                                            PDG_PortType type,
                                            bool filter_bypassed=true,
                                            bool filter_reference=true) const;
    void                        connectedNodes(
                                            PDG_NodeArray& nodes,
                                            PDG_PortType type,
                                            bool filter_bypassed=true,
                                            bool filter_reference=true) const;
    PDG_Node*                   firstConnectedNode(
                                            PDG_PortType type,
                                            bool filter_bypassed=true,
                                            bool filter_reference=true) const;
    void                        connectedAncestors(
                                            PDG_NodeSet& nodes,
                                            PDG_PortType type,
                                            bool filter_bypassed=true,
                                            bool filter_reference=true);

    /// Emits a node level error from the node as PDG_Event
    void                        addError(
                                    const UT_StringHolder& message)
                                    const override;

    /// Emits a node level warning from the node as PDG_Event
    void                        addWarning(
                                    const UT_StringHolder& message)
                                    const override;

    /// Handler for external dependencies, e.g. files. External dependencies
    /// that are added to the node will be resolved just before a work item in
    /// the node is cooked.
    const UT_Array<PDG_Dependency*>&
                                dependencies() const;
    void                        addDependency(PDG_Dependency* dependency);
    void                        removeDependency(PDG_Dependency* dependency);
    void                        resolveDependencies();


    /// Returns the underyling work item array. This method is not safe to call
    /// from external code if a cook or dirty is in progress.
    const PDG_WorkItemPtrArray& workItems() const
                                    { return myWorkItems; }

    /// Returns the IDs of the work items in the node
    void                        workItemIDs(
                                    PDG_WorkItemIDArray& array,
                                    bool include_batches) const;

    /// Returns a safe copy of the work item array
    void                        workItemsCopy(
                                    PDG_WorkItemArray& array,
                                    bool include_batches) const;

    /// Returns a safe copy of the work item array with a filter. The filter
    /// function is called for each work item, and can return false to indicate
    /// that the work item shouldn't be included in the copied list
    template <typename Filter>
    void                        workItemsCopy(
                                            PDG_WorkItemArray& array,
                                            const Filter& filter) const
                                    {
                                        UT_TBBSpinLock::Scope lock(
                                            myWorkItemLock);
                                        for (auto&& work_item : myWorkItems)
                                        {
                                            if (work_item &&
                                                filter(work_item.get()))
                                            {
                                                array.append(work_item.get());
                                            }
                                        }
                                    }

    /// Returns a safe copy of the batch work item set
    void                        batchItemsCopy(
                                    PDG_BatchWorkItemArray& batches) const;

    /// Aggregates output files from all work items. Safe to call from multiple
    /// threads or during a cook, and will return false/empty result if the 
    /// serial lock cannot be acquired
    bool                        outputFiles(PDG_File::Array& files,
                                            bool localize) const;

    /// Builds evaluation dependencies to cook a specific set of work items
    virtual void                queueWorkItemDeps(
                                            PDGE_Evaluator& evaluator,
                                            PDG_NodeSet& visited_nodes,
                                            PDG_WorkItemIDSet& visited_items,
                                            PDG_Filter& filter);

    /// Runs precook logic for this node and recurses into input nodes.
    bool                        preCook(PDG_NodeSet& dirty,
                                        PDG_NodeSet& visited,
                                        bool& save_scene,
                                        bool has_filter);


    /// Sets the loop depth and loop block reference on the node
    int                         preCookLoop(PDG_NodeSet& visited);


    /// Runs postcook logic for this node and recurses into input nodes.
    void                        postCook(PDG_NodeSet& visited);

    /// Adds or updates an existing file cache entry with the specified cache
    /// id. This will create an entry if one does not yet exist.
    PDG_CacheID                 addOutputCacheEntry(const UT_StringHolder& file,
                                                    PDG_CacheID cache_id);

    /// Adds or updates the dependent file attribute cache, and returns a new
    /// cache ID for the work itme based on the entry.
    PDG_CacheID                 addModTimeCacheEntry(
                                        const PDG_File& file,
                                        const PDG_WorkItem* work_item);

    /// Serializes the work items in the node to the specified stream
    bool                        saveJSON(std::ostream &os, bool binary);

    /// Serializes the work items in the node to the specified file
    bool                        saveJSON(const UT_StringHolder& file_path);

    /// Writes the current parameter value configuration of this node
    /// interface to JSON
    bool                        asJSON(
                                    UT_JSONWriter& writer,
                                    bool skip_defaults) const;

    /// Reads and constructs a scheduler from JSON and returns the instance
    static bool                 fromJSON(
                                    const UT_JSONValue* value,
                                    PDG_GraphContext* context,
                                    PDG_NodePortMap& inputs,
                                    UT_WorkBuffer& errors);

    /// Queues node dependencies for cooking with the evaluator
    static void                 queueNodeDeps(PDGE_Evaluator& evaluator,
                                              const PDG_NodeSet& leaf_nodes,
                                              const PDG_NodeSet& error_handlers,
                                              bool generate_only,
                                              bool cook);

protected:
    /// Tracks generation state of the node over a particular scope, using
    /// a counter since a node can be generating in multiple threads at a
    /// time.
    class PDG_API ScopedGenerate
    {
    public:
                    ScopedGenerate(PDG_Node* node);
                    ~ScopedGenerate();
                    UT_NON_COPYABLE(ScopedGenerate)
        inline bool isFirstGenerate() const { return myIsFirstGenerate; }

    private:
        PDG_Node*   myNode;
        fpreal      myStartTime;
        bool        myIsFirstGenerate;
    };

    /// Helper struct for validating and dirtying incomplete loop blocks. Each
    /// node in a loop is passed a vector of infos for any loops that pass
    /// through that node, which is usd to set the maximal loop depth and begin
    /// block list for each node in a block.
    struct LoopInfo
    {
        UT_StringHolder         myServiceName;
        PDG_ServiceResetWhen    myLoopResetWhen;
        PDG_ServiceResetType    myLoopResetType;
        const PDG_Node*         myBeginNode;
        bool                    myEndCooked;
    };

    /// Helper struct for tracking out of date files in file attributes with
    /// the `transfer` flag set.
    struct ModTimeCacheEntry
    {
        PDG_File            myFile;
        PDG_File::Hash      myLastStat;
        PDG_CacheID         myCacheId;
    };

    /// Enumerations of cook conditions
    enum CookWhen
    {
        /// Never queue work items in this node for cooking
        eCookNone,

        /// Queue work items in this node once the isGenerated dep reolves --
        /// these items will cook eventually, but may wait for targeted
        /// partitioners first.
        eCookDeferred,

        /// Queue work items for cooking immediately after they've been
        /// generated.
        eCookImmediate,
    };

    /// Enumeration of targeting conditions
    enum TargetedBy
    {
        /// No partitioner targets this node
        eTargetedNone   = 0x0,

        /// A partitioner set to generate when all items in this node are
        /// generated
        eTargetedAll    = 0x1,

        /// A partitioner set to generate each time items in this node are
        /// generated
        eTargetedEach   = 0x2,
    };

    /// The key for the node name when writing the node to JSON
    static const UT_StringHolder theNameKey;

    /// The key for the node type when writing the node to JSON
    static const UT_StringHolder theTypeKey;

    /// The key for the scheduler name when writing the node to JSON
    static const UT_StringHolder theSchedulerKey;

    /// The key for the input nodes when writing the node to JSON
    static const UT_StringHolder theInputsKey;
    
    /// The key for the parameters when writing the node to JSON
    static const UT_StringHolder theParametersKey;

protected:
    friend class PDG_BatchWorkItem;
    friend class PDG_Mapper;
    friend class PDG_Processor;
    friend class PDG_Partitioner;
    friend class PDG_WorkItem;
    friend class PDG_WorkItemDirty;

    inline UT_RWLock&           attributeLock() const
                                    { return myAttributeLock; }

    inline PDGE_Dependency*     canGenerateDep()
                                    { return &myCanGenerateDep; }
    inline PDGE_Dependency*     isGeneratedDep()
                                    { return &myIsGeneratedDep; }
    inline PDGE_Dependency*     isCookedDep()
                                    { return &myIsCookedDep; }

    inline PDGE_PropagateGroup* propagateGroup()
                                    { return &myPropagateGroup; }

    UT_StringHolder             debugName() const override
                                    { return name(); }

    void                        resetOwner() override;

    virtual int                 preCookLoop(
                                    PDG_NodeSet& visited,
                                    const UT_Array<LoopInfo>& begin_info);
    virtual bool                preCook(bool is_dirty, bool has_filter);
    virtual void                postCook();

    virtual void                clearAllWorkItems();
    virtual void                clearWorkItem(const PDG_WorkItem* work_item) {}
    virtual void                addWorkItem(PDG_WorkItem* work_item);
    virtual bool                queueWorkItem(PDG_WorkItem* work_item)
                                    { return false; }
    virtual bool                syncWorkItem(
                                        PDG_WorkItem* work_item,
                                        const PDG_WorkItem* parent,
                                        const PDG_WorkItem* clone_target)
                                    { return false; }
    virtual bool                cookWorkItem(
                                    PDGE_Resolutions& resolutions,
                                    PDG_WorkItem* work_item,
                                    bool did_cook);
    void                        removeWorkItems(
                                    const PDG_WorkItemConstArray& work_items);

    virtual PDG_WorkItemState   updateOutputCache(PDG_WorkItem* work_item) const
                                    { return PDG_WorkItemState::eUncooked; }

    virtual bool                cacheBuiltinParms(
                                    PDG_NodeSet& dirty,
                                    int num_inputs,
                                    bool dynamic_inputs);
    virtual void                addInputDeps(PDG_Node* input_node);
    virtual void                addCommonDeps();

    virtual bool                requiresCookedInputs(bool cook) const;

    virtual bool                shouldSchedule(
                                    const PDG_WorkItem* work_item) const
                                    { return false; }

    void                        injectDynamicWorkItem(
                                    PDG_WorkItemPtr& work_item);
    void                        addWorkItems(
                                    PDG_WorkItemPtrArray& work_items,
                                    PDG_BatchWorkItemPtrArray& batches,
                                    PDG_EvaluationContext::State state,
                                    bool merge_items);

    void                        addPropagateDependencies(
                                    PDG_WorkItem* work_item);
    void                        queueWorkItemResolutions(
                                    PDGE_Resolutions& resolutions,
                                    PDG_WorkItem* work_item,
                                    PDGE_Dependency* can_cook_dep);
    void                        queueBatchWorkItemResolutions(
                                    PDGE_Resolutions& resolutions,
                                    PDG_BatchWorkItem* batch_item,
                                    PDGE_Dependency* can_cook_dep);

    void                        needsNodeCook(
                                    UT_ArrayMap<PDG_Node*, bool>& needs_cook,
                                    bool cook);
    void                        queueNodeDeps(
                                    PDGE_Evaluator& evaluator,
                                    const UT_ArrayMap<PDG_Node*, bool>& needs_cook,
                                    const PDG_NodeSet& error_handlers,
                                    PDG_NodeSet& visited,
                                    bool generate_only,
                                    bool cook);

    void                        updateInputRegeneration();

    void                        applyDirty(bool remove_outputs);
    void                        prepareDirtyAll(
                                    PDG_WorkItemDirty& dirty_state,
                                    bool remove_outputs);

    bool                        compactItems(bool reset_index=false);

    bool                        upstreamItems(
                                        PDG_WorkItemArray& work_items,
                                        bool skip_failed=false) const;
    bool                        downstreamItems(
                                        PDG_WorkItemArray& work_items) const;

    void                        clearOutputCache();
    void                        updateModTimeCache();

    template <typename FieldType, typename EvalType=FieldType>
    void                        updateBuiltinField(
                                        PDG_NodeSet& dirty,
                                        const UT_StringHolder& parm_name,
                                        FieldType& field,
                                        const FieldType& default_value,
                                        bool set_dirty = true)
                                    {
                                        FieldType field_value = default_value;
                                        PDGT_Value* port_value =
                                            paramValue(parm_name);

                                        if (port_value)
                                        {
                                            EvalType eval_value;
                                            port_value->value(eval_value);
                                            field_value =
                                                (FieldType)(eval_value);
                                        }

                                        if (field == field_value)
                                            return;
                                        field = field_value;

                                        if (set_dirty && myHasCachedParms)
                                            dirty.insert(this);
                                    }

protected:
    PDG_NodeOptions             myNodeOptions;
    PDG_NodeStats               myNodeStats;
    PDG_SortOptions             mySortOptions;

    PDGE_Dependency             myCanGenerateDep;
    PDGE_Dependency             myIsGeneratedDep;
    PDGE_Dependency             myIsCookedDep;
    PDGE_PropagateGroup         myPropagateGroup;

    PDG_WorkItemPtrArray        myWorkItems;
    PDG_BatchWorkItemPtrArray   myBatchItems;

    PDG_NodeSet                 myStaticAncestors;
    PDG_NodeArray               myExtraInputs;
    UT_Array<PDG_Dependency*>   myDependencies;

    UT_ArrayStringMap<PDG_CacheID>
                                myOutputCache;
    UT_StringMap<ModTimeCacheEntry>
                                myModTimeCache;

    UT_StringHolder             myName;

    PDG_NodeCallbackPtr         myCallback;
    const PDG_NodeCallbackType* myTypeObject;

    PDG_GraphContext*           myContext;

    PDG_Scheduler*              myScheduler;
    PDG_SchedulerSet            mySchedulerReferences;

    UT_StringHolder             myServiceName;

    int                         myTargetedBy;
    int                         myLoopDepth;
    int                         myLoopBeginDepth;
    int                         myInputFilter;

    CookWhen                    myCookWhen;
    PDG_NodeRegenerateReason    myRegenerateReason;
    BypassState                 myBypassState;

    PDG_ServiceResetWhen        myLoopResetWhen;
    PDG_ServiceResetType        myLoopResetType;

    SYS_AtomicCounter           myActiveGenerates;
    SYS_AtomicCounter           myTotalGenerates;

    PDG_NodeID                  myId;
    int                         myMaxIndex;

    mutable UT_RWLock           myAttributeLock;
    mutable UT_TBBSpinLock      myWorkItemLock;
    mutable UT_TBBSpinLock      myOutputCacheLock;
    mutable UT_TBBSpinLock      myModTimeCacheLock;

    bool                        myIsDynamicGen;
    bool                        myIsDynamicEval;
    bool                        myIsDynamicProp;
    bool                        myIsAllGeneration;

    mutable bool                myHasError;
    bool                        myHasCachedParms;
    bool                        myCanHaveWorkItems;

    bool                        myIsErrorHandler;
    bool                        myIsErrorHandlerBranch;

    bool                        myIsGenerated;
    bool                        myIsActive;
    bool                        myIsCooked;
    bool                        myIsFrozen;

    bool                        myUseServiceBlock;
};

#endif /* __PDG_NODE_H__ */