Namespaces
namespace	moodycamel
namespace	detail

Classes
struct	rpmalloc_global_statistics_t
struct	rpmalloc_thread_statistics_t
struct	rpmalloc_config_t
class	FastVector
class	LockableCtx
class	Lockable
class	SharedLockableCtx
class	SharedLockable
struct	GpuCtxWrapper
struct	SourceLocationData
class	Profiler
class	RingBuffer
class	ScopedZone
class	ThreadExitHandler
class	Thread
struct	LZ4_stream_t_internal
struct	LZ4_streamDecode_t_internal
union	LZ4_stream_u
union	LZ4_streamDecode_u
struct	LZ4HC_CCtx_internal
union	LZ4_streamHC_u
struct	Color
struct	ServerQueryPacket
struct	WelcomeMessage
struct	OnDemandPayloadMessage
struct	BroadcastMessage
struct	QueueThreadContext
struct	QueueZoneBeginLean
struct	QueueZoneBegin
struct	QueueZoneEnd
struct	QueueZoneValidation
struct	QueueZoneColor
struct	QueueZoneValue
struct	QueueStringTransfer
struct	QueueFrameMark
struct	QueueFrameImage
struct	QueueFrameImageFat
struct	QueueSourceLocation
struct	QueueZoneTextFat
struct	QueueLockAnnounce
struct	QueueLockTerminate
struct	QueueLockWait
struct	QueueLockObtain
struct	QueueLockRelease
struct	QueueLockMark
struct	QueueLockName
struct	QueueLockNameFat
struct	QueuePlotData
struct	QueueMessage
struct	QueueMessageColor
struct	QueueMessageLiteral
struct	QueueMessageColorLiteral
struct	QueueMessageFat
struct	QueueMessageColorFat
struct	QueueGpuNewContext
struct	QueueGpuZoneBeginLean
struct	QueueGpuZoneBegin
struct	QueueGpuZoneEnd
struct	QueueGpuTime
struct	QueueGpuCalibration
struct	QueueGpuContextName
struct	QueueGpuContextNameFat
struct	QueueMemNamePayload
struct	QueueMemAlloc
struct	QueueMemFree
struct	QueueCallstackFat
struct	QueueCallstackAllocFat
struct	QueueCallstackSample
struct	QueueCallstackSampleFat
struct	QueueCallstackFrameSize
struct	QueueCallstackFrame
struct	QueueSymbolInformation
struct	QueueCodeInformation
struct	QueueCrashReport
struct	QueueSysTime
struct	QueueContextSwitch
struct	QueueThreadWakeup
struct	QueueTidToPid
struct	QueuePlotConfig
struct	QueueParamSetup
struct	QueueCpuTopology
struct	QueueHeader
struct	QueueItem
class	Socket
class	ListenSocket
class	UdpBroadcast
class	IpAddress
class	UdpListen
class	D3D12ZoneScope
class	OpenCLCtxScope
class	GpuCtxScope
class	VkCtxScope

Typedefs
typedef struct tracy::rpmalloc_global_statistics_t	rpmalloc_global_statistics_t
typedef struct tracy::rpmalloc_thread_statistics_t	rpmalloc_thread_statistics_t
typedef struct tracy::rpmalloc_config_t	rpmalloc_config_t
typedef void(*	ParameterCallback )(uint32_t idx, int32_t val)
typedef union LZ4_stream_u	LZ4_stream_t
typedef union LZ4_streamDecode_u	LZ4_streamDecode_t
typedef signed char	LZ4_i8
typedef unsigned char	LZ4_byte
typedef unsigned short	LZ4_u16
typedef unsigned int	LZ4_u32
typedef struct LZ4_stream_t_internal	LZ4_stream_t_internal
typedef union LZ4_streamHC_u	LZ4_streamHC_t
typedef struct LZ4HC_CCtx_internal	LZ4HC_CCtx_internal

Enumerations
enum	{ TargetFrameSize = 256 * 1024 }
enum	{ LZ4Size = Lz4CompressBound( TargetFrameSize ) }
enum	{ HandshakeShibbolethSize = 8 }
enum	HandshakeStatus { HandshakePending, HandshakeWelcome, HandshakeProtocolMismatch, HandshakeNotAvailable, HandshakeDropped }
enum	{ WelcomeMessageProgramNameSize = 64 }
enum	{ WelcomeMessageHostInfoSize = 1024 }
enum	ServerQuery { ServerQueryTerminate, ServerQueryString, ServerQueryThreadString, ServerQuerySourceLocation, ServerQueryPlotName, ServerQueryCallstackFrame, ServerQueryFrameName, ServerQueryDisconnect, ServerQueryExternalName, ServerQueryParameter, ServerQuerySymbol, ServerQuerySymbolCode, ServerQueryCodeLocation, ServerQuerySourceCode, ServerQueryDataTransfer, ServerQueryDataTransferPart }
enum	{ ServerQueryPacketSize = sizeof( ServerQueryPacket ) }
enum	CpuArchitecture { CpuArchUnknown, CpuArchX86, CpuArchX64, CpuArchArm32, CpuArchArm64 }
enum	{ WelcomeMessageSize = sizeof( WelcomeMessage ) }
enum	{ OnDemandPayloadMessageSize = sizeof( OnDemandPayloadMessage ) }
enum	{ BroadcastMessageSize = sizeof( BroadcastMessage ) }
enum	QueueType
enum	LockType
enum	PlotDataType
enum	GpuContextType
enum	GpuContextFlags { GpuContextCalibration = 1 << 0 }
enum	PlotFormatType
enum	{ QueueItemSize = sizeof( QueueItem ) }

Functions
TRACY_API int	rpmalloc_initialize (void)
	Initialize allocator with default configuration.
RPMALLOC_EXPORT int	rpmalloc_initialize_config (const rpmalloc_config_t *config)
	Initialize allocator with given configuration.
RPMALLOC_EXPORT const rpmalloc_config_t *	rpmalloc_config (void)
	Get allocator configuration.
TRACY_API void	rpmalloc_finalize (void)
	Finalize allocator.
TRACY_API void	rpmalloc_thread_initialize (void)
	Initialize allocator for calling thread.
TRACY_API void	rpmalloc_thread_finalize (void)
	Finalize allocator for calling thread.
RPMALLOC_EXPORT void	rpmalloc_thread_collect (void)
	Perform deferred deallocations pending for the calling thread heap.
RPMALLOC_EXPORT int	rpmalloc_is_thread_initialized (void)
	Query if allocator is initialized for calling thread.
RPMALLOC_EXPORT void	rpmalloc_thread_statistics (rpmalloc_thread_statistics_t *stats)
	Get per-thread statistics.
RPMALLOC_EXPORT void	rpmalloc_global_statistics (rpmalloc_global_statistics_t *stats)
	Get global statistics.
