PxProfileEventBufferAtomic.h

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2022 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
 
#ifndef PX_PROFILE_EVENT_BUFFER_ATOMIC_H
#define PX_PROFILE_EVENT_BUFFER_ATOMIC_H
 
#include "PxProfileEvents.h"
#include "PxProfileEventSerialization.h"
#include "PxProfileDataBuffer.h"
 
#include "foundation/PxArray.h"
#include "foundation/PxAtomic.h"
#include "foundation/PxAllocator.h"
#include "foundation/PxAlloca.h"
#include "foundation/PxTime.h"
 
 
namespace physx {
    namespace profile {
 
        static const uint32_t LOCAL_BUFFER_SIZE = 512;
 
        template<typename TContextProvider,
            typename TMutex,
            typename TScopedLock,           
            typename TEventFilter>
        class EventBufferAtomic : public DataBuffer < TMutex, TScopedLock >
        {
        public:
            typedef DataBuffer<TMutex, TScopedLock> TBaseType;
            typedef TContextProvider    TContextProviderType;
            typedef TEventFilter        TEventFilterType;
            typedef typename TBaseType::TMutexType TMutexType;
            typedef typename TBaseType::TScopedLockType TScopedLockType;
            typedef typename TBaseType::TU8AllocatorType TU8AllocatorType;
            typedef typename TBaseType::TMemoryBufferType TMemoryBufferType;
            typedef typename TBaseType::TBufferClientArray TBufferClientArray;
 
        private:                        
            TContextProvider                    mContextProvider;
            TEventFilterType                    mEventFilter;
            volatile int32_t                    mReserved;
            volatile int32_t                    mWritten;
            
        public:
            EventBufferAtomic(PxAllocatorCallback* inFoundation
                , uint32_t inBufferFullAmount
                , const TContextProvider& inProvider
                , TMutexType* inBufferMutex
                , const TEventFilterType& inEventFilter)
                : TBaseType(inFoundation, inBufferFullAmount, inBufferMutex, "struct physx::profile::ProfileEvent")             
                , mContextProvider(inProvider)
                , mEventFilter(inEventFilter)
                , mReserved(0)
                , mWritten(0)        
            {               
            }
 
            TContextProvider& getContextProvider() { return mContextProvider; }
 
            PX_FORCE_INLINE void startEvent(uint16_t inId, uint32_t threadId, uint64_t contextId, uint8_t cpuId, uint8_t threadPriority, uint64_t inTimestamp)
            {
                if (mEventFilter.isEventEnabled(inId))
                {
                    StartEvent theEvent;
                    theEvent.init(threadId, contextId, cpuId, threadPriority, inTimestamp);
                    doAddProfileEvent(inId, theEvent);
                }
            }
 
            PX_FORCE_INLINE void startEvent(uint16_t inId, uint64_t contextId)
            {
                PxProfileEventExecutionContext ctx(mContextProvider.getExecutionContext());
                startEvent(inId, ctx.mThreadId, contextId, ctx.mCpuId, static_cast<uint8_t>(ctx.mThreadPriority), PxTime::getCurrentCounterValue());
            }
 
            PX_FORCE_INLINE void startEvent(uint16_t inId, uint64_t contextId, uint32_t threadId)
            {
                startEvent(inId, threadId, contextId, 0, 0, PxTime::getCurrentCounterValue());
            }
 
            PX_FORCE_INLINE void stopEvent(uint16_t inId, uint32_t threadId, uint64_t contextId, uint8_t cpuId, uint8_t threadPriority, uint64_t inTimestamp)
            {
                if (mEventFilter.isEventEnabled(inId))
                {
                    StopEvent theEvent;
                    theEvent.init(threadId, contextId, cpuId, threadPriority, inTimestamp);
                    doAddProfileEvent(inId, theEvent);
                }
            }
 
            PX_FORCE_INLINE void stopEvent(uint16_t inId, uint64_t contextId)
            {
                PxProfileEventExecutionContext ctx(mContextProvider.getExecutionContext());
                stopEvent(inId, ctx.mThreadId, contextId, ctx.mCpuId, static_cast<uint8_t>(ctx.mThreadPriority), PxTime::getCurrentCounterValue());
            }
 
            PX_FORCE_INLINE void stopEvent(uint16_t inId, uint64_t contextId, uint32_t threadId)
            {
                stopEvent(inId, threadId, contextId, 0, 0, PxTime::getCurrentCounterValue());
            }
 
            inline void eventValue(uint16_t inId, uint64_t contextId, int64_t inValue)
            {
                eventValue(inId, mContextProvider.getThreadId(), contextId, inValue);
            }
 
