#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>

Include dependency graph for PDG_WorkItemTypes.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
using	PDG_WorkItemDataPtr = UT_SharedPtr< PDG_WorkItemData >
	Type def for registered type objects. More...

using	PDG_WorkItemID = exint
	Type defs for unique work item IDs. More...

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 >>

using	PDG_WorkItemPtr = UT_UniquePtr< PDG_WorkItem >
	Work item pointers. More...

using	PDG_BatchWorkItemPtr = UT_UniquePtr< PDG_BatchWorkItem >

using	PDG_WorkItemArray = UT_Array< PDG_WorkItem * >
	Array, set and map of work items. More...

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 >

using	PDG_WorkItemPair = std::pair< PDG_WorkItem , PDG_WorkItem >
	Pair and array of work item pairs. More...

using	PDG_WorkItemPairArray = UT_Array< PDG_WorkItemPair >

using	PDG_BatchWorkItemArray = UT_Array< PDG_BatchWorkItem * >
	Array and set of batch work items. More...

using	PDG_BatchWorkItemPtrArray = UT_Array< PDG_BatchWorkItemPtr >

using	PDG_BatchWorkItemSet = UT_ArraySet< PDG_BatchWorkItem * >

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

Enumerations
enum	PDG_BatchActivation { PDG_BatchActivation::eAny, PDG_BatchActivation::eFirst, PDG_BatchActivation::eAll, PDG_BatchActivation::eFixed }

enum	PDG_WorkItemEvalState { PDG_WorkItemEvalState::eEvalBlocked, PDG_WorkItemEvalState::eEvalReady, PDG_WorkItemEvalState::eEvalFailed }

enum	PDG_WorkItemCacheState { PDG_WorkItemCacheState::eUndefined, PDG_WorkItemCacheState::eDirtyAlways, PDG_WorkItemCacheState::eDirtyEmpty, PDG_WorkItemCacheState::eDirtyNew, PDG_WorkItemCacheState::eDirtyStale, PDG_WorkItemCacheState::eDirtyMissing, PDG_WorkItemCacheState::eCleanPending, PDG_WorkItemCacheState::eClean }

enum	PDG_WorkItemLogType { PDG_WorkItemLogType::eLogError, PDG_WorkItemLogType::eLogWarning, PDG_WorkItemLogType::eLogMessage, PDG_WorkItemLogType::eLogRaw }
	Enumeration of work item log message types. More...

enum	PDG_WorkItemSortOrder : uint8 { PDG_WorkItemSortOrder::eSortNone, PDG_WorkItemSortOrder::eSortIndex, PDG_WorkItemSortOrder::eSortInputOrder, PDG_WorkItemSortOrder::eSortAttribute, PDG_WorkItemSortOrder::eSortFrame }

enum	PDG_WorkItemState : uint8 { PDG_WorkItemState::eUndefined, PDG_WorkItemState::eUncooked, PDG_WorkItemState::eWaiting, PDG_WorkItemState::eScheduled, PDG_WorkItemState::eCooking, PDG_WorkItemState::eCookedSuccess, PDG_WorkItemState::eCookedCache, PDG_WorkItemState::eCookedFail, PDG_WorkItemState::eCookedCancel, PDG_WorkItemState::eDirty, PDG_WorkItemState::eStateCount }
	Enum of possible work item states. More...

enum	PDG_WorkItemType : uint8 { PDG_WorkItemType::eRegular, PDG_WorkItemType::eBatch, PDG_WorkItemType::ePartition }
	Enum of work item types. More...

enum	PDG_WorkItemExecutionType : uint8 { PDG_WorkItemExecutionType::eRegular, PDG_WorkItemExecutionType::eLongRunning, PDG_WorkItemExecutionType::eCleanup }
	Enum of work item runtime types. More...

enum	PDG_WorkItemCookType : uint8 { PDG_WorkItemCookType::eGenerate, PDG_WorkItemCookType::eInProcess, PDG_WorkItemCookType::eOutOfProcess, PDG_WorkItemCookType::eService, PDG_WorkItemCookType::eAutomatic }
	Enumeration of work item cook types. More...