RPMALLOC_EXPORT void	rpmalloc_dump_statistics (void *file)
	Dump all statistics in human readable format to file (should be a FILE*)
TRACY_API RPMALLOC_ALLOCATOR void *	rpmalloc (size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(1)
	Allocate a memory block of at least the given size.
TRACY_API void	rpfree (void *ptr)
	Free the given memory block.
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void *	rpcalloc (size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(1
	Allocate a memory block of at least the given size and zero initialize it.
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void TRACY_API RPMALLOC_ALLOCATOR void *	rprealloc (void *ptr, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2)
	Reallocate the given block to at least the given size.
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void *	rpaligned_realloc (void *ptr, size_t alignment, size_t size, size_t oldsize, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3)
	Reallocate the given block to at least the given size and alignment,.
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void *	rpaligned_alloc (size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2)
	Allocate a memory block of at least the given size and alignment.
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void *	rpmemalign (size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2)
	Allocate a memory block of at least the given size and alignment.
RPMALLOC_EXPORT int	rpposix_memalign (void **memptr, size_t alignment, size_t size)
	Allocate a memory block of at least the given size and alignment.
RPMALLOC_EXPORT size_t	rpmalloc_usable_size (void *ptr)
	Query the usable size of the given memory block (from given pointer to the end of block)
void	CompressImageDxt1 (const char src, char dst, int w, int h)
TRACY_API moodycamel::ConcurrentQueue < QueueItem > ::ExplicitProducer *	GetToken ()
TRACY_API Profiler &	GetProfiler ()
TRACY_API std::atomic< uint32_t > &	GetLockCounter ()
TRACY_API std::atomic< uint8_t > &	GetGpuCtxCounter ()
TRACY_API GpuCtxWrapper &	GetGpuCtx ()
TRACY_API uint64_t	GetThreadHandle ()
TRACY_API void	InitRPMallocThread ()
TRACY_API bool	ProfilerAvailable ()
TRACY_API bool	SystemTraceAvailable ()
TRACY_API int64_t	GetFrequencyQpc ()
LZ4LIB_API int	LZ4_versionNumber (void)
	library version number; useful to check dll version
LZ4LIB_API const char *	LZ4_versionString (void)
	library version string; useful to check dll version
LZ4LIB_API int	LZ4_compress_default (const char src, char dst, int srcSize, int dstCapacity)
LZ4LIB_API int	LZ4_decompress_safe (const char src, char dst, int compressedSize, int dstCapacity)
LZ4LIB_API int	LZ4_compressBound (int inputSize)
LZ4LIB_API int	LZ4_compress_fast (const char src, char dst, int srcSize, int dstCapacity, int acceleration)
LZ4LIB_API int	LZ4_sizeofState (void)
LZ4LIB_API int	LZ4_compress_fast_extState (void state, const char src, char *dst, int srcSize, int dstCapacity, int acceleration)
LZ4LIB_API int	LZ4_compress_destSize (const char src, char dst, int *srcSizePtr, int targetDstSize)
LZ4LIB_API int	LZ4_decompress_safe_partial (const char src, char dst, int srcSize, int targetOutputSize, int dstCapacity)
LZ4LIB_API LZ4_stream_t *	LZ4_createStream (void)
LZ4LIB_API int	LZ4_freeStream (LZ4_stream_t *streamPtr)
LZ4LIB_API void	LZ4_resetStream_fast (LZ4_stream_t *streamPtr)
LZ4LIB_API int	LZ4_loadDict (LZ4_stream_t streamPtr, const char dictionary, int dictSize)
LZ4LIB_API int	LZ4_compress_fast_continue (LZ4_stream_t streamPtr, const char src, char *dst, int srcSize, int dstCapacity, int acceleration)
LZ4LIB_API int	LZ4_saveDict (LZ4_stream_t streamPtr, char safeBuffer, int maxDictSize)
LZ4LIB_API LZ4_streamDecode_t *	LZ4_createStreamDecode (void)
LZ4LIB_API int	LZ4_freeStreamDecode (LZ4_streamDecode_t *LZ4_stream)
LZ4LIB_API int	LZ4_setStreamDecode (LZ4_streamDecode_t LZ4_streamDecode, const char dictionary, int dictSize)
LZ4LIB_API int	LZ4_decoderRingBufferSize (int maxBlockSize)
LZ4LIB_API int	LZ4_decompress_safe_continue (LZ4_streamDecode_t LZ4_streamDecode, const char src, char *dst, int srcSize, int dstCapacity)
LZ4LIB_API int	LZ4_decompress_safe_usingDict (const char src, char dst, int srcSize, int dstCapcity, const char *dictStart, int dictSize)
LZ4LIB_API LZ4_stream_t *	LZ4_initStream (void *buffer, size_t size)
	LZ4_DEPRECATED ("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress(const char *src
	LZ4_DEPRECATED ("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState(void *state
	LZ4_DEPRECATED ("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue(LZ4_stream_t *LZ4_streamPtr
	LZ4_DEPRECATED ("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress(const char *source
	LZ4_DEPRECATED ("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize(const char *source
	LZ4_DEPRECATED ("Use LZ4_createStream() instead") LZ4LIB_API void LZ4_create(char inputBuffer)
	LZ4_DEPRECATED ("Use LZ4_resetStream() instead") LZ4LIB_API int LZ4_resetStreamState(void *state
	LZ4_DEPRECATED ("Use LZ4_saveDict() instead") LZ4LIB_API char LZ4_slideInputBuffer(void state)
	LZ4_DEPRECATED ("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k(const char *src
	LZ4_DEPRECATED ("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k(const char *src
LZ4LIB_API int	LZ4_decompress_fast (const char src, char dst, int originalSize)
LZ4LIB_API int	LZ4_decompress_fast_continue (LZ4_streamDecode_t LZ4_streamDecode, const char src, char *dst, int originalSize)
LZ4LIB_API int	LZ4_decompress_fast_usingDict (const char src, char dst, int originalSize, const char *dictStart, int dictSize)
LZ4LIB_API void	LZ4_resetStream (LZ4_stream_t *streamPtr)
LZ4LIB_API int	LZ4_compress_HC (const char src, char dst, int srcSize, int dstCapacity, int compressionLevel)
LZ4LIB_API int	LZ4_sizeofStateHC (void)
LZ4LIB_API int	LZ4_compress_HC_extStateHC (void stateHC, const char src, char *dst, int srcSize, int maxDstSize, int compressionLevel)
LZ4LIB_API int	LZ4_compress_HC_destSize (void stateHC, const char src, char dst, int srcSizePtr, int targetDstSize, int compressionLevel)
LZ4LIB_API LZ4_streamHC_t *	LZ4_createStreamHC (void)
LZ4LIB_API int	LZ4_freeStreamHC (LZ4_streamHC_t *streamHCPtr)
LZ4LIB_API void	LZ4_resetStreamHC_fast (LZ4_streamHC_t *streamHCPtr, int compressionLevel)
LZ4LIB_API int	LZ4_loadDictHC (LZ4_streamHC_t streamHCPtr, const char dictionary, int dictSize)
LZ4LIB_API int	LZ4_compress_HC_continue (LZ4_streamHC_t streamHCPtr, const char src, char *dst, int srcSize, int maxDstSize)
LZ4LIB_API int	LZ4_compress_HC_continue_destSize (LZ4_streamHC_t LZ4_streamHCPtr, const char src, char dst, int srcSizePtr, int targetDstSize)
LZ4LIB_API int	LZ4_saveDictHC (LZ4_streamHC_t streamHCPtr, char safeBuffer, int maxDictSize)
LZ4LIB_API LZ4_streamHC_t *	LZ4_initStreamHC (void *buffer, size_t size)
	LZ4_DEPRECATED ("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC(const char *source
	LZ4_DEPRECATED ("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC_withStateHC(void *state
	LZ4_DEPRECATED ("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC_continue(LZ4_streamHC_t *LZ4_streamHCPtr
	LZ4_DEPRECATED ("use LZ4_createStreamHC() instead") LZ4LIB_API void LZ4_createHC(const char inputBuffer)
	LZ4_DEPRECATED ("use LZ4_saveDictHC() instead") LZ4LIB_API char LZ4_slideInputBufferHC(void LZ4HC_Data)
	LZ4_DEPRECATED ("use LZ4_freeStreamHC() instead") LZ4LIB_API int LZ4_freeHC(void *LZ4HC_Data)
	LZ4_DEPRECATED ("use LZ4_initStreamHC() instead") LZ4LIB_API int LZ4_resetStreamStateHC(void *state
LZ4LIB_API void	LZ4_resetStreamHC (LZ4_streamHC_t *streamHCPtr, int compressionLevel)
template<typename T >
tracy_force_inline T	MemRead (const void *ptr)
template<typename T >
tracy_force_inline void	MemWrite (void *ptr, T val)
static void *	tracy_malloc (size_t size)
static void	tracy_free (void *ptr)
static void *	tracy_realloc (void *ptr, size_t size)
constexpr unsigned	Lz4CompressBound (unsigned isize)
	static_assert (LZ4Size<=std::numeric_limits< lz4sz_t >::max(),"LZ4Size greater than lz4sz_t")
	static_assert (TargetFrameSize 2 >=64 1024,"Not enough space for LZ4 stream buffer")
	static_assert (QueueItemSize==32,"Queue item size not 32 bytes")
	static_assert (sizeof(QueueDataSize)/sizeof(size_t)==(uint8_t) QueueType::NUM_TYPES,"QueueDataSize mismatch")
	static_assert (sizeof(void *)<=sizeof(uint64_t),"Pointer size > 8 bytes")
	static_assert (sizeof(void *)==sizeof(uintptr_t),"Pointer size != uintptr_t")
TRACY_API void	SetThreadName (const char *name)
TRACY_API const char *	GetThreadName (uint64_t id)
static void	LuaRegister (lua_State *L)
static char *	FindEnd (char *ptr)
static void	LuaRemove (char *script)

Variables
static const unsigned int	tracy_systrace_armv7_size = 1149
static const unsigned int	tracy_systrace_armv7_data [1152/4]
static const unsigned int	tracy_systrace_aarch64_size = 1650
static const unsigned int	tracy_systrace_aarch64_data [1652/4]
char *	dest
char int	srcSize
char int int	maxOutputSize
const char *	source
const char char int	inputSize
char int	outputSize
char int	isize
char *	inputBuffer
char *	dst
char int	compressedSize
char int int	maxDstSize
char int	originalSize
char int int	compressionLevel
static const char	HandshakeShibboleth [HandshakeShibbolethSize] = { 'T', 'r', 'a', 'c', 'y', 'P', 'r', 'f' }
static constexpr size_t	QueueDataSize []

Typedef Documentation

typedef struct tracy::rpmalloc_global_statistics_t tracy::rpmalloc_global_statistics_t

typedef struct tracy::rpmalloc_thread_statistics_t tracy::rpmalloc_thread_statistics_t

typedef struct tracy::rpmalloc_config_t tracy::rpmalloc_config_t

typedef void(* tracy::ParameterCallback)(uint32_t idx, int32_t val)

typedef union LZ4_stream_u tracy::LZ4_stream_t

typedef union LZ4_streamDecode_u tracy::LZ4_streamDecode_t

typedef signed char tracy::LZ4_i8

typedef unsigned char tracy::LZ4_byte

typedef unsigned short tracy::LZ4_u16

typedef unsigned int tracy::LZ4_u32

typedef struct LZ4_stream_t_internal tracy::LZ4_stream_t_internal

typedef union LZ4_streamHC_u tracy::LZ4_streamHC_t

typedef struct LZ4HC_CCtx_internal tracy::LZ4HC_CCtx_internal

Enumeration Type Documentation

anonymous enum

Enumerator:

TargetFrameSize

anonymous enum

Enumerator:

LZ4Size

anonymous enum

Enumerator:

HandshakeShibbolethSize

enum tracy::HandshakeStatus

Enumerator:

HandshakePending
HandshakeWelcome
HandshakeProtocolMismatch
HandshakeNotAvailable
HandshakeDropped

anonymous enum

Enumerator:

WelcomeMessageProgramNameSize

anonymous enum

Enumerator:

WelcomeMessageHostInfoSize

enum tracy::ServerQuery

Enumerator:

ServerQueryTerminate
ServerQueryString
ServerQueryThreadString
ServerQuerySourceLocation
ServerQueryPlotName
ServerQueryCallstackFrame
ServerQueryFrameName
ServerQueryDisconnect
ServerQueryExternalName
ServerQueryParameter
ServerQuerySymbol
ServerQuerySymbolCode
ServerQueryCodeLocation
ServerQuerySourceCode
ServerQueryDataTransfer
ServerQueryDataTransferPart

anonymous enum

Enumerator:

ServerQueryPacketSize

enum tracy::CpuArchitecture

Enumerator:

CpuArchUnknown
CpuArchX86
CpuArchX64
CpuArchArm32
CpuArchArm64

anonymous enum

Enumerator:

WelcomeMessageSize

anonymous enum

Enumerator:

OnDemandPayloadMessageSize

anonymous enum

Enumerator:

BroadcastMessageSize

enum tracy::QueueType

enum tracy::LockType

enum tracy::PlotDataType

enum tracy::GpuContextType

enum tracy::GpuContextFlags

Enumerator:

GpuContextCalibration

enum tracy::PlotFormatType

anonymous enum

Enumerator:

QueueItemSize

Function Documentation

TRACY_API int tracy::rpmalloc_initialize ( void )

Initialize allocator with default configuration.

RPMALLOC_EXPORT int tracy::rpmalloc_initialize_config ( const rpmalloc_config_t * config )

Initialize allocator with given configuration.

RPMALLOC_EXPORT const rpmalloc_config_t* tracy::rpmalloc_config ( void )

Get allocator configuration.

TRACY_API void tracy::rpmalloc_finalize ( void )

Finalize allocator.

TRACY_API void tracy::rpmalloc_thread_initialize ( void )

Initialize allocator for calling thread.

TRACY_API void tracy::rpmalloc_thread_finalize ( void )

Finalize allocator for calling thread.

Referenced by tracy::ThreadExitHandler::~ThreadExitHandler().

RPMALLOC_EXPORT void tracy::rpmalloc_thread_collect ( void )

Perform deferred deallocations pending for the calling thread heap.

RPMALLOC_EXPORT int tracy::rpmalloc_is_thread_initialized ( void )

Query if allocator is initialized for calling thread.

RPMALLOC_EXPORT void tracy::rpmalloc_thread_statistics ( rpmalloc_thread_statistics_t * stats )

Get per-thread statistics.

RPMALLOC_EXPORT void tracy::rpmalloc_global_statistics ( rpmalloc_global_statistics_t * stats )

Get global statistics.

RPMALLOC_EXPORT void tracy::rpmalloc_dump_statistics ( void * file )

Dump all statistics in human readable format to file (should be a FILE*)

TRACY_API RPMALLOC_ALLOCATOR void* tracy::rpmalloc ( size_t size )

Allocate a memory block of at least the given size.

Referenced by tracy_malloc().

TRACY_API void tracy::rpfree ( void * ptr )

Free the given memory block.

Referenced by tracy_free().

RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* tracy::rpcalloc	(	size_t	num,
		size_t	size
	)

Allocate a memory block of at least the given size and zero initialize it.

RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void TRACY_API RPMALLOC_ALLOCATOR void* tracy::rprealloc	(	void *	ptr,
		size_t	size
	)

Reallocate the given block to at least the given size.

Referenced by tracy_realloc().

RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* tracy::rpaligned_realloc	(	void *	ptr,
		size_t	alignment,
		size_t	size,
		size_t	oldsize,
		unsigned int	flags
	)

Reallocate the given block to at least the given size and alignment,.

RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* tracy::rpaligned_alloc	(	size_t	alignment,
		size_t	size
	)

Allocate a memory block of at least the given size and alignment.

RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* tracy::rpmemalign	(	size_t	alignment,
		size_t	size
	)

Allocate a memory block of at least the given size and alignment.

RPMALLOC_EXPORT int tracy::rpposix_memalign	(	void **	memptr,
		size_t	alignment,
		size_t	size
	)

Allocate a memory block of at least the given size and alignment.

RPMALLOC_EXPORT size_t tracy::rpmalloc_usable_size ( void * ptr )

Query the usable size of the given memory block (from given pointer to the end of block)

void tracy::CompressImageDxt1	(	const char *	src,
		char *	dst,
		int	w,
		int	h
	)

TRACY_API moodycamel::ConcurrentQueue<QueueItem>::ExplicitProducer* tracy::GetToken ( )

TRACY_API Profiler& tracy::GetProfiler ( )

TRACY_API std::atomic<uint32_t>& tracy::GetLockCounter ( )

TRACY_API std::atomic<uint8_t>& tracy::GetGpuCtxCounter ( )

TRACY_API GpuCtxWrapper& tracy::GetGpuCtx ( )

static uint64_t tracy::GetThreadHandle ( )

inline

References tracy::detail::GetThreadHandleImpl().

TRACY_API void tracy::InitRPMallocThread ( )

Referenced by tracy::Profiler::MemAllocCallstack(), tracy::Profiler::MemAllocCallstackNamed(), tracy::Profiler::MemFreeCallstack(), tracy::Profiler::MemFreeCallstackNamed(), tracy::Profiler::Message(), tracy::Profiler::MessageAppInfo(), and tracy::Profiler::MessageColor().

TRACY_API bool tracy::ProfilerAvailable ( )

Referenced by tracy::Profiler::MemAlloc(), tracy::Profiler::MemAllocCallstack(), tracy::Profiler::MemAllocCallstackNamed(), tracy::Profiler::MemAllocNamed(), tracy::Profiler::MemFree(), tracy::Profiler::MemFreeCallstack(), tracy::Profiler::MemFreeCallstackNamed(), and tracy::Profiler::MemFreeNamed().

TRACY_API bool tracy::SystemTraceAvailable ( )

TRACY_API int64_t tracy::GetFrequencyQpc ( )

LZ4LIB_API int tracy::LZ4_versionNumber ( void )

library version number; useful to check dll version

LZ4LIB_API const char* tracy::LZ4_versionString ( void )

library version string; useful to check dll version

LZ4LIB_API int tracy::LZ4_compress_default	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity
	)

LZ4_compress_default() : Compresses 'srcSize' bytes from buffer 'src' into already allocated 'dst' buffer of size 'dstCapacity'. Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize). It also runs faster, so it's a recommended setting. If the function cannot compress 'src' into a more limited 'dst' budget, compression stops immediately, and the function result is zero. In which case, 'dst' content is undefined (invalid). srcSize : max supported value is LZ4_MAX_INPUT_SIZE. dstCapacity : size of buffer 'dst' (which must be already allocated)

Returns: : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity) or 0 if compression fails Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).

LZ4LIB_API int tracy::LZ4_decompress_safe	(	const char *	src,
		char *	dst,
		int	compressedSize,
		int	dstCapacity
	)

LZ4_decompress_safe() : compressedSize : is the exact complete size of the compressed block. dstCapacity : is the size of destination buffer (which must be already allocated), presumed an upper bound of decompressed size.

Returns: : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity) If destination buffer is not large enough, decoding will stop and output an error code (negative value). If the source stream is detected malformed, the function will stop decoding and return a negative result. Note 1 : This function is protected against malicious data packets : it will never writes outside 'dst' buffer, nor read outside 'source' buffer, even if the compressed block is maliciously modified to order the decoder to do these actions. In such case, the decoder stops immediately, and considers the compressed block malformed. Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them. The implementation is free to send / store / derive this information in whichever way is most beneficial. If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead.

LZ4LIB_API int tracy::LZ4_compressBound ( int inputSize )

LZ4_compressBound() : Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible) This function is primarily useful for memory allocation purposes (destination buffer size). Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example). Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize) inputSize : max supported value is LZ4_MAX_INPUT_SIZE return : maximum output size in a "worst case" scenario or 0, if input size is incorrect (too large or negative)

LZ4LIB_API int tracy::LZ4_compress_fast	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity,
		int	acceleration
	)

LZ4_compress_fast() : Same as LZ4_compress_default(), but allows selection of "acceleration" factor. The larger the acceleration value, the faster the algorithm, but also the lesser the compression. It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed. An acceleration value of "1" is the same as regular LZ4_compress_default() Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c). Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c).

LZ4LIB_API int tracy::LZ4_sizeofState ( void )

LZ4_compress_fast_extState() : Same as LZ4_compress_fast(), using an externally allocated memory space for its state. Use LZ4_sizeofState() to know how much memory must be allocated, and allocate it on 8-bytes boundaries (using malloc() typically). Then, provide this buffer as void* state to compression function.

LZ4LIB_API int tracy::LZ4_compress_fast_extState	(	void *	state,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity,
		int	acceleration
	)

LZ4LIB_API int tracy::LZ4_compress_destSize	(	const char *	src,
		char *	dst,
		int *	srcSizePtr,
		int	targetDstSize
	)

LZ4_compress_destSize() : Reverse the logic : compresses as much data as possible from 'src' buffer into already allocated buffer 'dst', of size >= 'targetDestSize'. This function either compresses the entire 'src' content into 'dst' if it's large enough, or fill 'dst' buffer completely with as much data as possible from 'src'. note: acceleration parameter is fixed to "default".

*srcSizePtr : will be modified to indicate how many bytes where read from 'src' to fill 'dst'. New value is necessarily <= input value.

Returns: : Nb bytes written into 'dst' (necessarily <= targetDestSize) or 0 if compression fails.

Note : from v1.8.2 to v1.9.1, this function had a bug (fixed un v1.9.2+): the produced compressed content could, in specific circumstances, require to be decompressed into a destination buffer larger by at least 1 byte than the content to decompress. If an application uses LZ4_compress_destSize(), it's highly recommended to update liblz4 to v1.9.2 or better. If this can't be done or ensured, the receiving decompression function should provide a dstCapacity which is > decompressedSize, by at least 1 byte. See https://github.com/lz4/lz4/issues/859 for details

LZ4LIB_API int tracy::LZ4_decompress_safe_partial	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	targetOutputSize,
		int	dstCapacity
	)

LZ4_decompress_safe_partial() : Decompress an LZ4 compressed block, of size 'srcSize' at position 'src', into destination buffer 'dst' of size 'dstCapacity'. Up to 'targetOutputSize' bytes will be decoded. The function stops decoding on reaching this objective. This can be useful to boost performance whenever only the beginning of a block is required.

Returns: : the number of bytes decoded in dst (necessarily <= targetOutputSize) If source stream is detected malformed, function returns a negative result.

Note 1 :

Returns: can be < targetOutputSize, if compressed block contains less data.

Note 2 : targetOutputSize must be <= dstCapacity

Note 3 : this function effectively stops decoding on reaching targetOutputSize, so dstCapacity is kind of redundant. This is because in older versions of this function, decoding operation would still write complete sequences. Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize, it could write more bytes, though only up to dstCapacity. Some "margin" used to be required for this operation to work properly. Thankfully, this is no longer necessary. The function nonetheless keeps the same signature, in an effort to preserve API compatibility.

Note 4 : If srcSize is the exact size of the block, then targetOutputSize can be any value, including larger than the block's decompressed size. The function will, at most, generate block's decompressed size.

Note 5 : If srcSize is larger than block's compressed size, then targetOutputSize MUST be <= block's decompressed size. Otherwise, silent corruption will occur.

LZ4LIB_API LZ4_stream_t* tracy::LZ4_createStream ( void )

LZ4LIB_API int tracy::LZ4_freeStream ( LZ4_stream_t * streamPtr )

LZ4LIB_API void tracy::LZ4_resetStream_fast ( LZ4_stream_t * streamPtr )

LZ4_resetStream_fast() : v1.9.0+ Use this to prepare an LZ4_stream_t for a new chain of dependent blocks (e.g., LZ4_compress_fast_continue()).

An LZ4_stream_t must be initialized once before usage. This is automatically done when created by LZ4_createStream(). However, should the LZ4_stream_t be simply declared on stack (for example), it's necessary to initialize it first, using LZ4_initStream().

After init, start any new stream with LZ4_resetStream_fast(). A same LZ4_stream_t can be re-used multiple times consecutively and compress multiple streams, provided that it starts each new stream with LZ4_resetStream_fast().

LZ4_resetStream_fast() is much faster than LZ4_initStream(), but is not compatible with memory regions containing garbage data.

Note: it's only useful to call LZ4_resetStream_fast() in the context of streaming compression. The extState functions perform their own resets. Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive.

LZ4LIB_API int tracy::LZ4_loadDict	(	LZ4_stream_t *	streamPtr,
		const char *	dictionary,
		int	dictSize
	)

LZ4_loadDict() : Use this function to reference a static dictionary into LZ4_stream_t. The dictionary must remain available during compression. LZ4_loadDict() triggers a reset, so any previous data will be forgotten. The same dictionary will have to be loaded on decompression side for successful decoding. Dictionary are useful for better compression of small data (KB range). While LZ4 accept any input as dictionary, results are generally better when using Zstandard's Dictionary Builder. Loading a size of 0 is allowed, and is the same as reset.

Returns: : loaded dictionary size, in bytes (necessarily <= 64 KB)

LZ4LIB_API int tracy::LZ4_compress_fast_continue	(	LZ4_stream_t *	streamPtr,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity,
		int	acceleration
	)

LZ4_compress_fast_continue() : Compress 'src' content using data from previously compressed blocks, for better compression ratio. 'dst' buffer must be already allocated. If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.

Returns: : size of compressed block or 0 if there is an error (typically, cannot fit into 'dst').

Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block. Each block has precise boundaries. Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata. It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together.

Note 2 : The previous 64KB of source data is assumed to remain present, unmodified, at same address in memory !

Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB. Make sure that buffers are separated, by at least one byte. This construction ensures that each block only depends on previous block.

Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.

Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed.

LZ4LIB_API int tracy::LZ4_saveDict	(	LZ4_stream_t *	streamPtr,
		char *	safeBuffer,
		int	maxDictSize
	)

LZ4_saveDict() : If last 64KB data cannot be guaranteed to remain available at its current memory location, save it into a safer place (char* safeBuffer). This is schematically equivalent to a memcpy() followed by LZ4_loadDict(), but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.

Returns: : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.

LZ4LIB_API LZ4_streamDecode_t* tracy::LZ4_createStreamDecode ( void )

LZ4_createStreamDecode() and LZ4_freeStreamDecode() : creation / destruction of streaming decompression tracking context. A tracking context can be re-used multiple times.

LZ4LIB_API int tracy::LZ4_freeStreamDecode ( LZ4_streamDecode_t * LZ4_stream )

LZ4LIB_API int tracy::LZ4_setStreamDecode	(	LZ4_streamDecode_t *	LZ4_streamDecode,
		const char *	dictionary,
		int	dictSize
	)

LZ4_setStreamDecode() : An LZ4_streamDecode_t context can be allocated once and re-used multiple times. Use this function to start decompression of a new stream of blocks. A dictionary can optionally be set. Use NULL or size 0 for a reset order. Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.

Returns: : 1 if OK, 0 if error

LZ4LIB_API int tracy::LZ4_decoderRingBufferSize ( int maxBlockSize )

LZ4_decoderRingBufferSize() : v1.8.2+ Note : in a ring buffer scenario (optional), blocks are presumed decompressed next to each other up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize), at which stage it resumes from beginning of ring buffer. When setting such a ring buffer for streaming decompression, provides the minimum size of this ring buffer to be compatible with any source respecting maxBlockSize condition.

Returns: : minimum ring buffer size, or 0 if there is an error (invalid maxBlockSize).

LZ4LIB_API int tracy::LZ4_decompress_safe_continue	(	LZ4_streamDecode_t *	LZ4_streamDecode,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity
	)

LZ4_decompress_*_continue() : These decoding functions allow decompression of consecutive blocks in "streaming" mode. A block is an unsplittable entity, it must be presented entirely to a decompression function. Decompression functions only accepts one block at a time. The last 64KB of previously decoded data must remain available and unmodified at the memory position where they were decoded. If less than 64KB of data has been decoded, all the data must be present.

Special : if decompression side sets a ring buffer, it must respect one of the following conditions :

Decompression buffer size is at least LZ4_decoderRingBufferSize(maxBlockSize). maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes. In which case, encoding and decoding buffers do not need to be synchronized. Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
Synchronized mode : Decompression buffer size is exactly the same as compression buffer size, and follows exactly same update rule (block boundaries at same positions), and decoding function is provided with exact decompressed size of each block (exception for last block of the stream), then decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes. In which case, encoding and decoding buffers do not need to be synchronized, and encoding ring buffer can have any size, including small ones ( < 64 KB).

Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression, then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.

LZ4LIB_API int tracy::LZ4_decompress_safe_usingDict	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapcity,
		const char *	dictStart,
		int	dictSize
	)

LZ4_decompress_*_usingDict() : These decoding functions work the same as a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue() They are stand-alone, and don't need an LZ4_streamDecode_t structure. Dictionary is presumed stable : it must remain accessible and unmodified during decompression. Performance tip : Decompression speed can be substantially increased when dst == dictStart + dictSize.

LZ4LIB_API LZ4_stream_t* tracy::LZ4_initStream	(	void *	buffer,
		size_t	size
	)

LZ4_initStream() : v1.9.0+ An LZ4_stream_t structure must be initialized at least once. This is automatically done when invoking LZ4_createStream(), but it's not when the structure is simply declared on stack (for example).

Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t. It can also initialize any arbitrary buffer of sufficient size, and will

Returns: a pointer of proper type upon initialization.

Note : initialization fails if size and alignment conditions are not respected. In which case, the function will

Returns: NULL. Note2: An LZ4_stream_t structure guarantees correct alignment and size. Note3: Before v1.9.0, use LZ4_resetStream() instead

tracy::LZ4_DEPRECATED ( "use LZ4_compress_default() instead" ) const

Obsolete compression functions (since v1.7.3)

tracy::LZ4_DEPRECATED ( "use LZ4_compress_fast_extState() instead" )

tracy::LZ4_DEPRECATED ( "use LZ4_compress_fast_continue() instead" )

tracy::LZ4_DEPRECATED ( "use LZ4_decompress_fast() instead" ) const

Obsolete decompression functions (since v1.8.0)

tracy::LZ4_DEPRECATED ( "use LZ4_decompress_safe() instead" ) const

tracy::LZ4_DEPRECATED ( "Use LZ4_createStream() instead" )

tracy::LZ4_DEPRECATED ( "Use LZ4_resetStream() instead" )

tracy::LZ4_DEPRECATED ( "Use LZ4_saveDict() instead" )

tracy::LZ4_DEPRECATED ( "use LZ4_decompress_safe_usingDict() instead" ) const

Obsolete streaming decoding functions (since v1.7.0)

tracy::LZ4_DEPRECATED ( "use LZ4_decompress_fast_usingDict() instead" ) const

LZ4LIB_API int tracy::LZ4_decompress_fast	(	const char *	src,
		char *	dst,
		int	originalSize
	)

Obsolete LZ4_decompress_fast variants (since v1.9.0) : These functions used to be faster than LZ4_decompress_safe(), but this is no longer the case. They are now slower. This is because LZ4_decompress_fast() doesn't know the input size, and therefore must progress more cautiously into the input buffer to not read beyond the end of block. On top of that LZ4_decompress_fast() is not protected vs malformed or malicious inputs, making it a security liability. As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated.

The last remaining LZ4_decompress_fast() specificity is that it can decompress a block without knowing its compressed size. Such functionality can be achieved in a more secure manner by employing LZ4_decompress_safe_partial().

Parameters: originalSize : is the uncompressed size to regenerate. dst must be already allocated, its size must be >= 'originalSize' bytes.

Returns: : number of bytes read from source buffer (== compressed size). The function expects to finish at block's end exactly. If the source stream is detected malformed, the function stops decoding and returns a negative result. note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer. However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds. Also, since match offsets are not validated, match reads from 'src' may underflow too. These issues never happen if input (compressed) data is correct. But they may happen if input data is invalid (error or intentional tampering). As a consequence, use these functions in trusted environments with trusted data only.

LZ4LIB_API int tracy::LZ4_decompress_fast_continue	(	LZ4_streamDecode_t *	LZ4_streamDecode,
		const char *	src,
		char *	dst,
		int	originalSize
	)

LZ4LIB_API int tracy::LZ4_decompress_fast_usingDict	(	const char *	src,
		char *	dst,
		int	originalSize,
		const char *	dictStart,
		int	dictSize
	)

LZ4LIB_API void tracy::LZ4_resetStream ( LZ4_stream_t * streamPtr )

LZ4_resetStream() : An LZ4_stream_t structure must be initialized at least once. This is done with LZ4_initStream(), or LZ4_resetStream(). Consider switching to LZ4_initStream(), invoking LZ4_resetStream() will trigger deprecation warnings in the future.

LZ4LIB_API int tracy::LZ4_compress_HC	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity,
		int	compressionLevel
	)

