183 lines
6.9 KiB
C++
183 lines
6.9 KiB
C++
// 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-2025 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_DEFAULT_PROFILER_H
|
|
#define PX_DEFAULT_PROFILER_H
|
|
|
|
#include "foundation/PxProfiler.h"
|
|
|
|
|
|
#if !PX_DOXYGEN
|
|
namespace physx
|
|
{
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
\brief The major and minor version of the current Default Profiler file format.
|
|
*/
|
|
#define PX_PROFILER_VERSION_MAJOR 0
|
|
#define PX_PROFILER_VERSION_MINOR 1
|
|
|
|
|
|
/**
|
|
\brief The various profiler data types that describe what data follows in the stream.
|
|
*/
|
|
struct PxDefaultProfilerDataType
|
|
{
|
|
enum Enum : PxU64
|
|
{
|
|
eTHREAD_BLOCK = 0, //!< A thread ID follows a thread tag. All data following a thread block are from this thread.
|
|
|
|
/*!
|
|
A key, size and character string follows a name registration tag. Event names are only written once per thread.
|
|
|
|
Ensure names are global or static so the character pointer is static and does not change.
|
|
Pointers values are used as keys to look up names. It is especially important for cross thread
|
|
zones so the zone names can be found across threads.
|
|
*/
|
|
eNAME_REGISTRATION,
|
|
|
|
eZONE_START, //!< A PxProfilerCallback::zoneStart callback. A time tag, context and name key follows a zone start tag.
|
|
eZONE_END, //!< A PxProfilerCallback::zoneEnd callback. A time tag, context and name key follows a zone end tag.
|
|
eZONE_START_CROSS_THREAD, //!< A PxProfilerCallback::zoneStart callback with detached set to true indicating a cross thread zone.
|
|
eZONE_END_CROSS_THREAD, //!< A PxProfilerCallback::zoneEnd callback with detached set to true indicating a cross thread zone.
|
|
eVALUE_INT, //!< A PxProfilerCallback::recordData callback with an integer value.
|
|
eVALUE_FLOAT, //!< A PxProfilerCallback::recordData callback with a floating point value.
|
|
eFRAME //!< A PxProfilerCallback::recordFrame callback. Frames are simple markers that are identifable in the profiling tools.
|
|
};
|
|
};
|
|
|
|
struct PxDefaultProfilerVersionInfo
|
|
{
|
|
PxU32 major; //!< The major version of the current file format.
|
|
PxU32 minor; //!< The minor version of the current file format.
|
|
};
|
|
|
|
struct PxDefaultProfilerHeader
|
|
{
|
|
PxDefaultProfilerDataType::Enum type; //!< The type of event or data that follows this header. See PxDefaultProfilerDataType.
|
|
};
|
|
|
|
struct PxDefaultProfilerThread
|
|
{
|
|
PxU64 threadId; //!< The thread identifier for all of the data that follows.
|
|
};
|
|
|
|
struct PxDefaultProfilerName
|
|
{
|
|
PxU64 key; //!< The key to the profiler name. Used to store the name in a map for quick look ups. It is also the pointer to the character string.
|
|
PxU32 size; //!< Byte size of the null terminated string that follows the PxDefaultProfilerName entry in the stream. Note that due to padding the size can be larger than the string size itself.
|
|
|
|
/// @cond
|
|
PxU32 padding;
|
|
/// @endcond
|
|
};
|
|
|
|
struct PxDefaultProfilerEvent
|
|
{
|
|
PxU64 time; //!< The time the event was received, in tens of nano seconds.
|
|
PxU64 contextId; //!< The context sent with the event. User controlled data to associate with the event.
|
|
PxU64 nameKey; //!< The key to look up the name at a later time so strings are not stored with every event.
|
|
};
|
|
|
|
struct PxDefaultProfilerValueEvent : public PxDefaultProfilerEvent
|
|
{
|
|
union
|
|
{
|
|
PxI32 intValue; //!< Either integer or float data that is to be graphed.
|
|
PxF32 floatValue; //!< Either integer or float data that is to be graphed.
|
|
};
|
|
|
|
/// @cond
|
|
PxU32 padding;
|
|
/// @endcond
|
|
};
|
|
|
|
class PxOutputStream;
|
|
|
|
/**
|
|
|
|
\brief Default implementation of PxProfilerCallback to record profiling events.
|
|
|
|
The profiling events are stored in a memory buffer which gets flushed to a user provided stream when the
|
|
buffer is full, or when flush or release is called.
|
|
|
|
\see PxDefaultProfilerCreate()
|
|
*/
|
|
class PxDefaultProfiler : public PxProfilerCallback
|
|
{
|
|
public:
|
|
|
|
/**
|
|
\brief Deletes the profiler.
|
|
|
|
Do not keep a reference to the deleted instance.
|
|
|
|
\see PxDefaultProfilerCreate()
|
|
*/
|
|
virtual void release() = 0;
|
|
|
|
/**
|
|
\brief Write all of the collected profiling data to the output stream.
|
|
|
|
This call is not thread safe, so it should only be called during a sync point or when all threads have yielded.
|
|
Calling this regularly, at appropriate times will prevent the buffers from filling up and forcing a write
|
|
to the stream at unexpected times because writes will affect performance.
|
|
*/
|
|
virtual void flush() = 0;
|
|
};
|
|
|
|
/**
|
|
\brief Create default profiler.
|
|
|
|
\note The PhysXExtensions SDK needs to be initialized first before using this method (see #PxInitExtensions)
|
|
|
|
\param[in] outputStream A PxOutputStream used to write all of the recorded
|
|
profiler events received. Writing to the stream occurs when the
|
|
buffer is full or when flush or release is called.
|
|
\param[in] numberOfBuffers The number of buffers to pre-allocate. One buffer is
|
|
used per thread, so a number larger than the anticipated number of threads is best.
|
|
If more buffers are needed, additional memory is allocated as needed, but this may
|
|
affect performance.
|
|
\param[in] bufferSize The number of bytes to allocate per thread for recording all
|
|
profiler events received on that thread. Once the buffer is full, the profiling data
|
|
is written to the stream, which will cause a slight delay. Use a larger buffer size
|
|
to prevent this, if memory permits. The minimum buffer size is 32,767 bytes, which is also
|
|
the default setting.
|
|
*/
|
|
PxDefaultProfiler* PxDefaultProfilerCreate(PxOutputStream& outputStream, PxU32 numberOfBuffers = 16, PxU32 bufferSize = 32767);
|
|
|
|
#if !PX_DOXYGEN
|
|
} // namespace physx
|
|
#endif
|
|
|
|
#endif
|