PxProfileEventBuffer.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_H
#define PX_PROFILE_EVENT_BUFFER_H
 
#include "PxProfileEvents.h"
#include "PxProfileEventSerialization.h"
#include "PxProfileDataBuffer.h"
#include "PxProfileContextProvider.h"
 
#include "foundation/PxTime.h"
 
namespace physx { namespace profile {
 
    template<typename TContextProvider, 
            typename TMutex, 
            typename TScopedLock,
            typename TEventFilter>
    class EventBuffer  : 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:
        EventContextInformation             mEventContextInformation;
        uint64_t                                mLastTimestamp;
        TContextProvider                    mContextProvider;
        TEventFilterType                    mEventFilter;
 
    public:
        EventBuffer(PxAllocatorCallback* inFoundation
                    , uint32_t inBufferFullAmount
                    , const TContextProvider& inProvider
                    , TMutexType* inBufferMutex
                    , const TEventFilterType& inEventFilter )
                    : TBaseType( inFoundation, inBufferFullAmount, inBufferMutex, "struct physx::profile::ProfileEvent" )
            , mLastTimestamp( 0 )
            , mContextProvider( inProvider )
            , mEventFilter( inEventFilter )
        {
            memset(&mEventContextInformation,0,sizeof(EventContextInformation));
        }
 
        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)
        {           
            TScopedLockType lock(TBaseType::mBufferMutex);
            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)
        {           
            TScopedLockType lock(TBaseType::mBufferMutex);
            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 )
        {
            TScopedLockType lock( TBaseType::mBufferMutex );
            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 );
            sendEvent( theHeader, theType );
        }
 
        void flushProfileEvents()
        {               
            TBaseType::flushEvents();
        }
 
        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()
        {
            mEventContextInformation.setToDefault();
            mLastTimestamp = 0;
        }
 
        template<typename TProfileEventType>
        PX_FORCE_INLINE void doAddProfileEvent(uint16_t eventId, const TProfileEventType& inType)
        {
            TScopedLockType lock(TBaseType::mBufferMutex);
            if (mEventContextInformation == inType.mContextInformation)
                doAddEvent(static_cast<uint8_t>(inType.getRelativeEventType()), eventId, inType.getRelativeEvent());
            else
            {
                mEventContextInformation = inType.mContextInformation;
                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 );
            //set the header relative timestamp;
            TDataType& theType( const_cast<TDataType&>( inType ) );
            uint64_t currentTs =  inType.getTimestamp();
            theType.setupHeader(theHeader, mLastTimestamp);
            mLastTimestamp = currentTs;
            sendEvent( theHeader, theType );
        }
 
        template<typename TDataType>
        PX_FORCE_INLINE void sendEvent( EventHeader& inHeader, TDataType& inType )
        {           
            uint32_t sizeToWrite = sizeof(inHeader) + inType.getEventSize(inHeader);
            PX_UNUSED(sizeToWrite);
 
            uint32_t writtenSize = inHeader.streamify( TBaseType::mSerializer );
            writtenSize += inType.streamify(TBaseType::mSerializer, inHeader);
 
            PX_ASSERT(writtenSize == sizeToWrite);
 
            if ( TBaseType::mDataArray.size() >= TBaseType::mBufferFullAmount )
                flushProfileEvents();
 
        }
 
    };
}}
#endif