LZ4_compress_HC() : Compress data from src into dst, using the powerful but slower "HC" algorithm. dst must be already allocated. Compression is guaranteed to succeed if dstCapacity >= LZ4_compressBound(srcSize) (see "lz4.h") Max supported srcSize value is LZ4_MAX_INPUT_SIZE (see "lz4.h") compressionLevel : any value between 1 and LZ4HC_CLEVEL_MAX will work. Values > LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX.

Returns: : the number of bytes written into 'dst' or 0 if compression fails.

LZ4LIB_API int tracy::LZ4_sizeofStateHC ( void )

LZ4_compress_HC_extStateHC() : Same as LZ4_compress_HC(), but using an externally allocated memory segment for state. state size is provided by LZ4_sizeofStateHC(). Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() should do properly).

LZ4LIB_API int tracy::LZ4_compress_HC_extStateHC	(	void *	stateHC,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	maxDstSize,
		int	compressionLevel
	)

LZ4LIB_API int tracy::LZ4_compress_HC_destSize	(	void *	stateHC,
		const char *	src,
		char *	dst,
		int *	srcSizePtr,
		int	targetDstSize,
		int	compressionLevel
	)

LZ4_compress_HC_destSize() : v1.9.0+ Will compress as much data as possible from src to fit into targetDstSize budget. Result is provided in 2 parts :