enum	PDG_WorkItemPendingDirty : uint8 { PDG_WorkItemPendingDirty::eNone, PDG_WorkItemPendingDirty::eDirty, PDG_WorkItemPendingDirty::eDelete }
	Enumeration of pending work item dirty states. More...

Typedef Documentation

using PDG_BatchWorkItemArray = UT_Array<PDG_BatchWorkItem*>

Array and set of batch work items.

Definition at line 57 of file PDG_WorkItemTypes.h.

using PDG_BatchWorkItemPtr = UT_UniquePtr<PDG_BatchWorkItem>

Definition at line 42 of file PDG_WorkItemTypes.h.

using PDG_BatchWorkItemPtrArray = UT_Array<PDG_BatchWorkItemPtr>

Definition at line 58 of file PDG_WorkItemTypes.h.

using PDG_BatchWorkItemSet = UT_ArraySet<PDG_BatchWorkItem*>

Definition at line 59 of file PDG_WorkItemTypes.h.

using PDG_OptionalFrame = UT_Optional<fpreal>

Optional frame value, used when constructing work items and partitions.

Definition at line 62 of file PDG_WorkItemTypes.h.

using PDG_WorkItemArray = UT_Array<PDG_WorkItem*>

Array, set and map of work items.

Definition at line 45 of file PDG_WorkItemTypes.h.

using PDG_WorkItemConstArray = UT_Array<const PDG_WorkItem*>

Definition at line 48 of file PDG_WorkItemTypes.h.

using PDG_WorkItemDataPtr = UT_SharedPtr<PDG_WorkItemData>

Type def for registered type objects.

Definition at line 26 of file PDG_WorkItemTypes.h.

using PDG_WorkItemID = exint

Type defs for unique work item IDs.

Definition at line 29 of file PDG_WorkItemTypes.h.

using PDG_WorkItemIDArray = UT_Array<PDG_WorkItemID>

Definition at line 30 of file PDG_WorkItemTypes.h.

using PDG_WorkItemIDBoolMap = UT_ArrayMap< PDG_WorkItemID, std::pair<const PDG_WorkItem*, bool>>

Definition at line 35 of file PDG_WorkItemTypes.h.

using PDG_WorkItemIDMap = UT_ArrayMap<PDG_WorkItemID, PDG_WorkItem*>

Definition at line 32 of file PDG_WorkItemTypes.h.

using PDG_WorkItemIDSet = UT_ArraySet<PDG_WorkItemID>

Definition at line 31 of file PDG_WorkItemTypes.h.

using PDG_WorkItemMap = UT_ArrayMap<PDG_WorkItem*, PDG_WorkItemSet>

Definition at line 50 of file PDG_WorkItemTypes.h.

using PDG_WorkItemPair = std::pair<PDG_WorkItem*, PDG_WorkItem*>

Pair and array of work item pairs.

Definition at line 53 of file PDG_WorkItemTypes.h.

using PDG_WorkItemPairArray = UT_Array<PDG_WorkItemPair>

Definition at line 54 of file PDG_WorkItemTypes.h.

using PDG_WorkItemPtr = UT_UniquePtr<PDG_WorkItem>

Work item pointers.

Definition at line 41 of file PDG_WorkItemTypes.h.

using PDG_WorkItemPtrArray = UT_Array<PDG_WorkItemPtr>

Definition at line 46 of file PDG_WorkItemTypes.h.

using PDG_WorkItemSet = UT_ArraySet<PDG_WorkItem*>

Definition at line 49 of file PDG_WorkItemTypes.h.

Enumeration Type Documentation

enum PDG_BatchActivation

strong

Enumeration of activiation modes for the batch, i.e. the condition under which the batch item is first submitted to the scheduler

