NvBlastTkTaskImpl.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2016-2020 NVIDIA Corporation. All rights reserved.


#ifndef NVBLASTTKTASKIMPL_H
#define NVBLASTTKTASKIMPL_H

#include "NvBlast.h"

#include "NvBlastTkFrameworkImpl.h"
#include "NvBlastTkEventQueue.h"
#include "NvBlastArray.h"

#include <atomic>
#include <mutex>
#include <condition_variable>

#include "NvBlastAssert.h"

#include "NvBlastTkGroup.h" // TkGroupStats


namespace Nv
{
namespace Blast
{

class TkGroupImpl;
class TkActorImpl;
class TkFamilyImpl;


struct TkWorkerJob
{
    TkActorImpl*    m_tkActor;          
    TkActorImpl**   m_newActors;        
    uint32_t        m_newActorsCount;   
};





template<typename T>
class SharedBlock
{
public:

    SharedBlock() : m_numElementsPerBlock(0), m_numBlocks(0), m_buffer(nullptr) {}

    void allocate(uint32_t elementsPerBlock, uint32_t numBlocks)
    {
        NVBLAST_ASSERT(elementsPerBlock > 0 && numBlocks > 0);

        m_buffer = reinterpret_cast<T*>(NVBLAST_ALLOC_NAMED(elementsPerBlock*numBlocks*sizeof(T), "SharedBlock"));
        m_numElementsPerBlock = elementsPerBlock;
        m_numBlocks = numBlocks;
    }

    T* getBlock(uint32_t id)
    {
        NVBLAST_ASSERT(id < m_numBlocks || 0 == m_numElementsPerBlock);
        return &m_buffer[id*m_numElementsPerBlock];
    }

    uint32_t numElementsPerBlock() const 
    {
        return m_numElementsPerBlock; 
    }

    void release()
    {
        m_numBlocks = 0;
        m_numElementsPerBlock = 0;
        NVBLAST_FREE(m_buffer);
        m_buffer = nullptr;
    }

private:
    uint32_t    m_numElementsPerBlock;  
    uint32_t    m_numBlocks;            
    T*          m_buffer;               
};


template<typename T>
class SharedBuffer
{
public:
    SharedBuffer() : m_capacity(0), m_used(0), m_buffer(nullptr) {}

    T* reserve(size_t n)
    {
        NVBLAST_ASSERT(m_used + n <= m_capacity);
        size_t start = m_used.fetch_add(n);
        return &m_buffer[start];
    }

    void allocate(size_t capacity)
    {
        NVBLAST_ASSERT(m_buffer == nullptr);
        m_buffer = reinterpret_cast<T*>(NVBLAST_ALLOC_NAMED(capacity*sizeof(T), "SplitMemory"));
        m_capacity = capacity;
    }

    void reset()
    {
        m_used = 0;
    }

    void release()
    {
        NVBLAST_ASSERT(m_buffer != nullptr);
        NVBLAST_FREE(m_buffer);
        m_buffer = nullptr;
        m_capacity = m_used = 0;
    }

private:
    size_t              m_capacity; 
    std::atomic<size_t> m_used;     
    T*                  m_buffer;   
};


template<typename T>
class LocalBuffer
{
public:
    T* allocate(size_t n)
    {
        if (m_used + n > m_capacity)
        {
            allocateNewBlock(n > m_capacity ? n : m_capacity);
        }

        size_t index = m_used;
        m_used += n;
        return &m_currentBlock[index];
    }

    void clear()
    {
        for (void* block : m_memoryBlocks)
        {
            NVBLAST_FREE(block);
        }
        m_memoryBlocks.clear();
    }

    void initialize(T* block, size_t capacity)
    {
        m_currentBlock = block;
        m_capacity = capacity;
        m_used = 0;
    }

private:
    void allocateNewBlock(size_t capacity)
    {
        BLAST_PROFILE_SCOPE_L("Local Buffer allocation");
        m_capacity = capacity;
        m_currentBlock = static_cast<T*>(NVBLAST_ALLOC_NAMED(capacity*sizeof(T), "Blast LocalBuffer"));
        m_memoryBlocks.pushBack(m_currentBlock);
        m_used = 0;
    }

    InlineArray<void*, 4>::type     m_memoryBlocks; 
    T*                              m_currentBlock; 
    size_t                          m_used;         
    size_t                          m_capacity;     
};


class SharedMemory
{
public:
    SharedMemory() : m_eventsMemory(0), m_eventsCount(0), m_refCount(0) {}

    NvBlastActor** reserveNewActors(size_t n)
    {
        return m_newActorBuffers.reserve(n);
    }

    TkActor** reserveNewTkActors(size_t n)
    {
        return m_newTkActorBuffers.reserve(n);
    }

    void allocate(TkFamilyImpl&);

    void reset()
    {
        m_newActorBuffers.reset();
        m_newTkActorBuffers.reset();
    }

    void addReference()         { m_refCount++; }

    void addReference(size_t n) { m_refCount += n; }

    bool removeReference()
    {
        m_refCount--;
        return !isUsed();
    }

    bool isUsed()
    {
        return m_refCount > 0;
    }

    void release()
    {
        m_newActorBuffers.release();
        m_newTkActorBuffers.release();
    }

    TkEventQueue                m_events;               
    uint32_t                    m_eventsMemory;         
    uint32_t                    m_eventsCount;          

private:
    size_t                      m_refCount;             

    SharedBuffer<NvBlastActor*> m_newActorBuffers;      
    SharedBuffer<TkActor*>      m_newTkActorBuffers;    
};


class TkWorker final : public TkGroupWorker
{
public:
    TkWorker() : m_id(~(uint32_t)0), m_group(nullptr), m_isBusy(false) {}

    void        process(uint32_t jobID);
    void        initialize();

    void        process(TkWorkerJob& job);

    uint32_t                                m_id;           
    TkGroupImpl*                            m_group;        

    LocalBuffer<NvBlastChunkFractureData>   m_chunkBuffer;  
    LocalBuffer<NvBlastBondFractureData>    m_bondBuffer;   

    void*                                   m_splitScratch;
    NvBlastFractureBuffers                  m_tempBuffer;
    bool                                    m_isBusy;

#if NV_PROFILE
    TkGroupStats    m_stats;
#endif
};
}
}

#endif // NVBLASTTKTASKIMPL_H