Returns: : the number of bytes written into 'dst' (necessarily <= targetDstSize) or 0 if compression fails. srcSizePtr : on success, *srcSizePtr is updated to indicate how much bytes were read from src

LZ4LIB_API LZ4_streamHC_t* tracy::LZ4_createStreamHC ( void )

LZ4_createStreamHC() and LZ4_freeStreamHC() : These functions create and release memory for LZ4 HC streaming state. Newly created states are automatically initialized. A same state can be used multiple times consecutively, starting with LZ4_resetStreamHC_fast() to start a new stream of blocks.

LZ4LIB_API int tracy::LZ4_freeStreamHC ( LZ4_streamHC_t * streamHCPtr )

LZ4LIB_API void tracy::LZ4_resetStreamHC_fast	(	LZ4_streamHC_t *	streamHCPtr,
		int	compressionLevel
	)

LZ4LIB_API int tracy::LZ4_loadDictHC	(	LZ4_streamHC_t *	streamHCPtr,
		const char *	dictionary,
		int	dictSize
	)

LZ4LIB_API int tracy::LZ4_compress_HC_continue	(	LZ4_streamHC_t *	streamHCPtr,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	maxDstSize
	)

LZ4LIB_API int tracy::LZ4_compress_HC_continue_destSize	(	LZ4_streamHC_t *	LZ4_streamHCPtr,
		const char *	src,
		char *	dst,
		int *	srcSizePtr,
		int	targetDstSize
	)

