LargeIslandSplitter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/NonCopyable.h>
#include <Jolt/Core/Atomics.h>
 
JPH_NAMESPACE_BEGIN
 
class Body;
class BodyID;
class IslandBuilder;
class TempAllocator;
class Constraint;
class BodyManager;
class ContactConstraintManager;
class CalculateSolverSteps;
 
class LargeIslandSplitter : public NonCopyable
{
private:
    using                   SplitMask = uint32;
 
public:
    static constexpr uint   cNumSplits = sizeof(SplitMask) * 8;
    static constexpr uint   cNonParallelSplitIdx = cNumSplits - 1;
    static constexpr uint   cLargeIslandTreshold = 128;                         
 
    enum class EStatus
    {
        WaitingForBatch,                                                        
        BatchRetrieved,                                                         
        AllBatchesDone,                                                         
    };
 
    struct Split
    {
        inline uint         GetNumContacts() const                              { return mContactBufferEnd - mContactBufferBegin; }
        inline uint         GetNumConstraints() const                           { return mConstraintBufferEnd - mConstraintBufferBegin; }
        inline uint         GetNumItems() const                                 { return GetNumContacts() + GetNumConstraints(); }
 
        uint32              mContactBufferBegin;                                
        uint32              mContactBufferEnd;                                  
 
        uint32              mConstraintBufferBegin;                             
        uint32              mConstraintBufferEnd;                               
    };
 
    class Splits
    {
    public:
        inline uint         GetNumSplits() const
        {
            return mNumSplits;
        }
 
        inline void         GetConstraintsInSplit(uint inSplitIndex, uint32 &outConstraintsBegin, uint32 &outConstraintsEnd) const
        {
            const Split &split = mSplits[inSplitIndex];
            outConstraintsBegin = split.mConstraintBufferBegin;
            outConstraintsEnd = split.mConstraintBufferEnd;
        }
 
        inline void         GetContactsInSplit(uint inSplitIndex, uint32 &outContactsBegin, uint32 &outContactsEnd) const
        {
            const Split &split = mSplits[inSplitIndex];
            outContactsBegin = split.mContactBufferBegin;
            outContactsEnd = split.mContactBufferEnd;
        }
 
        inline void         ResetStatus()
        {
            mStatus.store(StatusItemMask, memory_order_relaxed);
        }
 
        inline void         StartFirstBatch()
        {
            uint split_index = mNumSplits > 0? 0 : cNonParallelSplitIdx;
            mStatus.store(uint64(split_index) << StatusSplitShift, memory_order_release);
        }
 
        EStatus             FetchNextBatch(uint32 &outConstraintsBegin, uint32 &outConstraintsEnd, uint32 &outContactsBegin, uint32 &outContactsEnd, bool &outFirstIteration);
 
        void                MarkBatchProcessed(uint inNumProcessed, bool &outLastIteration, bool &outFinalBatch);
 
        enum EIterationStatus : uint64
        {
            StatusIterationMask     = 0xffff000000000000,
            StatusIterationShift    = 48,
            StatusSplitMask         = 0x0000ffff00000000,
            StatusSplitShift        = 32,
            StatusItemMask          = 0x00000000ffffffff,
        };
 
        static inline int   sGetIteration(uint64 inStatus)
        {
            return int((inStatus & StatusIterationMask) >> StatusIterationShift);
        }
 
        static inline uint  sGetSplit(uint64 inStatus)
        {
            return uint((inStatus & StatusSplitMask) >> StatusSplitShift);
        }
 
        static inline uint  sGetItem(uint64 inStatus)
        {
            return uint(inStatus & StatusItemMask);
        }
 
        Split               mSplits[cNumSplits];                                
        uint32              mIslandIndex;                                       
        uint                mNumSplits;                                         
        int                 mNumIterations;                                     
        int                 mNumVelocitySteps;                                  
        int                 mNumPositionSteps;                                  
        atomic<uint64>      mStatus;                                            
        atomic<uint>        mItemsProcessed;                                    
    };
 
public:
                            ~LargeIslandSplitter();
 
    void                    Prepare(const IslandBuilder &inIslandBuilder, uint32 inNumActiveBodies, TempAllocator *inTempAllocator);
 
    uint                    AssignSplit(const Body *inBody1, const Body *inBody2);
 
    uint                    AssignToNonParallelSplit(const Body *inBody);
 
    bool                    SplitIsland(uint32 inIslandIndex, const IslandBuilder &inIslandBuilder, const BodyManager &inBodyManager, const ContactConstraintManager &inContactManager, Constraint **inActiveConstraints, CalculateSolverSteps &ioStepsCalculator);
 
    EStatus                 FetchNextBatch(uint &outSplitIslandIndex, uint32 *&outConstraintsBegin, uint32 *&outConstraintsEnd, uint32 *&outContactsBegin, uint32 *&outContactsEnd, bool &outFirstIteration);
 
    void                    MarkBatchProcessed(uint inSplitIslandIndex, const uint32 *inConstraintsBegin, const uint32 *inConstraintsEnd, const uint32 *inContactsBegin, const uint32 *inContactsEnd, bool &outLastIteration, bool &outFinalBatch);
 
    inline uint32           GetIslandIndex(uint inSplitIslandIndex) const
    {
        JPH_ASSERT(inSplitIslandIndex < mNumSplitIslands);
        return mSplitIslands[inSplitIslandIndex].mIslandIndex;
    }
 
    void                    PrepareForSolvePositions();
 
    void                    Reset(TempAllocator *inTempAllocator);
 
private:
    static constexpr uint   cSplitCombineTreshold = 32;                         
    static constexpr uint   cBatchSize = 16;                                    
 
    uint32                  mNumActiveBodies = 0;                               
 
    SplitMask *             mSplitMasks = nullptr;                              
 
    uint32 *                mContactAndConstraintsSplitIdx = nullptr;           
    uint32 *                mContactAndConstraintIndices = nullptr;             
    uint                    mContactAndConstraintsSize = 0;                     
    atomic<uint>            mContactAndConstraintsNextFree { 0 };               
 
    uint                    mNumSplitIslands = 0;                               
    Splits *                mSplitIslands = nullptr;                            
    atomic<uint>            mNextSplitIsland = 0;                               
};
 
JPH_NAMESPACE_END