PDG_BatchWorkItem.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_BATCHWORKITEM_H__
#define __PDG_BATCHWORKITEM_H__

#include "PDG_API.h"

#include "PDG_WorkItem.h"
#include "PDG_WorkItemTypes.h"

#include <UT/UT_StringHolder.h>
 
class PDG_API PDG_BatchWorkItem : public PDG_WorkItem
{
public:
                                PDG_BatchWorkItem(
                                    PDG_GraphContext* context,
                                    bool is_static = true,
                                    PDG_WorkItemID item_id = theInvalidId,
                                    int batch_size = 0);

                                ~PDG_BatchWorkItem() override;

    /// Returns the memory usage of this batch. Does not count sub items in the
    /// batch as they're technically owned by the node.
    void                        memoryInfo(PDG_MemoryInfo& memory_info,
                                           bool inclusive) const override;

    /// Returns the starting index for the batch, if it supports partial
    /// cooking.
    int                         batchStart() const;

    /// Returns the size of the batch
    int                         batchSize() const;

    /// Returns the list of sub items in the batch
    const PDG_WorkItemArray&    batchItems() const
                                    { return myBatchItems; }

    /// Returns the batch name; the prefix given to all sub items
    UT_StringHolder             batchName() const
                                    { return name(); }

    /// Resets the work item's dependency objects
    void                        resetOwner() override;

    /// Returns a sub item for a given index, or nullptr if the index is out 
    /// of the valid range.
    PDG_WorkItem*               subitem(int index) const;

    /// Inserts a subitem at a specific index. Used for deserialization
    void                        insertSubitem(int index, PDG_WorkItem* item);

    /// Initializes the batch item with a given sub item count and starting
    /// state
    void                        initBatchItems(
                                    PDG_WorkItemArray& items,
                                    int count);

    /// Reinitializes the batch item properties from the ones on this work
    /// item. Assumes the same batch size.
    void                        initBatchItems();

    /// Sets the pending dirty flag on all sub items
    void                        setPendingDirty(PendingDirty pending) override;

    /// Sets the partial batch flag
    void                        setIsPartialCook(bool is_partial);

    /// sets the is dynamic batch flag
    void                        setIsDynamicBatch(bool is_dynamic);

    /// Sets the work item command directly, and updates the cook type of any
    /// subitems in the batch
    bool                        setCommand(
                                    const UT_StringHolder& command,
                                    bool shell=false) override;

    /// Sets a per-platform work item command, and updates the cook type of
    /// any subitems in the batch
    bool                        setPlatformCommands(
                                    const UT_StringHolder& linux,
                                    const UT_StringHolder& mac,
                                    const UT_StringHolder& windows,
                                    bool shell=false) override;

    /// Returns the partial batch flag
    bool                        isPartialCook() const
                                    { return myIsPartialCook; }

    /// Returns true if the batch is allowed to dynamically add work items
    /// while it c ooks
    bool                        isDynamicBatch() const
                                    { return myIsDynamicBatch; }

    /// Sets the batch offset
    void                        setOffset(int offset);

    /// Returns the batch offset, e.g. the start of the first item in the real
    /// index space
    int                         offset() const
                                    { return myOffset; }

    /// Sets the activation mode of the batch
    void                        setActivationMode(
                                    PDG_BatchActivation mode);

    /// Sets the activation count, used when the activation mode is set to
    /// ActivateFixed.
    void                        setActivationCount(
                                    int activation_count);

    /// Gets the activation mode of the batch
    PDG_BatchActivation         activationMode() const;

    /// Gets the activation count
    int                         activationCount() const;

    /// Sets the start index of the batch
    void                        setStartIndex(int index);

    /// Sets a stat on the batch item, and the subitems if requested
    fpreal                      setTimeStat(PDG_WorkItemStats::StatType stat,
                                            bool batched) override;

    /// Returns the can cook dependency object for this work item
    PDGE_Dependency*            notCachedDep()
                                    { return &myNotCachedDep; }

    /// Tries marking the not cached dep as resolved
    void                        tryNotCached(
                                    PDGE_Resolutions& resolutions,
                                    PDG_WorkItem* work_item);

    /// Returns the active batch sub item, if any
    const PDG_WorkItem*         activeBatchItem() const;

    /// Sets the active batch sub item index, and returns that sub item if
    /// the index is valid
    const PDG_WorkItem*         setActiveBatchIndex(int index) const;

    /// Dynamically adds a new work item to the batch
    PDG_WorkItem*               appendSubItem(UT_WorkBuffer& errors);

    /// Returns the output file cache state of this work item
    PDG_WorkItemCacheState      outputCacheState() const override;

protected:
    /// Returns true if the entire batch is cached, else false
    PDG_WorkItemState           checkCached(bool add_results) override;

    /// Notifies the batch item than a given subitem index has finished cooking
    void                        notifyCook(PDGE_Resolutions& resolutions,
                                           PDG_WorkItemState result,
                                           int batch_index,
                                           fpreal duration,
                                           bool notify_all,
                                           bool static_cook,
                                           bool unresolve) override;

    /// Syncs the cache for all subitems
    void                        syncCacheId() override;

    /// Sets the frame of the batch item and all sub items, using the step
    /// size.
    bool                        setFrame(fpreal frame,
                                         fpreal frame_step,
                                         bool check_dirty) override;

    /// Called when one of the dependencies owned by this work item
    /// is resolved.
    PDGE_Dependency::State      evalResolve(
                                        PDGE_Resolutions& resolutions,
                                        const PDGE_Evaluator& evaluator,
                                        PDGE_Dependency* dependency) override;

private:
    PDG_WorkItemArray           myBatchItems;
    PDGE_Dependency             myNotCachedDep;

    int                         myOffset;
    int                         myStartIndex;
    int                         myCacheCheck;
    int                         myActivationCount;
    mutable int                 myActiveBatchIndex;

    PDG_BatchActivation         myActivationMode;
    bool                        myIsPartialCook;
    bool                        myIsDynamicBatch;
};

#endif /* __PDG_BATCHWORKITEM_H__ */