LZ4_compress_HC_continue_destSize() : v1.9.0+ Similar to LZ4_compress_HC_continue(), but will read as much data as possible from src to fit into targetDstSize budget. Result is provided into 2 parts :

Returns: : the number of bytes written into 'dst' (necessarily <= targetDstSize) or 0 if compression fails. srcSizePtr : on success, *srcSizePtr will be updated to indicate how much bytes were read from src. Note that this function may not consume the entire input.

LZ4LIB_API int tracy::LZ4_saveDictHC	(	LZ4_streamHC_t *	streamHCPtr,
		char *	safeBuffer,
		int	maxDictSize
	)

LZ4LIB_API LZ4_streamHC_t* tracy::LZ4_initStreamHC	(	void *	buffer,
		size_t	size
	)

tracy::LZ4_DEPRECATED ( "use LZ4_compress_HC() instead" ) const

tracy::LZ4_DEPRECATED ( "use LZ4_compress_HC_extStateHC() instead" )

tracy::LZ4_DEPRECATED ( "use LZ4_compress_HC_continue() instead" )

tracy::LZ4_DEPRECATED ( "use LZ4_createStreamHC() instead" ) const

tracy::LZ4_DEPRECATED ( "use LZ4_saveDictHC() instead" )

tracy::LZ4_DEPRECATED ( "use LZ4_freeStreamHC() instead" )

