PDGE_Resolutions.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 __PDGE_RESOLUTIONS_H__
#define __PDGE_RESOLUTIONS_H__

#include "PDGE_API.h"

#include "PDGE_Dependency.h"
#include "PDGE_DependencyOwner.h"

#include <UT/UT_Array.h>
#include <UT/UT_ArrayMap.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_ParallelUtil.h>

class PDGE_Evaluator;

/*
 * An array of dependency resolutions, including both partial and full
 * resolutions.
 */
class PDGE_API PDGE_Resolutions : UT_NonCopyable
{
public:
                                PDGE_Resolutions(bool defer_heavy = true)
                                    : myIsSerial(false)
                                    , myIsDeferHeavy(defer_heavy) {}
                                    
                                PDGE_Resolutions(PDGE_Resolutions&& array)
                                    {
                                        myResolutions =
                                            std::move(array.myResolutions);
                                        myPartials = 
                                            std::move(array.myPartials);
                                        myIsSerial =
                                            array.myIsSerial;
                                        myIsDeferHeavy = 
                                            array.myIsDeferHeavy;
                                    }
    PDGE_Resolutions&           operator=(PDGE_Resolutions&& other)
                                    {
                                        if (this == &other)
                                            return *this;
                                        myResolutions =
                                            std::move(other.myResolutions);
                                        myPartials = 
                                            std::move(other.myPartials);
                                        myIsSerial = other.myIsSerial;
                                        myIsDeferHeavy = other.myIsDeferHeavy;
                                        return *this;
                                    }

    /// Returns the memory usage of this object
    int64                       getMemoryUsage(bool inclusive) const;

    /// Clears all exisiting resolutions from the array, including both partial
    /// and full resolves.
    inline void                 clearAll()
                                    {
                                        myResolutions.clear();
                                        myPartials.clear();
                                        myIsSerial = false;
                                    }

    /// Clears only partial resolutions from the array.
    inline void                 clearPartials()
                                    {
                                        myPartials.clear();
                                        myIsSerial = false;
                                    }

    /// Concats the contents of the specificed resolutions with the ones in
    /// this array. No deduplication is performed.
    inline void                 concat(const PDGE_Resolutions& resolutions)
                                    {
                                        myResolutions.concat(
                                            resolutions.myResolutions);
                                        myPartials.concat(
                                            resolutions.myPartials);
                                    }

    /// Returns the number of full resolutions in the array
    inline exint                numResolves() const
                                    { return myResolutions.size(); }

    /// Returns the number of partial resolutions in the array
    inline exint                numPartials() const
                                    { return myPartials.size(); }

    /// Returns true if partial evaluation should be performed in serial
    /// instead of in parallel
    inline bool                 isSerial() const
                                    { return myIsSerial; }


    /// Adds a new dependency to the list of full resolutions
    inline void                 addResolve(PDGE_Dependency* dependency)
                                    { myResolutions.append(dependency); }

    /// Adds a new dependency to the list of partial resolutions, along with
    /// the owner argument associated with the partial resolution.
    bool                        addPartial(
                                    PDGE_Dependency* dependency,
                                    const PDGE_DependencyOwner::Array& owners,
                                    bool ascending=true,
                                    bool serial=false);

    /// Same as above, but with a single owner argument for convenience
    bool                        addPartial(
                                    PDGE_Dependency* dependency,
                                    PDGE_DependencyOwner* owner,
                                    bool ascending=true,
                                    bool serial=false);

    /// Save as above, but with an arbitrarily typed array
    template <typename T>
    bool                        addPartial(
                                    PDGE_Dependency* dependency,
                                    const UT_Array<T>& owners,
                                    bool ascending=true,
                                    bool serial=false)
                                        {
                                            PDGE_DependencyOwner::Array output;
                                            PDGE_DependencyOwner::cast<T>(
                                                output, owners);

                                            return addPartial(dependency,
                                                              output,
                                                              ascending,
                                                              serial);
                                        }

    /// Evaluates all full resolutions in the array. This function should be
    /// called from a UTparallelFor.
    void                        evaluateResolves(
                                    const UT_BlockedRange<int64>& range,
                                    PDGE_Evaluator& evaluator,
                                    PDGE_Resolutions& resolutions,
                                    PDGE_Resolutions& deferred) const;

    /// Evaluates all partial resolutions and stores new resolutions into the
    /// supplied array. This function should be called from a UTparalleReduce.
    void                        evaluatePartials(
                                    const UT_BlockedRange<int64>& range,
                                    PDGE_Evaluator& evaluator,
                                    PDGE_Resolutions& resolutions) const;

private:
    PDGE_Dependency::Array      myResolutions;
    PDGE_Dependency::Partial    myPartials;
    bool                        myIsSerial;
    bool                        myIsDeferHeavy;
};

#endif