NvBlastTkEventQueue.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 NVBLASTTKEVENTQUEUE_H
#define NVBLASTTKEVENTQUEUE_H

#include <algorithm>
#include <vector>

#include <mutex>
#include <atomic>

#include "NvBlastTkFrameworkImpl.h"
#include "NvBlastAssert.h"


namespace Nv {
namespace Blast {

class TkEventQueue
{
public:
    TkEventQueue() : m_currentEvent(0), m_poolCapacity(0), m_pool(nullptr), m_allowAllocs(true) {}

    operator const Array<TkEvent>::type&() 
    {
        NVBLAST_ASSERT(m_allowAllocs);
        NVBLAST_ASSERT(m_currentEvent == m_events.size());
        return m_events; 
    }

    void protect(bool enable)
    {
        // During parallel use, m_events.size() and m_currentEvent are allowed to diverge.
        // This is fine because resizeUninitialized does not alter the stored data.
        NVBLAST_ASSERT(m_currentEvent <= m_events.capacity());
        m_events.resizeUninitialized(m_currentEvent);
        m_allowAllocs = !enable;
    }

    void reset()
    {
        m_events.clear();
        m_currentEvent = 0;
        for (void* mem : m_memory)
        {
            NVBLAST_FREE(mem);
        }
        m_memory.clear();
        m_currentData = 0;
        m_allowAllocs = true;
        m_poolCapacity = 0;
        m_pool = nullptr;
    }

    template<class T>
    void addEvent(T* payload)
    {
        uint32_t index = m_currentEvent.fetch_add(1);

        // Should not allocate in protected state.
        NVBLAST_ASSERT(m_allowAllocs || m_currentEvent <= m_events.capacity());

        m_events.resizeUninitialized(m_currentEvent);

        // During parallel use, m_events.size() and m_currentEvent are allowed to diverge.
        // Consistency is restored in protect().
        NVBLAST_ASSERT(!m_allowAllocs || m_currentEvent == m_events.size());

        TkEvent& evt = m_events[index];
        evt.type = TkEvent::Type(T::EVENT_TYPE);
        evt.payload = payload;
    }

    template<typename T>
    T* allocData()
    {
        uint32_t index = m_currentData.fetch_add(sizeof(T));
        if (m_currentData <= m_poolCapacity)
        {
            return reinterpret_cast<T*>(&m_pool[index]);
        }
        else
        {
            // Could do larger block allocation here.
            reserveData(sizeof(T));
            // Account for the requested size.
            m_currentData = sizeof(T);
            return reinterpret_cast<T*>(&m_pool[0]);
        }
    }

    void reserveData(size_t size)
    {
        NVBLAST_ASSERT(m_allowAllocs);
        m_pool = reinterpret_cast<uint8_t*>(allocDataBySize(size));
        m_poolCapacity = size;
        m_currentData = 0;
    }

    void reserveEvents(uint32_t n)
    {
        NVBLAST_ASSERT(m_allowAllocs);
        m_events.reserve(m_events.size() + n);
    }

    void addListener(TkEventListener& l)
    {
        m_listeners.pushBack(&l);
    }

    void removeListener(TkEventListener& l)
    {
        m_listeners.findAndReplaceWithLast(&l);
    }

    void dispatch()
    {
        dispatch(*this);
        reset();
    }

    void dispatch(const Array<TkEvent>::type& events) const
    {
        if (events.size())
        {
            for (TkEventListener* l : m_listeners)
            {
                BLAST_PROFILE_SCOPE_M("TkEventQueue::dispatch");
                l->receive(events.begin(), events.size());
            }
        }
    }

private:
    void* allocDataBySize(size_t size)
    {
        void* memory = nullptr;
        if (size > 0)
        {
            memory = NVBLAST_ALLOC_NAMED(size, "TkEventQueue Data");
            m_memory.pushBack(memory);
        }
        return memory;
    }


    Array<TkEvent>::type                    m_events;       
    Array<void*>::type                      m_memory;       
    std::atomic<uint32_t>                   m_currentEvent; 
    std::atomic<uint32_t>                   m_currentData;  
    size_t                                  m_poolCapacity; 
    uint8_t*                                m_pool;         
    bool                                    m_allowAllocs;  
    InlineArray<TkEventListener*,4>::type   m_listeners;    
};

}   // namespace Blast
}   // namespace Nv


#endif  // ifndef NVBLASTTKEVENTQUEUE_H