tracy::LZ4_DEPRECATED ( "use LZ4_initStreamHC() instead" )

LZ4LIB_API void tracy::LZ4_resetStreamHC	(	LZ4_streamHC_t *	streamHCPtr,
		int	compressionLevel
	)

template<typename T >

tracy_force_inline T tracy::MemRead ( const void * ptr )

template<typename T >

tracy_force_inline void tracy::MemWrite	(	void *	ptr,
		T	val
	)

static void* tracy::tracy_malloc ( size_t size )

inlinestatic

References rpmalloc().

Referenced by tracy::FastVector< FrameImageQueueItem >::AllocMore(), tracy::Profiler::AllocSourceLocation(), tracy::LockableCtx::CustomName(), tracy::SharedLockableCtx::CustomName(), tracy::moodycamel::ConcurrentQueueDefaultTraits::malloc(), tracy::Profiler::Message(), tracy::Profiler::MessageAppInfo(), tracy::Profiler::MessageColor(), tracy::ScopedZone::Name(), tracy::Profiler::SendFrameImage(), and tracy::ScopedZone::Text().

static void tracy::tracy_free ( void * ptr )

inlinestatic

References rpfree().

Referenced by tracy::FastVector< FrameImageQueueItem >::AllocMore(), tracy::moodycamel::ConcurrentQueueDefaultTraits::free(), and tracy::FastVector< FrameImageQueueItem >::~FastVector().

