PDG_WorkItemTypes.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_WORK_ITEM_TYPES_H__
#define __PDG_WORK_ITEM_TYPES_H__

#include <UT/UT_Array.h>
#include <UT/UT_ArrayMap.h>
#include <UT/UT_ArraySet.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_Optional.h>
#include <UT/UT_UniquePtr.h>

#include <SYS/SYS_Types.h>

class PDG_BatchWorkItem;
class PDG_WorkItem;
class PDG_WorkItemData;

/// Type def for registered type objects
using PDG_WorkItemDataPtr       = UT_SharedPtr<PDG_WorkItemData>;

/// Type defs for unique work item IDs
using PDG_WorkItemID            = exint;
using PDG_WorkItemIDArray       = UT_Array<PDG_WorkItemID>;
using PDG_WorkItemIDSet         = UT_ArraySet<PDG_WorkItemID>;
using PDG_WorkItemIDMap         = UT_ArrayMap<PDG_WorkItemID, PDG_WorkItem*>;
using PDG_WorkItemIDBoolMap     = UT_ArrayMap<
                                    PDG_WorkItemID,
                                    std::pair<const PDG_WorkItem*, bool>>;

/// Default, invalid work item ID value.
static constexpr PDG_WorkItemID PDG_WorkItemInvalidID = -1;

/// Work item pointers
using PDG_WorkItemPtr           = UT_UniquePtr<PDG_WorkItem>;
using PDG_BatchWorkItemPtr      = UT_UniquePtr<PDG_BatchWorkItem>;

/// Array, set and map of work items
using PDG_WorkItemArray         = UT_Array<PDG_WorkItem*>;
using PDG_WorkItemPtrArray      = UT_Array<PDG_WorkItemPtr>;

using PDG_WorkItemConstArray    = UT_Array<const PDG_WorkItem*>;
using PDG_WorkItemSet           = UT_ArraySet<PDG_WorkItem*>;
using PDG_WorkItemMap           = UT_ArrayMap<PDG_WorkItem*, PDG_WorkItemSet>;

/// Pair and array of work item pairs
using PDG_WorkItemPair          = std::pair<PDG_WorkItem*, PDG_WorkItem*>;
using PDG_WorkItemPairArray     = UT_Array<PDG_WorkItemPair>;

/// Array and set of batch work items
using PDG_BatchWorkItemArray    = UT_Array<PDG_BatchWorkItem*>;
using PDG_BatchWorkItemPtrArray = UT_Array<PDG_BatchWorkItemPtr>;
using PDG_BatchWorkItemSet      = UT_ArraySet<PDG_BatchWorkItem*>;

/// Optional frame value, used when constructing work items and partitions
using PDG_OptionalFrame         = UT_Optional<fpreal>;

/// Enumeration of activiation modes for the batch, i.e. the condition under
/// which the batch item is first submitted to the scheduler
enum class PDG_BatchActivation
{
    /// The batch is scheduled once any of the subitems are ready to cook
    eAny,

    /// The batch is scheduled once the first sub item is ready to cook
    eFirst,

    /// The batch is scheduled once all of the subitems are ready to cook
    eAll,

    /// The batch is scheduled once a specific number of subitems are ready
    /// to cook
    eFixed
};

/// Enumeration of evaluation states that a work item can be in. Used when
/// checking if the subitem is able to evaluate yet.
enum class PDG_WorkItemEvalState
{
    /// The work item is blocked on a dependency
    eEvalBlocked,

    /// The work item is ready to cook
    eEvalReady,

    /// The work item has a failed dependency
    eEvalFailed,
};

/// Enumeration of work item cache states, returned when checking if a work
/// item is cached with respect to a particular node
enum class PDG_WorkItemCacheState
{
    /// The work item's cache state is undefined, e.g. because it doesn't
    /// exist or the node doesn't support caching
    eUndefined,

    /// The cache state is always dirty, usually due to the node's caching
    /// mode parameter
    eDirtyAlways,

    /// The cache state is dirty because the work item has no files
    eDirtyEmpty,

    /// The cache state is dirty because the work item has new files that
    /// didn't exist on a previous cook
    eDirtyNew,

    /// The cache state is dirty because the work item is stale with
    /// respect to its input tasks
    eDirtyStale,

    /// The cache state is dirty because an output file is missing on disk
    eDirtyMissing,

    /// The cache is clean, assuming the parent task is also clean
    eCleanPending,

    /// The cache is clean
    eClean,
};

/// Enumeration of work item log message types
enum class PDG_WorkItemLogType
{
    /// Error log message
    eLogError,

    /// Warning log message
    eLogWarning,

    /// Plain log message
    eLogMessage,

    /// Raw log data
    eLogRaw,
};

/// Enumeration of sort order types, currently used by the partitionItems
/// method
enum class PDG_WorkItemSortOrder : uint8
{
    /// Explicitly chosen no sorting
    eSortNone,

    /// Index based sorting
    eSortIndex,

    /// Input ordering
    eSortInputOrder,

    /// Order by a specific attribute value
    eSortAttribute,

    /// Order by the work item's frame value
    eSortFrame,
};

/// Enum of possible work item states
enum class PDG_WorkItemState : uint8
{
    /// Undefined state, e.g. for uninitialized data. Work items should never
    /// actually have this state
    eUndefined,

    /// The item is uncooked and no cooked has been attempted yet
    eUncooked,  

    /// The item is uncooked and waiting on its dependencies to finish 
    /// cooking
    eWaiting,

    /// The item has been sent to the scheduler(s), but might not yet
    /// be executing
    eScheduled,

    /// The item is cooking
    eCooking,

    /// The item has finished cooking and succeeded
    eCookedSuccess,

    /// The item has was marked as successfully cooked because it a cached
    /// file was found on disk
    eCookedCache,

    /// The item has finished cooking and failed
    eCookedFail,

    /// The item has finished cooking by cancellation
    eCookedCancel,

    /// The item was dirty; it may have been cooked before, but not 
    /// necessarily. This is effectively the same as uncooked, but it
    /// gives an indication that item may need additional cleanup or 
    /// repartitioning.
    eDirty,

    /// The number of states
    eStateCount,
};

/// Enum of work item types
enum class PDG_WorkItemType : uint8
{
    /// A static or dynamic work item that does real work, and has one 
    /// upstream parent
    eRegular,

    /// A batch item, which consists of one or more subitems that are 
    /// Regular type items
    eBatch,

    /// A partition, which has a list of upstream components
    ePartition,
};

/// Enum of work item runtime types
enum class PDG_WorkItemExecutionType : uint8
{
    /// A regular work item, with normal running time
    eRegular,

    /// A long running work item that's process may outlive the cooking state
    /// of the work item
    eLongRunning,

    /// A work item that cleans up another long running item
    eCleanup
};

/// Enumeration of work item cook types
enum class PDG_WorkItemCookType :  uint8
{
    /// The work item does its processing during the generation stage,
    /// and doesn't "cook" in the traditional sense.
    eGenerate,

    /// The work item cooks in process
    eInProcess,

    /// The work item cooks out of process
    eOutOfProcess,

    /// The work item cooks as a service
    eService,

    /// Unspecified/automatic cook type
    eAutomatic
};

/// Enumeration of pending work item dirty states
enum class PDG_WorkItemPendingDirty : uint8
{
    /// The item does not require any sort of dirtying
    eNone,

    /// The item needs to be dirtied, but not deleted
    eDirty,

    /// the item needs to be deleted
    eDelete
};

#endif /* __PDG_WORK_ITEM_TYPES_H__ */