            inline void eventValue(uint16_t inId, uint32_t threadId, uint64_t contextId, int64_t inValue)
            {
                EventValue theEvent;
                theEvent.init(inValue, contextId, threadId);
                EventHeader theHeader(static_cast<uint8_t>(getEventType<EventValue>()), inId);
                //set the header relative timestamp;
                EventValue& theType(theEvent);
                theType.setupHeader(theHeader);
 
                int32_t sizeToWrite = int32_t(sizeof(theHeader) + theType.getEventSize(theHeader));
                int32_t reserved = PxAtomicAdd(&mReserved, sizeToWrite);
                sendEvent(theHeader, theType, reserved, sizeToWrite);
            }
 
            void flushProfileEvents(int32_t reserved = -1)
            {
                TScopedLockType lock(TBaseType::mBufferMutex);
 
                // set the buffer full to lock additional writes
                int32_t reservedOld = PxAtomicExchange(&mReserved, int32_t(TBaseType::mBufferFullAmount + 1));
                if (reserved == -1)
                    reserved = reservedOld;
 
                // spin till we have written all the data               
                while (reserved > mWritten)
                {
                }
 
                // check if we have written all data
                PX_ASSERT(reserved == mWritten);
 
                // set the correct size of the serialization data buffer
                TBaseType::mSerializer.mArray->setEnd(TBaseType::mSerializer.mArray->begin() + mWritten);
 
                // flush events
                TBaseType::flushEvents();
 
                // write master timestamp and set reserved/written to start writing to buffer again
                mWritten = 0;
                mReserved = 0;
            }
 
            void release()
            {
                PX_PROFILE_DELETE(TBaseType::mWrapper.mUserFoundation, this);
            }
        protected:
            //Clears the cache meaning event compression
            //starts over again.
            //only called when the buffer mutex is held
            void clearCachedData()
            {                               
            }
 
            template<typename TProfileEventType>
            PX_FORCE_INLINE void doAddProfileEvent(uint16_t eventId, const TProfileEventType& inType)
            {               
                doAddEvent(static_cast<uint8_t>(getEventType<TProfileEventType>()), eventId, inType);
            }
 
            template<typename TDataType>
            PX_FORCE_INLINE void doAddEvent(uint8_t inEventType, uint16_t eventId, const TDataType& inType)
            {
                EventHeader theHeader(inEventType, eventId);
                TDataType& theType(const_cast<TDataType&>(inType));             
                theType.setupHeader(theHeader, 0);
 
                const int32_t sizeToWrite = int32_t(sizeof(theHeader) + theType.getEventSize(theHeader));
 
                int32_t reserved = PxAtomicAdd(&mReserved, sizeToWrite);
                sendEvent(theHeader, theType, reserved, sizeToWrite);               
            }
 
            template<typename TDataType>
            PX_FORCE_INLINE void sendEvent(EventHeader& inHeader, TDataType& inType, int32_t reserved, int32_t sizeToWrite)
            {
                // if we don't fit to the buffer, we wait till it is flushed
                if (reserved - sizeToWrite >= int32_t(TBaseType::mBufferFullAmount))
                {
                    while (reserved - sizeToWrite >= int32_t(TBaseType::mBufferFullAmount))
                    {
                        // I32 overflow 
                        if (mReserved < int32_t(TBaseType::mBufferFullAmount))
                        {                           
                            reserved = PxAtomicAdd(&mReserved, sizeToWrite);
                        }
                    }
                }
 
                int32_t writeIndex = reserved - sizeToWrite;
                uint32_t writtenSize = 0;
 
                PX_ASSERT(writeIndex >= 0);
                
                PX_ALLOCA(tempBuffer, uint8_t, sizeToWrite);
                TempMemoryBuffer memoryBuffer(tempBuffer, sizeToWrite);
                EventSerializer<TempMemoryBuffer> eventSerializer(&memoryBuffer);
 
                writtenSize = inHeader.streamify(eventSerializer);
                writtenSize += inType.streamify(eventSerializer, inHeader);
 
                TBaseType::mSerializer.mArray->reserve(writeIndex + writtenSize);
                TBaseType::mSerializer.mArray->write(&tempBuffer[0], writtenSize, writeIndex);
                
                PX_ASSERT(writtenSize == uint32_t(sizeToWrite));                    
                PxAtomicAdd(&mWritten, sizeToWrite);
 
                if (reserved >= int32_t(TBaseType::mBufferFullAmount))
                {   
                    TScopedLockType lock(TBaseType::mBufferMutex);
                    // we flush the buffer if its full and we did not flushed him in the meantime
                    if(mReserved >= reserved)
                        flushProfileEvents(reserved);
                }
            }
 
        };
    }
}
#endif