static void* tracy::tracy_realloc	(	void *	ptr,
		size_t	size
	)

inlinestatic

References rprealloc().

constexpr unsigned tracy::Lz4CompressBound ( unsigned isize )

tracy::static_assert	(	LZ4Size<=std::numeric_limits< lz4sz_t >::	max(),
		"LZ4Size greater than lz4sz_t"
	)

Referenced by tracy::moodycamel::details::ceil_to_pow_2(), and tracy::moodycamel::details::circular_less_than().

tracy::static_assert	(	TargetFrameSize 2 >=64	1024,
		"Not enough space for LZ4 stream buffer"
	)

tracy::static_assert	(	QueueItemSize	= `=32`,
		"Queue item size not 32 bytes"
	)

tracy::static_assert	(	sizeof(QueueDataSize)/sizeof(size_t)	= `=(uint8_t) QueueType::NUM_TYPES`,
		"QueueDataSize mismatch"
	)

tracy::static_assert	(	sizeof(void *)<=sizeof(uint64_t)	,
		"Pointer	size,
		8 bytes"
	)

tracy::static_assert ( sizeof(void *) = =sizeof(uintptr_t) )

TRACY_API void tracy::SetThreadName ( const char * name )

TRACY_API const char* tracy::GetThreadName ( uint64_t id )

static void tracy::LuaRegister ( lua_State * L )

inlinestatic

References tracy::detail::noop().

static char* tracy::FindEnd ( char * ptr )