Enumerator
eAny	The batch is scheduled once any of the subitems are ready to cook.
eFirst	The batch is scheduled once the first sub item is ready to cook.
eAll	The batch is scheduled once all of the subitems are ready to cook.
eFixed	The batch is scheduled once a specific number of subitems are ready to cook

Definition at line 66 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemCacheState

strong

Enumeration of work item cache states, returned when checking if a work item is cached with respect to a particular node

Enumerator
eUndefined	The work item's cache state is undefined, e.g. because it doesn't exist or the node doesn't support caching
eDirtyAlways	The cache state is always dirty, usually due to the node's caching mode parameter
eDirtyEmpty	The cache state is dirty because the work item has no files.
eDirtyNew	The cache state is dirty because the work item has new files that didn't exist on a previous cook
eDirtyStale	The cache state is dirty because the work item is stale with respect to its input tasks
eDirtyMissing	The cache state is dirty because an output file is missing on disk.
eCleanPending	The cache is clean, assuming the parent task is also clean.
eClean	The cache is clean.

Definition at line 98 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemCookType : uint8

strong

Enumeration of work item cook types.

Enumerator
eGenerate	The work item does its processing during the generation stage, and doesn't "cook" in the traditional sense.
eInProcess	The work item cooks in process.
eOutOfProcess	The work item cooks out of process.
eService	The work item cooks as a service.
eAutomatic	Unspecified/automatic cook type.

Definition at line 239 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemEvalState

strong

Enumeration of evaluation states that a work item can be in. Used when checking if the subitem is able to evaluate yet.

Enumerator
eEvalBlocked	The work item is blocked on a dependency.
eEvalReady	The work item is ready to cook.
eEvalFailed	The work item has a failed dependency.

Definition at line 84 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemExecutionType : uint8

strong

Enum of work item runtime types.

Enumerator
eRegular	A regular work item, with normal running time.
eLongRunning	A long running work item that's process may outlive the cooking state of the work item
eCleanup	A work item that cleans up another long running item.

Definition at line 225 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemLogType

strong

Enumeration of work item log message types.

Enumerator
eLogError	Error log message.
eLogWarning	Warning log message.
eLogMessage	Plain log message.
eLogRaw	Raw log data.

Definition at line 130 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemPendingDirty : uint8

strong

Enumeration of pending work item dirty states.

Enumerator
eNone	The item does not require any sort of dirtying.
eDirty	The item needs to be dirtied, but not deleted.
eDelete	the item needs to be deleted

Definition at line 259 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemSortOrder : uint8

strong

Enumeration of sort order types, currently used by the partitionItems method

Enumerator
eSortNone	Explicitly chosen no sorting.
eSortIndex	Index based sorting.
eSortInputOrder	Input ordering.
eSortAttribute	Order by a specific attribute value.
eSortFrame	Order by the work item's frame value.

Definition at line 147 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemState : uint8

strong

Enum of possible work item states.

Enumerator
eUndefined	Undefined state, e.g. for uninitialized data. Work items should never actually have this state
eUncooked	The item is uncooked and no cooked has been attempted yet.
eWaiting	The item is uncooked and waiting on its dependencies to finish cooking
eScheduled	The item has been sent to the scheduler(s), but might not yet be executing
eCooking	The item is cooking.
eCookedSuccess	The item has finished cooking and succeeded.
eCookedCache	The item has was marked as successfully cooked because it a cached file was found on disk
eCookedFail	The item has finished cooking and failed.
eCookedCancel	The item has finished cooking by cancellation.
eDirty	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.
eStateCount	The number of states.

Definition at line 166 of file PDG_WorkItemTypes.h.

enum PDG_WorkItemType : uint8

strong

Enum of work item types.

Enumerator
eRegular	A static or dynamic work item that does real work, and has one upstream parent
eBatch	A batch item, which consists of one or more subitems that are Regular type items
ePartition	A partition, which has a list of upstream components.

Definition at line 210 of file PDG_WorkItemTypes.h.

Typedefs

Enumerations

Typedef Documentation

Enumeration Type Documentation