inlinestatic

Referenced by LuaRemove().

static void tracy::LuaRemove ( char * script )

inlinestatic

References FindEnd().

Variable Documentation

const unsigned int tracy::tracy_systrace_armv7_size = 1149

static

const unsigned int tracy::tracy_systrace_armv7_data[1152/4]

static

Initial value:

{
    0x464c457f, 0x00010101, 0x00000000, 0x00000000, 0x00280003, 0x00000001, 0x000001f0, 0x00000034, 0x00000000, 0x05000200, 0x00200034, 0x00280007, 
    0x00000000, 0x00000006, 0x00000034, 0x00000034, 0x00000034, 0x000000e0, 0x000000e0, 0x00000004, 0x00000004, 0x00000003, 0x00000114, 0x00000114, 
    0x00000114, 0x00000013, 0x00000013, 0x00000004, 0x00000001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x000003fd, 0x000003fd, 0x00000005, 
    0x00001000, 0x00000001, 0x000003fd, 0x000013fd, 0x000013fd, 0x00000080, 0x000000b3, 0x00000006, 0x00001000, 0x00000002, 0x00000400, 0x00001400, 
    0x00001400, 0x0000007d, 0x000000b0, 0x00000006, 0x00000004, 0x6474e551, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000006, 
    0x00000004, 0x70000001, 0x000003a4, 0x000003a4, 0x000003a4, 0x00000008, 0x00000008, 0x00000004, 0x00000004, 0x7379732f, 0x2f6d6574, 0x2f6e6962, 
    0x6b6e696c, 0x00007265, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000000, 0x00000000, 0x00000012, 0x00000016, 0x00000000, 
    0x00000000, 0x00000012, 0x6f6c6400, 0x006e6570, 0x4342494c, 0x62696c00, 0x732e6c64, 0x6c64006f, 0x006d7973, 0x00000001, 0x00000003, 0x00000001, 
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00010001, 0x0000000d, 0x00000010, 0x00000000, 0x00050d63, 0x00020000, 0x00000008, 
    0x00000000, 0x000014bc, 0x00000116, 0x000014c0, 0x00000216, 0xe52de004, 0xe59fe004, 0xe08fe00e, 0xe5bef008, 0x000012dc, 0xe28fc600, 0xe28cca01, 
    0xe5bcf2dc, 0xe28fc600, 0xe28cca01, 0xe5bcf2d4, 0xe92d4ff0, 0xe28db01c, 0xe24dd024, 0xe24dd801, 0xe59f017c, 0xe3a01001, 0xe3a08001, 0xe08f0000, 
    0xebfffff0, 0xe59f116c, 0xe1a04000, 0xe08f1001, 0xebffffef, 0xe59f1160, 0xe1a06000, 0xe1a00004, 0xe08f1001, 0xebffffea, 0xe59f1150, 0xe1a07000, 
    0xe1a00004, 0xe08f1001, 0xebffffe5, 0xe59f1140, 0xe1a05000, 0xe1a00004, 0xe08f1001, 0xebffffe0, 0xe58d0004, 0xe1a00004, 0xe59f1128, 0xe08f1001, 
    0xebffffdb, 0xe59f1120, 0xe1a0a000, 0xe1a00004, 0xe08f1001, 0xebffffd6, 0xe1a04000, 0xe59f010c, 0xe3a01000, 0xe3a09000, 0xe08f0000, 0xe12fff36, 
    0xe1a06000, 0xe3700001, 0xca000001, 0xe3a00000, 0xe12fff37, 0xe3a00009, 0xe3a01001, 0xe1cd01bc, 0xe3a00008, 0xe1cd01b4, 0xe3090680, 0xe3400098, 
    0xe3a02000, 0xe58d000c, 0xe28d0010, 0xe58d7000, 0xe58d6018, 0xe58d8010, 0xe58d9008, 0xe12fff35, 0xe3500000, 0xca00001d, 0xe28d7018, 0xe28d8010, 
    0xe28d9020, 0xe1a00007, 0xe3a01001, 0xe3a02000, 0xe12fff35, 0xe3500000, 0xda00000a, 0xe1a00006, 0xe1a01009, 0xe3a02801, 0xe12fff3a, 0xe3500001, 
    0xba00000e, 0xe1a02000, 0xe3a00001, 0xe1a01009, 0xe12fff34, 0xea000003, 0xe59d2004, 0xe28d0008, 0xe3a01000, 0xe12fff32, 0xe1a00008, 0xe3a01001, 
    0xe3a02000, 0xe12fff35, 0xe3500001, 0xbaffffe4, 0xe59d1000, 0xe3a00000, 0xe12fff31, 0xe24bd01c, 0xe8bd8ff0, 0x00000198, 0x00000190, 0x00000181, 
    0x00000172, 0x00000163, 0x00000159, 0x0000014a, 0x00000138, 0x7ffffe4c, 0x00000001, 0x6362696c, 0x006f732e, 0x6e65706f, 0x69786500, 0x6f700074, 
    0x6e006c6c, 0x736f6e61, 0x7065656c, 0x61657200, 0x72770064, 0x00657469, 0x7379732f, 0x72656b2f, 0x2f6c656e, 0x75626564, 0x72742f67, 0x6e696361, 
    0x72742f67, 0x5f656361, 0x65706970, 0x00000000, 0x00000003, 0x000014b0, 0x00000002, 0x00000010, 0x00000017, 0x000001b4, 0x00000014, 0x00000011, 
    0x00000015, 0x00000000, 0x00000006, 0x00000128, 0x0000000b, 0x00000010, 0x00000005, 0x00000158, 0x0000000a, 0x0000001c, 0x6ffffef5, 0x00000174, 
    0x00000001, 0x0000000d, 0x0000001e, 0x00000008, 0x6ffffffb, 0x00000001, 0x6ffffff0, 0x0000018c, 0x6ffffffe, 0x00000194, 0x6fffffff, 0x00000001, 
}

const unsigned int tracy::tracy_systrace_aarch64_size = 1650

static

const unsigned int tracy::tracy_systrace_aarch64_data[1652/4]

static

const char char * tracy::dest

char int tracy::srcSize

const char char int int tracy::maxOutputSize

const char * tracy::source

const char char int tracy::inputSize

char int tracy::outputSize

Referenced by makVrv::DtMessage::serializeViaArchive().

char int tracy::isize

char * tracy::inputBuffer

char * tracy::dst

char int tracy::compressedSize

char int int tracy::maxDstSize

char int tracy::originalSize

const char char int int int tracy::compressionLevel

const char tracy::HandshakeShibboleth[HandshakeShibbolethSize] = { 'T', 'r', 'a', 'c', 'y', 'P', 'r', 'f' }

static

constexpr size_t tracy::QueueDataSize[]

static

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation