mirror/tracy
1
0
Fork 0
mirror of https://github.com/wolfpld/tracy.git synced 2024-11-27 00:04:35 +00:00
Code Issues Packages Projects Releases Wiki Activity
5306034893
tracy/client/TracyProfiler.cpp

3988 lines
130 KiB
C++
Raw Normal View History

Change TRACY_DISABLE to TRACY_ENABLE. By default tracy is now disabled.
2017-10-16 19:34:39 +00:00
#ifdef TRACY_ENABLE
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
#ifdef _WIN32
Moved NoMinMax inside _MSC_VER
2018-12-24 18:49:53 +00:00
# ifndef NOMINMAX
# define NOMINMAX
# endif
Moved NoMinMax before windows.h
2018-12-24 18:50:52 +00:00
# include <winsock2.h>
# include <windows.h>
# include <tlhelp32.h>
Add missing header for PRIxMAX.
2019-01-20 16:17:09 +00:00
# include <inttypes.h>
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
# include <intrin.h>
Reply to string requests.
2017-09-14 17:25:16 +00:00
#else
# include <sys/time.h>
Report physical memory size on BSD.
2019-11-21 01:14:08 +00:00
# include <sys/param.h>
Reply to string requests.
2017-09-14 17:25:16 +00:00
#endif
Process name getter.
2017-10-03 21:17:16 +00:00
#ifdef _GNU_SOURCE
# include <errno.h>
#endif
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
#ifdef __linux__
# include <dirent.h>
More header cleanup.
2019-11-05 19:15:53 +00:00
# include <signal.h>
# include <pthread.h>
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
# include <sys/types.h>
# include <sys/syscall.h>
#endif
Report physical memory size on BSD.
2019-11-21 01:14:08 +00:00
#if defined __APPLE__ || defined BSD
Retrieve memory size on apple.
2019-02-20 12:52:55 +00:00
# include <sys/types.h>
# include <sys/sysctl.h>
Process name retrieval on apple.
2019-02-20 12:13:29 +00:00
#endif
Compile ARM CPU decoding functions only if used.
2020-07-30 23:51:31 +00:00
#if defined __APPLE__
# include "TargetConditionals.h"
Get process executable path on macos.
2021-01-31 18:34:39 +00:00
# include <mach-o/dyld.h>
Compile ARM CPU decoding functions only if used.
2020-07-30 23:51:31 +00:00
#endif
Ensure that mappings have read permission before decoding symbols and reading code. (#129)
2020-11-21 20:05:39 +00:00
#ifdef __ANDROID__
# include <sys/mman.h>
Report device name on Android.
2021-10-26 16:09:56 +00:00
# include <sys/system_properties.h>
Ensure that mappings have read permission before decoding symbols and reading code. (#129)
2020-11-21 20:05:39 +00:00
# include <stdio.h>
# include <stdint.h>
# include <algorithm>
# include <vector>
#endif
More header cleanup.
2019-11-05 19:15:53 +00:00
#include <algorithm>
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
#include <assert.h>
More header cleanup.
2019-11-05 19:15:53 +00:00
#include <atomic>
Hide GetTime() in Profiler.
2017-09-23 19:09:46 +00:00
#include <chrono>
Reply to string requests.
2017-09-14 17:25:16 +00:00
#include <limits>
More header cleanup.
2019-11-05 19:15:53 +00:00
#include <new>
Getting program name on android.
2017-10-30 13:59:05 +00:00
#include <stdlib.h>
Missing header.
2017-09-19 00:19:20 +00:00
#include <string.h>
Check mtime of profiled executable.
2021-01-31 16:42:44 +00:00
#include <sys/stat.h>
Add number of CPU cores to host info.
2019-08-15 00:28:35 +00:00
#include <thread>
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
#include "../common/TracyAlign.hpp"
Send event data over network.
2017-09-11 20:51:47 +00:00
#include "../common/TracySocket.hpp"
Move TracySystem to a common directory.
2017-09-12 23:31:55 +00:00
#include "../common/TracySystem.hpp"
Use weak compare, yield thread.
2021-05-31 00:22:13 +00:00
#include "../common/TracyYield.hpp"
Don't include LZ4 headers in tracy headers. The LZ4 implementation is wrapped in tracy namespace, but it also adds some defines, which may conflict with other LZ4 implementations.
2019-05-01 10:57:42 +00:00
#include "../common/tracy_lz4.hpp"
Initialize rpmalloc.
2017-10-14 14:59:43 +00:00
#include "tracy_rpmalloc.hpp"
Windows callstack inspection plumbing.
2018-06-18 23:17:19 +00:00
#include "TracyCallstack.hpp"
Experimental DXT1 compressor.
2019-06-27 15:09:47 +00:00
#include "TracyDxt1.hpp"
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
#include "TracyScoped.hpp"
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
#include "TracyProfiler.hpp"
Use custom threading wrapper instead of std::thread. std::thread may perform memory allocation when a thread is created (it does so on MSVC). Tracy heap is managed by its own allocator and this changes prevents accessing application heap.
2017-10-16 19:13:57 +00:00
#include "TracyThread.hpp"
Decode ARM CPU names.
2019-07-03 19:01:34 +00:00
#include "TracyArmCpuTable.hpp"
Implement retrieval of external process names.
2019-08-16 17:22:23 +00:00
#include "TracySysTrace.hpp"
C API prototype.
2019-01-14 19:55:37 +00:00
#include "../TracyC.h"
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
Separate config for data and broadcast port.
2020-03-08 13:34:09 +00:00
#ifdef TRACY_PORT
# ifndef TRACY_DATA_PORT
# define TRACY_DATA_PORT TRACY_PORT
# endif
# ifndef TRACY_BROADCAST_PORT
# define TRACY_BROADCAST_PORT TRACY_PORT
# endif
#endif
Fix if condition.
2019-02-19 20:51:41 +00:00
#ifdef __APPLE__
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# define TRACY_DELAYED_INIT
Force proper initialization order on gcc.
2017-10-08 22:39:12 +00:00
#else
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# ifdef __GNUC__
# define init_order( val ) __attribute__ ((init_priority(val)))
# else
# define init_order(x)
# endif
Force proper initialization order on gcc.
2017-10-08 22:39:12 +00:00
#endif
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Host info discovery.
2018-08-19 16:15:14 +00:00
# include <lmcons.h>
Perform windows version discovery.
2018-08-19 16:43:26 +00:00
extern "C" typedef LONG (WINAPI *t_RtlGetVersion)( PRTL_OSVERSIONINFOW );
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
extern "C" typedef BOOL (WINAPI *t_GetLogicalProcessorInformationEx)( LOGICAL_PROCESSOR_RELATIONSHIP, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD );
Host info discovery.
2018-08-19 16:15:14 +00:00
#else
# include <unistd.h>
# include <limits.h>
#endif
System RAM discovery on Linux.
2018-08-19 16:52:04 +00:00
#if defined __linux__
# include <sys/sysinfo.h>
Discover linux kernel version.
2018-08-19 17:00:01 +00:00
# include <sys/utsname.h>
System RAM discovery on Linux.
2018-08-19 16:52:04 +00:00
#endif
Host info discovery.
2018-08-19 16:15:14 +00:00
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if !defined _WIN32 && ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 )
Add include for built-in __get_cpuid() on gcc/clang.
2019-07-10 00:09:19 +00:00
# include <cpuid.h>
#endif
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if !( ( defined _WIN32 && _WIN32_WINNT >= _WIN32_WINNT_VISTA ) || defined __linux__ )
Include <mutex> for std::once.
2019-11-05 20:40:35 +00:00
# include <mutex>
#endif
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
namespace tracy
{
Move EnsureReadable() and co. to top of source file.
2021-10-20 22:06:14 +00:00
#ifdef __ANDROID__
// Implementation helpers of EnsureReadable(address).
// This is so far only needed on Android, where it is common for libraries to be mapped
// with only executable, not readable, permissions. Typical example (line from /proc/self/maps):
/*
746b63b000-746b6dc000 --xp 00042000 07:48 35 /apex/com.android.runtime/lib64/bionic/libc.so
*/
// See https://github.com/wolfpld/tracy/issues/125 .
// To work around this, we parse /proc/self/maps and we use mprotect to set read permissions
// on any mappings that contain symbols addresses hit by HandleSymbolCodeQuery.
namespace {
// Holds some information about a single memory mapping.
struct MappingInfo {
// Start of address range. Inclusive.
uintptr_t start_address;
// End of address range. Exclusive, so the mapping is the half-open interval
// [start, end) and its length in bytes is `end - start`. As in /proc/self/maps.
uintptr_t end_address;
// Read/Write/Executable permissions.
bool perm_r, perm_w, perm_x;
};
} // anonymous namespace
// Internal implementation helper for LookUpMapping(address).
//
// Parses /proc/self/maps returning a vector<MappingInfo>.
// /proc/self/maps is assumed to be sorted by ascending address, so the resulting
// vector is sorted by ascending address too.
static std::vector<MappingInfo> ParseMappings()
{
std::vector<MappingInfo> result;
FILE* file = fopen( "/proc/self/maps", "r" );
if( !file ) return result;
char line[1024];
while( fgets( line, sizeof( line ), file ) )
{
uintptr_t start_addr;
uintptr_t end_addr;
if( sscanf( line, "%lx-%lx", &start_addr, &end_addr ) != 2 ) continue;
char* first_space = strchr( line, ' ' );
if( !first_space ) continue;
char* perm = first_space + 1;
char* second_space = strchr( perm, ' ' );
if( !second_space || second_space - perm != 4 ) continue;
result.emplace_back();
auto& mapping = result.back();
mapping.start_address = start_addr;
mapping.end_address = end_addr;
mapping.perm_r = perm[0] == 'r';
mapping.perm_w = perm[1] == 'w';
mapping.perm_x = perm[2] == 'x';
}
fclose( file );
return result;
}
// Internal implementation helper for LookUpMapping(address).
//
// Takes as input an `address` and a known vector `mappings`, assumed to be
// sorted by increasing addresses, as /proc/self/maps seems to be.
// Returns a pointer to the MappingInfo describing the mapping that this
// address belongs to, or nullptr if the address isn't in `mappings`.
static MappingInfo* LookUpMapping(std::vector<MappingInfo>& mappings, uintptr_t address)
{
// Comparison function for std::lower_bound. Returns true if all addresses in `m1`
// are lower than `addr`.
auto Compare = []( const MappingInfo& m1, uintptr_t addr ) {
// '<=' because the address ranges are half-open intervals, [start, end).
return m1.end_address <= addr;
};
auto iter = std::lower_bound( mappings.begin(), mappings.end(), address, Compare );
if( iter == mappings.end() || iter->start_address > address) {
return nullptr;
}
return &*iter;
}
// Internal implementation helper for EnsureReadable(address).
//
// Takes as input an `address` and returns a pointer to a MappingInfo
// describing the mapping that this address belongs to, or nullptr if
// the address isn't in any known mapping.
//
// This function is stateful and not reentrant (assumes to be called from
// only one thread). It holds a vector of mappings parsed from /proc/self/maps.
//
// Attempts to react to mappings changes by re-parsing /proc/self/maps.
static MappingInfo* LookUpMapping(uintptr_t address)
{
// Static state managed by this function. Not constant, we mutate that state as
// we turn some mappings readable. Initially parsed once here, updated as needed below.
static std::vector<MappingInfo> s_mappings = ParseMappings();
MappingInfo* mapping = LookUpMapping( s_mappings, address );
if( mapping ) return mapping;
// This address isn't in any known mapping. Try parsing again, maybe
// mappings changed.
s_mappings = ParseMappings();
return LookUpMapping( s_mappings, address );
}
// Internal implementation helper for EnsureReadable(address).
//
// Attempts to make the specified `mapping` readable if it isn't already.
// Returns true if and only if the mapping is readable.
static bool EnsureReadable( MappingInfo& mapping )
{
if( mapping.perm_r )
{
// The mapping is already readable.
return true;
}
int prot = PROT_READ;
if( mapping.perm_w ) prot |= PROT_WRITE;
if( mapping.perm_x ) prot |= PROT_EXEC;
if( mprotect( reinterpret_cast<void*>( mapping.start_address ),
mapping.end_address - mapping.start_address, prot ) == -1 )
{
// Failed to make the mapping readable. Shouldn't happen, hasn't
// been observed yet. If it happened in practice, we should consider
// adding a bool to MappingInfo to track this to avoid retrying mprotect
// everytime on such mappings.
return false;
}
// The mapping is now readable. Update `mapping` so the next call will be fast.
mapping.perm_r = true;
return true;
}
// Attempts to set the read permission on the entire mapping containing the
// specified address. Returns true if and only if the mapping is now readable.
static bool EnsureReadable( uintptr_t address )
{
MappingInfo* mapping = LookUpMapping(address);
return mapping && EnsureReadable( *mapping );
}
#endif // defined __ANDROID__
Always use init once to initialize rpmalloc.
2020-01-30 18:38:05 +00:00
#ifndef TRACY_DELAYED_INIT
Measure time of initialization start.
2017-10-16 23:07:34 +00:00
struct InitTimeWrapper
{
int64_t val;
};
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
struct ProducerWrapper
{
tracy::moodycamel::ConcurrentQueue<QueueItem>::ExplicitProducer* ptr;
};
Proper init order of thread local thread handle.
2019-06-26 17:32:52 +00:00
struct ThreadHandleWrapper
{
Change thread id size from 64 to 32 bits. Both Windows and Linux use 32-bit thread identifiers. MacOS has a 64-bit counter, but in practice it will never overflow during profiling and no false aliasing will happen. These changes are only done client-side and in the network protocol. The server still uses 64-bit thread identifiers, to enable virtual threads, etc.
2021-10-07 22:42:52 +00:00
uint32_t val;
Proper init order of thread local thread handle.
2019-06-26 17:32:52 +00:00
};
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
#endif
Fix spacing
2021-04-09 22:35:44 +00:00
Use one cpuid implementation.
2020-05-06 16:52:36 +00:00
#if defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
static inline void CpuId( uint32_t* regs, uint32_t leaf )
{
ensure regs is initialized even if cpuid fails
2020-06-03 18:11:15 +00:00
memset(regs, 0, sizeof(uint32_t) * 4);
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
__cpuidex( (int*)regs, leaf, 0 );
#else
__get_cpuid( leaf, regs, regs+1, regs+2, regs+3 );
#endif
}
static void InitFailure( const char* msg )
{
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Display error messages on console, if available.
2019-08-08 17:18:05 +00:00
bool hasConsole = false;
bool reopen = false;
const auto attached = AttachConsole( ATTACH_PARENT_PROCESS );
if( attached )
{
hasConsole = true;
reopen = true;
}
else
{
const auto err = GetLastError();
if( err == ERROR_ACCESS_DENIED )
{
hasConsole = true;
}
}
if( hasConsole )
{
fprintf( stderr, "Tracy Profiler initialization failure: %s\n", msg );
if( reopen )
{
freopen( "CONOUT$", "w", stderr );
fprintf( stderr, "Tracy Profiler initialization failure: %s\n", msg );
}
}
else
{
MessageBoxA( nullptr, msg, "Tracy Profiler initialization failure", MB_ICONSTOP );
}
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
#else
fprintf( stderr, "Tracy Profiler initialization failure: %s\n", msg );
#endif
Signal initialization failure through exit code.
2021-11-11 11:43:59 +00:00
exit( 1 );
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
}
static int64_t SetupHwTimer()
{
Fix timer setup for fallback timer.
2021-01-29 10:20:23 +00:00
#if !defined TRACY_TIMER_QPC && !defined TRACY_TIMER_FALLBACK
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
uint32_t regs[4];
Use proper cpuid flag.
2020-06-10 14:25:19 +00:00
CpuId( regs, 1 );
Change rdtscp check to rdtsc check.
2020-06-08 17:35:42 +00:00
if( !( regs[3] & ( 1 << 4 ) ) ) InitFailure( "CPU doesn't support RDTSC instruction." );
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
CpuId( regs, 0x80000007 );
Allow skipping invariant TSC check.
2019-08-08 17:21:39 +00:00
if( !( regs[3] & ( 1 << 8 ) ) )
{
PR feedback
2021-04-09 22:33:01 +00:00
const char* noCheck = GetEnvVar( "TRACY_NO_INVARIANT_CHECK" );
Allow skipping invariant TSC check.
2019-08-08 17:21:39 +00:00
if( !noCheck || noCheck[0] != '1' )
{
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Add a define for fallback timer usage.
2021-01-28 17:49:17 +00:00
InitFailure( "CPU doesn't support invariant TSC.\nDefine TRACY_NO_INVARIANT_CHECK=1 to ignore this error, *if you know what you are doing*.\nAlternatively you may rebuild the application with the TRACY_TIMER_QPC or TRACY_TIMER_FALLBACK define to use lower resolution timer." );
There's no QPC on non-windows systems.
2020-09-20 17:47:00 +00:00
#else
Add a define for fallback timer usage.
2021-01-28 17:49:17 +00:00
InitFailure( "CPU doesn't support invariant TSC.\nDefine TRACY_NO_INVARIANT_CHECK=1 to ignore this error, *if you know what you are doing*.\nAlternatively you may rebuild the application with the TRACY_TIMER_FALLBACK define to use lower resolution timer." );
There's no QPC on non-windows systems.
2020-09-20 17:47:00 +00:00
#endif
Allow skipping invariant TSC check.
2019-08-08 17:21:39 +00:00
}
}
Add support for QPC timer.
2020-04-07 20:01:31 +00:00
#endif
Check for rdstcp/invariant tsc support.
2019-07-10 00:01:08 +00:00
return Profiler::GetTime();
}
Test if HW timer can be used on arm.
2018-04-27 14:58:45 +00:00
#else
static int64_t SetupHwTimer()
{
return Profiler::GetTime();
}
#endif
Process name getter.
2017-10-03 21:17:16 +00:00
static const char* GetProcessName()
{
Fixed __ANDROID_API__ < 21 build and FD_SET usage.
2018-08-01 17:18:40 +00:00
const char* processName = "unknown";
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
#ifdef _WIN32
Process name getter.
2017-10-03 21:17:16 +00:00
static char buf[_MAX_PATH];
GetModuleFileNameA( nullptr, buf, _MAX_PATH );
const char* ptr = buf;
while( *ptr != '\0' ) ptr++;
while( ptr > buf && *ptr != '\\' && *ptr != '/' ) ptr--;
if( ptr > buf ) ptr++;
Fixed __ANDROID_API__ < 21 build and FD_SET usage.
2018-08-01 17:18:40 +00:00
processName = ptr;
Getting program name on android.
2017-10-30 13:59:05 +00:00
#elif defined __ANDROID__
# if __ANDROID_API__ >= 21
auto buf = getprogname();
Fixed __ANDROID_API__ < 21 build and FD_SET usage.
2018-08-01 17:18:40 +00:00
if( buf ) processName = buf;
Getting program name on android.
2017-10-30 13:59:05 +00:00
# endif
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#elif defined _GNU_SOURCE
Apparently program_invocation_short_name may be not defined.
2021-02-11 17:12:59 +00:00
if( program_invocation_short_name ) processName = program_invocation_short_name;
Get proper program name on BSD.
2019-11-21 01:16:12 +00:00
#elif defined __APPLE__ || defined BSD
Just use getprogname().
2019-02-21 10:40:56 +00:00
auto buf = getprogname();
if( buf ) processName = buf;
Fixed compiler warnings.
2018-08-01 12:07:30 +00:00
#endif
Fixed __ANDROID_API__ < 21 build and FD_SET usage.
2018-08-01 17:18:40 +00:00
return processName;
Process name getter.
2017-10-03 21:17:16 +00:00
}
Implement getting process executable path.
2021-01-31 16:37:54 +00:00
static const char* GetProcessExecutablePath()
{
#ifdef _WIN32
static char buf[_MAX_PATH];
GetModuleFileNameA( nullptr, buf, _MAX_PATH );
return buf;
Android applications spawn through a common executable. /proc/self/exe -> /system/bin/app_process64
2021-02-01 14:24:31 +00:00
#elif defined __ANDROID__
return nullptr;
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#elif defined _GNU_SOURCE
Implement getting process executable path.
2021-01-31 16:37:54 +00:00
return program_invocation_name;
Get process executable path on macos.
2021-01-31 18:34:39 +00:00
#elif defined __APPLE__
static char buf[1024];
uint32_t size = 1024;
_NSGetExecutablePath( buf, &size );
return buf;
Executable path discovery on BSDs.
2021-01-31 19:27:32 +00:00
#elif defined __DragonFly__
static char buf[1024];
readlink( "/proc/curproc/file", buf, 1024 );
return buf;
#elif defined __FreeBSD__
static char buf[1024];
int mib[4];
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PATHNAME;
mib[3] = -1;
size_t cb = 1024;
sysctl( mib, 4, buf, &cb, nullptr, 0 );
return buf;
#elif defined __NetBSD__
static char buf[1024];
readlink( "/proc/curproc/exe", buf, 1024 );
return buf;
Implement getting process executable path.
2021-01-31 16:37:54 +00:00
#else
return nullptr;
#endif
}
GetHex() is only used on ARM linux.
2020-07-30 23:46:16 +00:00
#if defined __linux__ && defined __ARM_ARCH
Decode ARM CPU names.
2019-07-03 19:01:34 +00:00
static uint32_t GetHex( char*& ptr, int skip )
{
uint32_t ret;
ptr += skip;
char* end;
if( ptr[0] == '0' && ptr[1] == 'x' )
{
ptr += 2;
ret = strtol( ptr, &end, 16 );
}
else
{
ret = strtol( ptr, &end, 10 );
}
ptr = end;
return ret;
}
GetHex() is only used on ARM linux.
2020-07-30 23:46:16 +00:00
#endif
Decode ARM CPU names.
2019-07-03 19:01:34 +00:00
Host info discovery.
2018-08-19 16:15:14 +00:00
static const char* GetHostInfo()
{
static char buf[1024];
auto ptr = buf;
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Get rid of unicode ifdefs.
2020-04-07 19:35:37 +00:00
t_RtlGetVersion RtlGetVersion = (t_RtlGetVersion)GetProcAddress( GetModuleHandleA( "ntdll.dll" ), "RtlGetVersion" );
Perform windows version discovery.
2018-08-19 16:43:26 +00:00
if( !RtlGetVersion )
{
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
# ifdef __MINGW32__
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
ptr += sprintf( ptr, "OS: Windows (MingW)\n" );
# else
ptr += sprintf( ptr, "OS: Windows\n" );
Perform windows version discovery.
2018-08-19 16:43:26 +00:00
# endif
}
else
{
RTL_OSVERSIONINFOW ver = { sizeof( RTL_OSVERSIONINFOW ) };
RtlGetVersion( &ver );
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
# ifdef __MINGW32__
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
ptr += sprintf( ptr, "OS: Windows %i.%i.%i (MingW)\n", (int)ver.dwMajorVersion, (int)ver.dwMinorVersion, (int)ver.dwBuildNumber );
# else
ptr += sprintf( ptr, "OS: Windows %i.%i.%i\n", ver.dwMajorVersion, ver.dwMinorVersion, ver.dwBuildNumber );
Perform windows version discovery.
2018-08-19 16:43:26 +00:00
# endif
}
Host info discovery.
2018-08-19 16:15:14 +00:00
#elif defined __linux__
Discover linux kernel version.
2018-08-19 17:00:01 +00:00
struct utsname utsName;
uname( &utsName );
Host info discovery.
2018-08-19 16:15:14 +00:00
# if defined __ANDROID__
Discover linux kernel version.
2018-08-19 17:00:01 +00:00
ptr += sprintf( ptr, "OS: Linux %s (Android)\n", utsName.release );
Host info discovery.
2018-08-19 16:15:14 +00:00
# else
Discover linux kernel version.
2018-08-19 17:00:01 +00:00
ptr += sprintf( ptr, "OS: Linux %s\n", utsName.release );
Host info discovery.
2018-08-19 16:15:14 +00:00
# endif
#elif defined __APPLE__
Fix apple target detection.
2019-02-20 11:43:48 +00:00
# if TARGET_OS_IPHONE == 1
Host info discovery.
2018-08-19 16:15:14 +00:00
ptr += sprintf( ptr, "OS: Darwin (iOS)\n" );
Fix apple target detection.
2019-02-20 11:43:48 +00:00
# elif TARGET_OS_MAC == 1
Host info discovery.
2018-08-19 16:15:14 +00:00
ptr += sprintf( ptr, "OS: Darwin (OSX)\n" );
# else
ptr += sprintf( ptr, "OS: Darwin (unknown)\n" );
# endif
#elif defined __DragonFly__
ptr += sprintf( ptr, "OS: BSD (DragonFly)\n" );
#elif defined __FreeBSD__
ptr += sprintf( ptr, "OS: BSD (FreeBSD)\n" );
#elif defined __NetBSD__
ptr += sprintf( ptr, "OS: BSD (NetBSD)\n" );
#elif defined __OpenBSD__
ptr += sprintf( ptr, "OS: BSD (OpenBSD)\n" );
#else
ptr += sprintf( ptr, "OS: unknown\n" );
#endif
#if defined _MSC_VER
Detect and report clang-cl.
2019-07-25 17:03:58 +00:00
# if defined __clang__
ptr += sprintf( ptr, "Compiler: MSVC clang-cl %i.%i.%i\n", __clang_major__, __clang_minor__, __clang_patchlevel__ );
# else
Host info discovery.
2018-08-19 16:15:14 +00:00
ptr += sprintf( ptr, "Compiler: MSVC %i\n", _MSC_VER );
Detect and report clang-cl.
2019-07-25 17:03:58 +00:00
# endif
Host info discovery.
2018-08-19 16:15:14 +00:00
#elif defined __clang__
ptr += sprintf( ptr, "Compiler: clang %i.%i.%i\n", __clang_major__, __clang_minor__, __clang_patchlevel__ );
#elif defined __GNUC__
ptr += sprintf( ptr, "Compiler: gcc %i.%i\n", __GNUC__, __GNUC_MINOR__ );
#else
ptr += sprintf( ptr, "Compiler: unknown\n" );
#endif
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Host info discovery.
2018-08-19 16:15:14 +00:00
InitWinSock();
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
Host info discovery.
2018-08-19 16:15:14 +00:00
char hostname[512];
gethostname( hostname, 512 );
DWORD userSz = UNLEN+1;
char user[UNLEN+1];
GetUserNameA( user, &userSz );
ptr += sprintf( ptr, "User: %s@%s\n", user, hostname );
#else
HOST_NAME_MAX and LOGIN_NAME_MAX availability is not consistent across linux/android/macos platforms. However all of them do have versions of these macros with _POSIX_ prefix. In addition to that hostname and user variables may be uninitialized in some configurations, however they are always used. Initializing these arrays fixes conditional depending on uninitialized memory warning uncovered by valgrind.
2018-12-18 15:10:39 +00:00
char hostname[_POSIX_HOST_NAME_MAX]{};
char user[_POSIX_LOGIN_NAME_MAX]{};
Host info discovery.
2018-08-19 16:15:14 +00:00
HOST_NAME_MAX and LOGIN_NAME_MAX availability is not consistent across linux/android/macos platforms. However all of them do have versions of these macros with _POSIX_ prefix. In addition to that hostname and user variables may be uninitialized in some configurations, however they are always used. Initializing these arrays fixes conditional depending on uninitialized memory warning uncovered by valgrind.
2018-12-18 15:10:39 +00:00
gethostname( hostname, _POSIX_HOST_NAME_MAX );
There's no getlogin_t() on android.
2018-08-27 11:59:19 +00:00
# if defined __ANDROID__
const auto login = getlogin();
if( login )
{
strcpy( user, login );
}
else
{
memcpy( user, "(?)", 4 );
}
# else
HOST_NAME_MAX and LOGIN_NAME_MAX availability is not consistent across linux/android/macos platforms. However all of them do have versions of these macros with _POSIX_ prefix. In addition to that hostname and user variables may be uninitialized in some configurations, however they are always used. Initializing these arrays fixes conditional depending on uninitialized memory warning uncovered by valgrind.
2018-12-18 15:10:39 +00:00
getlogin_r( user, _POSIX_LOGIN_NAME_MAX );
There's no getlogin_t() on android.
2018-08-27 11:59:19 +00:00
# endif
Host info discovery.
2018-08-19 16:15:14 +00:00
ptr += sprintf( ptr, "User: %s@%s\n", user, hostname );
#endif
#if defined __i386 || defined _M_IX86
ptr += sprintf( ptr, "Arch: x86\n" );
#elif defined __x86_64__ || defined _M_X64
ptr += sprintf( ptr, "Arch: x64\n" );
#elif defined __aarch64__
ptr += sprintf( ptr, "Arch: ARM64\n" );
#elif defined __ARM_ARCH
ptr += sprintf( ptr, "Arch: ARM\n" );
#else
ptr += sprintf( ptr, "Arch: unknown\n" );
#endif
#if defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64
uint32_t regs[4];
char cpuModel[4*4*3];
auto modelPtr = cpuModel;
Fix signed/unsigned.
2018-08-19 16:53:32 +00:00
for( uint32_t i=0x80000002; i<0x80000005; ++i )
Host info discovery.
2018-08-19 16:15:14 +00:00
{
Use one cpuid implementation.
2020-05-06 16:52:36 +00:00
CpuId( regs, i );
Host info discovery.
2018-08-19 16:15:14 +00:00
memcpy( modelPtr, regs, sizeof( regs ) ); modelPtr += sizeof( regs );
}
ptr += sprintf( ptr, "CPU: %s\n", cpuModel );
Decode ARM CPU names.
2019-07-03 19:01:34 +00:00
#elif defined __linux__ && defined __ARM_ARCH
bool cpuFound = false;
FILE* fcpuinfo = fopen( "/proc/cpuinfo", "rb" );
if( fcpuinfo )
{
enum { BufSize = 4*1024 };
char buf[BufSize];
const auto sz = fread( buf, 1, BufSize, fcpuinfo );
fclose( fcpuinfo );
const auto end = buf + sz;
auto cptr = buf;
uint32_t impl = 0;
uint32_t var = 0;
uint32_t part = 0;
uint32_t rev = 0;
while( end - cptr > 20 )
{
while( end - cptr > 20 && memcmp( cptr, "CPU ", 4 ) != 0 )
{
cptr += 4;
while( end - cptr > 20 && *cptr != '\n' ) cptr++;
cptr++;
}
if( end - cptr <= 20 ) break;
cptr += 4;
if( memcmp( cptr, "implementer\t: ", 14 ) == 0 )
{
if( impl != 0 ) break;
impl = GetHex( cptr, 14 );
}
else if( memcmp( cptr, "variant\t: ", 10 ) == 0 ) var = GetHex( cptr, 10 );
else if( memcmp( cptr, "part\t: ", 7 ) == 0 ) part = GetHex( cptr, 7 );
else if( memcmp( cptr, "revision\t: ", 11 ) == 0 ) rev = GetHex( cptr, 11 );
while( *cptr != '\n' && *cptr != '\0' ) cptr++;
cptr++;
}
if( impl != 0 || var != 0 || part != 0 || rev != 0 )
{
cpuFound = true;
ptr += sprintf( ptr, "CPU: %s%s r%ip%i\n", DecodeArmImplementer( impl ), DecodeArmPart( impl, part ), var, rev );
}
}
if( !cpuFound )
{
ptr += sprintf( ptr, "CPU: unknown\n" );
}
iOS device name decoding.
2019-06-19 07:59:46 +00:00
#elif defined __APPLE__ && TARGET_OS_IPHONE == 1
{
size_t sz;
sysctlbyname( "hw.machine", nullptr, &sz, nullptr, 0 );
auto str = (char*)tracy_malloc( sz );
sysctlbyname( "hw.machine", str, &sz, nullptr, 0 );
ptr += sprintf( ptr, "Device: %s\n", DecodeIosDevice( str ) );
tracy_free( str );
}
Host info discovery.
2018-08-19 16:15:14 +00:00
#else
ptr += sprintf( ptr, "CPU: unknown\n" );
#endif
Report device name on Android.
2021-10-26 16:09:56 +00:00
#ifdef __ANDROID__
char deviceModel[PROP_VALUE_MAX+1];
char deviceManufacturer[PROP_VALUE_MAX+1];
__system_property_get( "ro.product.model", deviceModel );
__system_property_get( "ro.product.manufacturer", deviceManufacturer );
ptr += sprintf( ptr, "Device: %s %s\n", deviceManufacturer, deviceModel );
#endif
Host info discovery.
2018-08-19 16:15:14 +00:00
Add number of CPU cores to host info.
2019-08-15 00:28:35 +00:00
ptr += sprintf( ptr, "CPU cores: %i\n", std::thread::hardware_concurrency() );
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Host info discovery.
2018-08-19 16:15:14 +00:00
MEMORYSTATUSEX statex;
statex.dwLength = sizeof( statex );
GlobalMemoryStatusEx( &statex );
Proper printf type for DWORDLONG on cygwin.
2018-12-28 23:49:05 +00:00
# ifdef _MSC_VER
Fix printf types.
2018-08-22 14:31:09 +00:00
ptr += sprintf( ptr, "RAM: %I64u MB\n", statex.ullTotalPhys / 1024 / 1024 );
Proper printf type for DWORDLONG on cygwin.
2018-12-28 23:49:05 +00:00
# else
ptr += sprintf( ptr, "RAM: %llu MB\n", statex.ullTotalPhys / 1024 / 1024 );
# endif
System RAM discovery on Linux.
2018-08-19 16:52:04 +00:00
#elif defined __linux__
struct sysinfo sysInfo;
sysinfo( &sysInfo );
Fix warning.
2018-08-20 10:53:14 +00:00
ptr += sprintf( ptr, "RAM: %lu MB\n", sysInfo.totalram / 1024 / 1024 );
Retrieve memory size on apple.
2019-02-20 12:52:55 +00:00
#elif defined __APPLE__
size_t memSize;
size_t sz = sizeof( memSize );
sysctlbyname( "hw.memsize", &memSize, &sz, nullptr, 0 );
ptr += sprintf( ptr, "RAM: %zu MB\n", memSize / 1024 / 1024 );
Report physical memory size on BSD.
2019-11-21 01:14:08 +00:00
#elif defined BSD
size_t memSize;
size_t sz = sizeof( memSize );
sysctlbyname( "hw.physmem", &memSize, &sz, nullptr, 0 );
ptr += sprintf( ptr, "RAM: %zu MB\n", memSize / 1024 / 1024 );
Host info discovery.
2018-08-19 16:15:14 +00:00
#else
ptr += sprintf( ptr, "RAM: unknown\n" );
#endif
return buf;
}
Transfer PID of profiled program.
2019-08-17 20:19:04 +00:00
static uint64_t GetPid()
{
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Transfer PID of profiled program.
2019-08-17 20:19:04 +00:00
return uint64_t( GetCurrentProcessId() );
#else
return uint64_t( getpid() );
#endif
}
Preserve valid order of server query acknowledgements.
2021-02-07 19:53:20 +00:00
void Profiler::AckServerQuery()
Move server query acknowledgement to a separate function.
2021-02-03 21:32:31 +00:00
{
Preserve valid order of server query acknowledgements.
2021-02-07 19:53:20 +00:00
QueueItem item;
MemWrite( &item.hdr.type, QueueType::AckServerQueryNoop );
NeedDataSize( QueueDataSize[(int)QueueType::AckServerQueryNoop] );
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::AckServerQueryNoop] );
Move server query acknowledgement to a separate function.
2021-02-03 21:32:31 +00:00
}
Preserve valid order of server query acknowledgements.
2021-02-07 19:53:20 +00:00
void Profiler::AckSourceCodeNotAvailable()
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
{
Preserve valid order of server query acknowledgements.
2021-02-07 19:53:20 +00:00
QueueItem item;
MemWrite( &item.hdr.type, QueueType::AckSourceCodeNotAvailable );
NeedDataSize( QueueDataSize[(int)QueueType::AckSourceCodeNotAvailable] );
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::AckSourceCodeNotAvailable] );
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
}
Send listen port in broadcast message.
2020-03-08 13:37:59 +00:00
static BroadcastMessage& GetBroadcastMessage( const char* procname, size_t pnsz, int& len, int port )
Broadcast protocol version and process name.
2019-06-17 16:34:35 +00:00
{
Define broadcast message, add versioning.
2019-06-18 18:26:40 +00:00
static BroadcastMessage msg;
Broadcast protocol version and process name.
2019-06-17 16:34:35 +00:00
Define broadcast message, add versioning.
2019-06-18 18:26:40 +00:00
msg.broadcastVersion = BroadcastVersion;
msg.protocolVersion = ProtocolVersion;
Send listen port in broadcast message.
2020-03-08 13:37:59 +00:00
msg.listenPort = port;
Broadcast protocol version and process name.
2019-06-17 16:34:35 +00:00
Define broadcast message, add versioning.
2019-06-18 18:26:40 +00:00
memcpy( msg.programName, procname, pnsz );
memset( msg.programName + pnsz, 0, WelcomeMessageProgramNameSize - pnsz );
Broadcast protocol version and process name.
2019-06-17 16:34:35 +00:00
Cast to proper types.
2019-06-26 17:33:37 +00:00
len = int( offsetof( BroadcastMessage, programName ) + pnsz + 1 );
Define broadcast message, add versioning.
2019-06-18 18:26:40 +00:00
return msg;
Broadcast protocol version and process name.
2019-06-17 16:34:35 +00:00
}
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
static DWORD s_profilerThreadId = 0;
Only handle selected subset of exceptions.
2018-08-20 00:06:59 +00:00
static char s_crashText[1024];
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
LONG WINAPI CrashFilter( PEXCEPTION_POINTERS pExp )
{
Don't handle crashes, if there's no connection.
2020-08-28 15:21:52 +00:00
if( !GetProfiler().IsConnected() ) return EXCEPTION_CONTINUE_SEARCH;
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
const unsigned ec = pExp->ExceptionRecord->ExceptionCode;
Only handle selected subset of exceptions.
2018-08-20 00:06:59 +00:00
auto msgPtr = s_crashText;
switch( ec )
{
case EXCEPTION_ACCESS_VIOLATION:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_ACCESS_VIOLATION (0x%x). ", ec );
switch( pExp->ExceptionRecord->ExceptionInformation[0] )
{
case 0:
Fixed compiler warnings.
2019-02-20 15:28:27 +00:00
msgPtr += sprintf( msgPtr, "Read violation at address 0x%" PRIxPTR ".", pExp->ExceptionRecord->ExceptionInformation[1] );
Only handle selected subset of exceptions.
2018-08-20 00:06:59 +00:00
break;
case 1:
Fixed compiler warnings.
2019-02-20 15:28:27 +00:00
msgPtr += sprintf( msgPtr, "Write violation at address 0x%" PRIxPTR ".", pExp->ExceptionRecord->ExceptionInformation[1] );
Only handle selected subset of exceptions.
2018-08-20 00:06:59 +00:00
break;
case 8:
Fixed compiler warnings.
2019-02-20 15:28:27 +00:00
msgPtr += sprintf( msgPtr, "DEP violation at address 0x%" PRIxPTR ".", pExp->ExceptionRecord->ExceptionInformation[1] );
Only handle selected subset of exceptions.
2018-08-20 00:06:59 +00:00
break;
default:
break;
}
break;
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_ARRAY_BOUNDS_EXCEEDED (0x%x). ", ec );
break;
case EXCEPTION_DATATYPE_MISALIGNMENT:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_DATATYPE_MISALIGNMENT (0x%x). ", ec );
break;
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_FLT_DIVIDE_BY_ZERO (0x%x). ", ec );
break;
case EXCEPTION_ILLEGAL_INSTRUCTION:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_ILLEGAL_INSTRUCTION (0x%x). ", ec );
break;
case EXCEPTION_IN_PAGE_ERROR:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_IN_PAGE_ERROR (0x%x). ", ec );
break;
case EXCEPTION_INT_DIVIDE_BY_ZERO:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_INT_DIVIDE_BY_ZERO (0x%x). ", ec );
break;
case EXCEPTION_PRIV_INSTRUCTION:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_PRIV_INSTRUCTION (0x%x). ", ec );
break;
case EXCEPTION_STACK_OVERFLOW:
msgPtr += sprintf( msgPtr, "Exception EXCEPTION_STACK_OVERFLOW (0x%x). ", ec );
break;
default:
return EXCEPTION_CONTINUE_SEARCH;
}
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
Send crash report.
2018-08-20 00:07:31 +00:00
{
Send callstacks before sending events they belong to.
2020-09-29 14:39:56 +00:00
GetProfiler().SendCallstack( 60, "KiUserExceptionDispatcher" );
Crash reports may be serialized.
2021-10-10 13:58:24 +00:00
TracyQueuePrepare( QueueType::CrashReport );
Send crash report.
2018-08-20 00:07:31 +00:00
item->crashReport.time = Profiler::GetTime();
item->crashReport.text = (uint64_t)s_crashText;
Crash reports may be serialized.
2021-10-10 13:58:24 +00:00
TracyQueueCommit( crashReportThread );
Send crash report.
2018-08-20 00:07:31 +00:00
}
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
HANDLE h = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 );
if( h == INVALID_HANDLE_VALUE ) return EXCEPTION_CONTINUE_SEARCH;
THREADENTRY32 te = { sizeof( te ) };
if( !Thread32First( h, &te ) )
{
CloseHandle( h );
return EXCEPTION_CONTINUE_SEARCH;
}
const auto pid = GetCurrentProcessId();
const auto tid = GetCurrentThreadId();
do
{
if( te.th32OwnerProcessID == pid && te.th32ThreadID != tid && te.th32ThreadID != s_profilerThreadId )
{
HANDLE th = OpenThread( THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID );
if( th != INVALID_HANDLE_VALUE )
{
SuspendThread( th );
CloseHandle( th );
}
}
}
while( Thread32Next( h, &te ) );
CloseHandle( h );
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::Crash );
TracyLfqCommit;
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
}
std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) );
Prevent direct access to s_profiler.
2019-02-19 17:38:08 +00:00
GetProfiler().RequestShutdown();
while( !GetProfiler().HasShutdownFinished() ) { std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); };
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
TerminateProcess( GetCurrentProcess(), 1 );
return EXCEPTION_CONTINUE_SEARCH;
}
#endif
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
#ifdef __linux__
static long s_profilerTid = 0;
static char s_crashText[1024];
Fun fact: two threads can crash at the same time.
2018-08-20 23:45:33 +00:00
static std::atomic<bool> s_alreadyCrashed( false );
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
Fixed compiler warnings.
2019-02-20 15:28:27 +00:00
static void ThreadFreezer( int /*signal*/ )
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
{
for(;;) sleep( 1000 );
}
static inline void HexPrint( char*& ptr, uint64_t val )
{
if( val == 0 )
{
*ptr++ = '0';
return;
}
static const char HexTable[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
char buf[16];
auto bptr = buf;
do
{
*bptr++ = HexTable[val%16];
val /= 16;
}
while( val > 0 );
do
{
*ptr++ = *--bptr;
}
while( bptr != buf );
}
Fixed compiler warnings.
2019-02-20 15:28:27 +00:00
static void CrashHandler( int signal, siginfo_t* info, void* /*ucontext*/ )
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
{
Fun fact: two threads can crash at the same time.
2018-08-20 23:45:33 +00:00
bool expected = false;
if( !s_alreadyCrashed.compare_exchange_strong( expected, true ) ) ThreadFreezer( signal );
Include SIGABRT in crash handling.
2021-02-07 18:04:48 +00:00
struct sigaction act = {};
act.sa_handler = SIG_DFL;
sigaction( SIGABRT, &act, nullptr );
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
auto msgPtr = s_crashText;
switch( signal )
{
case SIGILL:
strcpy( msgPtr, "Illegal Instruction.\n" );
while( *msgPtr ) msgPtr++;
switch( info->si_code )
{
case ILL_ILLOPC:
strcpy( msgPtr, "Illegal opcode.\n" );
break;
case ILL_ILLOPN:
strcpy( msgPtr, "Illegal operand.\n" );
break;
case ILL_ILLADR:
strcpy( msgPtr, "Illegal addressing mode.\n" );
break;
case ILL_ILLTRP:
strcpy( msgPtr, "Illegal trap.\n" );
break;
case ILL_PRVOPC:
strcpy( msgPtr, "Privileged opcode.\n" );
break;
case ILL_PRVREG:
strcpy( msgPtr, "Privileged register.\n" );
break;
case ILL_COPROC:
strcpy( msgPtr, "Coprocessor error.\n" );
break;
case ILL_BADSTK:
strcpy( msgPtr, "Internal stack error.\n" );
break;
default:
break;
}
break;
case SIGFPE:
strcpy( msgPtr, "Floating-point exception.\n" );
while( *msgPtr ) msgPtr++;
switch( info->si_code )
{
case FPE_INTDIV:
strcpy( msgPtr, "Integer divide by zero.\n" );
break;
case FPE_INTOVF:
strcpy( msgPtr, "Integer overflow.\n" );
break;
case FPE_FLTDIV:
strcpy( msgPtr, "Floating-point divide by zero.\n" );
break;
case FPE_FLTOVF:
strcpy( msgPtr, "Floating-point overflow.\n" );
break;
case FPE_FLTUND:
strcpy( msgPtr, "Floating-point underflow.\n" );
break;
case FPE_FLTRES:
strcpy( msgPtr, "Floating-point inexact result.\n" );
break;
case FPE_FLTINV:
strcpy( msgPtr, "Floating-point invalid operation.\n" );
break;
case FPE_FLTSUB:
strcpy( msgPtr, "Subscript out of range.\n" );
break;
default:
break;
}
break;
case SIGSEGV:
strcpy( msgPtr, "Invalid memory reference.\n" );
while( *msgPtr ) msgPtr++;
switch( info->si_code )
{
case SEGV_MAPERR:
strcpy( msgPtr, "Address not mapped to object.\n" );
break;
case SEGV_ACCERR:
strcpy( msgPtr, "Invalid permissions for mapped object.\n" );
break;
SEGV_{BND,PKU}ERR might not be defined.
2018-08-27 12:45:07 +00:00
# ifdef SEGV_BNDERR
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
case SEGV_BNDERR:
strcpy( msgPtr, "Failed address bound checks.\n" );
break;
SEGV_{BND,PKU}ERR might not be defined.
2018-08-27 12:45:07 +00:00
# endif
# ifdef SEGV_PKUERR
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
case SEGV_PKUERR:
strcpy( msgPtr, "Access was denied by memory protection keys.\n" );
break;
SEGV_{BND,PKU}ERR might not be defined.
2018-08-27 12:45:07 +00:00
# endif
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
default:
break;
}
break;
case SIGPIPE:
strcpy( msgPtr, "Broken pipe.\n" );
while( *msgPtr ) msgPtr++;
break;
case SIGBUS:
strcpy( msgPtr, "Bus error.\n" );
while( *msgPtr ) msgPtr++;
switch( info->si_code )
{
case BUS_ADRALN:
strcpy( msgPtr, "Invalid address alignment.\n" );
break;
case BUS_ADRERR:
strcpy( msgPtr, "Nonexistent physical address.\n" );
break;
case BUS_OBJERR:
strcpy( msgPtr, "Object-specific hardware error.\n" );
break;
Check if BUS_MCEERR_AR and BUS_MCEERR_AO are defined.
2020-02-12 00:27:03 +00:00
# ifdef BUS_MCEERR_AR
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
case BUS_MCEERR_AR:
strcpy( msgPtr, "Hardware memory error consumed on a machine check; action required.\n" );
break;
Check if BUS_MCEERR_AR and BUS_MCEERR_AO are defined.
2020-02-12 00:27:03 +00:00
# endif
# ifdef BUS_MCEERR_AO
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
case BUS_MCEERR_AO:
strcpy( msgPtr, "Hardware memory error detected in process but not consumed; action optional.\n" );
break;
Check if BUS_MCEERR_AR and BUS_MCEERR_AO are defined.
2020-02-12 00:27:03 +00:00
# endif
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
default:
break;
}
break;
Include SIGABRT in crash handling.
2021-02-07 18:04:48 +00:00
case SIGABRT:
strcpy( msgPtr, "Abort signal from abort().\n" );
break;
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
default:
abort();
}
while( *msgPtr ) msgPtr++;
if( signal != SIGPIPE )
{
strcpy( msgPtr, "Fault address: 0x" );
while( *msgPtr ) msgPtr++;
HexPrint( msgPtr, uint64_t( info->si_addr ) );
*msgPtr++ = '\n';
}
{
Send callstacks before sending events they belong to.
2020-09-29 14:39:56 +00:00
GetProfiler().SendCallstack( 60, "__kernel_rt_sigreturn" );
Crash reports may be serialized.
2021-10-10 13:58:24 +00:00
TracyQueuePrepare( QueueType::CrashReport );
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
item->crashReport.time = Profiler::GetTime();
item->crashReport.text = (uint64_t)s_crashText;
Crash reports may be serialized.
2021-10-10 13:58:24 +00:00
TracyQueueCommit( crashReportThread );
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
}
DIR* dp = opendir( "/proc/self/task" );
if( !dp ) abort();
const auto selfTid = syscall( SYS_gettid );
struct dirent* ep;
while( ( ep = readdir( dp ) ) != nullptr )
{
if( ep->d_name[0] == '.' ) continue;
int tid = atoi( ep->d_name );
if( tid != selfTid && tid != s_profilerTid )
{
syscall( SYS_tkill, tid, SIGPWR );
}
}
closedir( dp );
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::Crash );
TracyLfqCommit;
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
}
std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) );
Prevent direct access to s_profiler.
2019-02-19 17:38:08 +00:00
GetProfiler().RequestShutdown();
while( !GetProfiler().HasShutdownFinished() ) { std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); };
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
abort();
}
#endif
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
enum { QueuePrealloc = 256 * 1024 };
Add checker for profiler availability.
2020-06-23 23:32:57 +00:00
static Profiler* s_instance = nullptr;
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
static Thread* s_thread;
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#ifndef TRACY_NO_FRAME_IMAGE
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
static Thread* s_compressThread;
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#endif
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#ifdef TRACY_HAS_CALLSTACK
static Thread* s_symbolThread;
Signal symbol resolution thread destruction.
2021-10-22 23:46:00 +00:00
std::atomic<bool> s_symbolThreadGone { false };
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#endif
Add system tracing skeleton.
2019-08-12 18:08:15 +00:00
#ifdef TRACY_HAS_SYSTEM_TRACING
static Thread* s_sysTraceThread = nullptr;
#endif
Add checker for profiler availability.
2020-06-23 23:32:57 +00:00
TRACY_API bool ProfilerAvailable() { return s_instance != nullptr; }
Add QPC frequency query to API.
2020-07-07 19:24:44 +00:00
TRACY_API int64_t GetFrequencyQpc()
{
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Add QPC frequency query to API.
2020-07-07 19:24:44 +00:00
LARGE_INTEGER t;
QueryPerformanceFrequency( &t );
return t.QuadPart;
#else
return 0;
#endif
}
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
#ifdef TRACY_DELAYED_INIT
struct ThreadNameData;
Clean up imported functions in multi-dll projects.
2019-06-07 13:56:46 +00:00
TRACY_API moodycamel::ConcurrentQueue<QueueItem>& GetQueue();
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
struct ProfilerData
{
int64_t initTime = SetupHwTimer();
moodycamel::ConcurrentQueue<QueueItem> queue;
Profiler profiler;
Fix atomics initialization.
2019-05-27 12:09:55 +00:00
std::atomic<uint32_t> lockCounter { 0 };
std::atomic<uint8_t> gpuCtxCounter { 0 };
std::atomic<ThreadNameData*> threadNameData { nullptr };
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
};
Disallow direct access to s_token.
2019-02-19 17:27:00 +00:00
struct ProducerWrapper
{
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
ProducerWrapper( ProfilerData& data ) : detail( data.queue ), ptr( data.queue.get_explicit_producer( detail ) ) {}
moodycamel::ProducerToken detail;
Disallow direct access to s_token.
2019-02-19 17:27:00 +00:00
tracy::moodycamel::ConcurrentQueue<QueueItem>::ExplicitProducer* ptr;
};
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
struct ProfilerThreadData
{
ProfilerThreadData( ProfilerData& data ) : token( data ), gpuCtx( { nullptr } ) {}
ProducerWrapper token;
GpuCtxWrapper gpuCtx;
# ifdef TRACY_ON_DEMAND
LuaZoneState luaZoneState;
# endif
};
Fix rpmalloc init for TRACY_MANUAL_LIFETIME path.
2021-05-31 20:55:30 +00:00
std::atomic<int> RpInitDone { 0 };
std::atomic<int> RpInitLock { 0 };
thread_local bool RpThreadInitDone = false;
Fixing preprocessor formatting
2020-07-08 10:48:37 +00:00
# ifdef TRACY_MANUAL_LIFETIME
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
ProfilerData* s_profilerData = nullptr;
Multi Dll Proj will Crash, Under Unity (#244)
2021-07-25 09:28:42 +00:00
static ProfilerThreadData& GetProfilerThreadData();
Fixing functions case to match the source capitalization rules
2020-07-07 10:12:02 +00:00
TRACY_API void StartupProfiler()
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
{
Use rpmalloc for initialization-related allocations.
2021-04-10 11:02:32 +00:00
s_profilerData = (ProfilerData*)tracy_malloc( sizeof( ProfilerData ) );
new (s_profilerData) ProfilerData();
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
s_profilerData->profiler.SpawnWorkerThreads();
Multi Dll Proj will Crash, Under Unity (#244)
2021-07-25 09:28:42 +00:00
GetProfilerThreadData().token = ProducerWrapper( *s_profilerData );
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
}
static ProfilerData& GetProfilerData()
{
Multi Dll Proj will Crash, Under Unity (#244)
2021-07-25 09:28:42 +00:00
assert( s_profilerData );
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
return *s_profilerData;
}
Fixing functions case to match the source capitalization rules
2020-07-07 10:12:02 +00:00
TRACY_API void ShutdownProfiler()
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
{
Use rpmalloc for initialization-related allocations.
2021-04-10 11:02:32 +00:00
s_profilerData->~ProfilerData();
tracy_free( s_profilerData );
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
s_profilerData = nullptr;
Fixing crash on exit due to RP malloc not being deinitialized
2020-07-08 10:50:25 +00:00
rpmalloc_finalize();
Multi Dll Proj will Crash, Under Unity (#244)
2021-07-25 09:28:42 +00:00
RpThreadInitDone = false;
RpInitDone.store( 0, std::memory_order_release );
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
}
Fixing preprocessor formatting
2020-07-08 10:48:37 +00:00
# else
Make sure profiler is initialized only once in delayed init scenario.
2019-06-19 15:28:18 +00:00
static std::atomic<int> profilerDataLock { 0 };
static std::atomic<ProfilerData*> profilerData { nullptr };
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
static ProfilerData& GetProfilerData()
{
Make sure profiler is initialized only once in delayed init scenario.
2019-06-19 15:28:18 +00:00
auto ptr = profilerData.load( std::memory_order_acquire );
if( !ptr )
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
{
Make sure profiler is initialized only once in delayed init scenario.
2019-06-19 15:28:18 +00:00
int expected = 0;
Use weak compare, yield thread.
2021-05-31 00:22:13 +00:00
while( !profilerDataLock.compare_exchange_weak( expected, 1, std::memory_order_release, std::memory_order_relaxed ) ) { expected = 0; YieldThread(); }
Make sure profiler is initialized only once in delayed init scenario.
2019-06-19 15:28:18 +00:00
ptr = profilerData.load( std::memory_order_acquire );
if( !ptr )
{
Use rpmalloc for initialization-related allocations.
2021-04-10 11:02:32 +00:00
ptr = (ProfilerData*)tracy_malloc( sizeof( ProfilerData ) );
Make sure profiler is initialized only once in delayed init scenario.
2019-06-19 15:28:18 +00:00
new (ptr) ProfilerData();
profilerData.store( ptr, std::memory_order_release );
}
profilerDataLock.store( 0, std::memory_order_release );
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
}
Make sure profiler is initialized only once in delayed init scenario.
2019-06-19 15:28:18 +00:00
return *ptr;
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
}
Fixing preprocessor formatting
2020-07-08 10:48:37 +00:00
# endif
Increase queue preallocation size.
2017-09-24 13:59:53 +00:00
Fix centos shutdown crash
2021-04-09 18:51:16 +00:00
// GCC prior to 8.4 had a bug with function-inline thread_local variables. Versions of glibc beginning with
// 2.18 may attempt to work around this issue, which manifests as a crash while running static destructors
// if this function is compiled into a shared object. Unfortunately, centos7 ships with glibc 2.17. If running
// on old GCC, use the old-fashioned way as a workaround
// See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85400
#if defined(__GNUC__) && ((__GNUC__ < 8) || ((__GNUC__ == 8) && (__GNUC_MINOR__ < 4)))
struct ProfilerThreadDataKey
{
public:
ProfilerThreadDataKey()
{
int val = pthread_key_create(&m_key, sDestructor);
static_cast<void>(val); // unused
assert(val == 0);
}
~ProfilerThreadDataKey()
{
int val = pthread_key_delete(m_key);
static_cast<void>(val); // unused
assert(val == 0);
}
ProfilerThreadData& get()
{
void* p = pthread_getspecific(m_key);
if (!p)
{
Use tracy_malloc rather than 'new' in ProfilerThreadDataKey This codepath, involving a workaround for GCC < 8.4, called 'new' and 'delete' directly, which could cause infinite recursion when user-provided versions of those functions were themselves using Tracy functionality. Now, this codepath uses Tracy's internal allocator. See issues #194, #196
2021-04-11 23:40:24 +00:00
p = (ProfilerThreadData*)tracy_malloc( sizeof( ProfilerThreadData ) );
new (p) ProfilerThreadData(GetProfilerData());
Fix centos shutdown crash
2021-04-09 18:51:16 +00:00
pthread_setspecific(m_key, p);
}
return *static_cast<ProfilerThreadData*>(p);
}
private:
pthread_key_t m_key;
static void sDestructor(void* p)
{
Use tracy_malloc rather than 'new' in ProfilerThreadDataKey This codepath, involving a workaround for GCC < 8.4, called 'new' and 'delete' directly, which could cause infinite recursion when user-provided versions of those functions were themselves using Tracy functionality. Now, this codepath uses Tracy's internal allocator. See issues #194, #196
2021-04-11 23:40:24 +00:00
((ProfilerThreadData*)p)->~ProfilerThreadData();
tracy_free(p);
Fix centos shutdown crash
2021-04-09 18:51:16 +00:00
}
};
static ProfilerThreadData& GetProfilerThreadData()
{
static ProfilerThreadDataKey key;
return key.get();
}
#else
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
static ProfilerThreadData& GetProfilerThreadData()
{
thread_local ProfilerThreadData data( GetProfilerData() );
return data;
}
Fix centos shutdown crash
2021-04-09 18:51:16 +00:00
#endif
Automatically create profiler instance.
2017-09-18 17:08:54 +00:00
Clean up imported functions in multi-dll projects.
2019-06-07 13:56:46 +00:00
TRACY_API moodycamel::ConcurrentQueue<QueueItem>::ExplicitProducer* GetToken() { return GetProfilerThreadData().token.ptr; }
TRACY_API Profiler& GetProfiler() { return GetProfilerData().profiler; }
TRACY_API moodycamel::ConcurrentQueue<QueueItem>& GetQueue() { return GetProfilerData().queue; }
TRACY_API int64_t GetInitTime() { return GetProfilerData().initTime; }
TRACY_API std::atomic<uint32_t>& GetLockCounter() { return GetProfilerData().lockCounter; }
TRACY_API std::atomic<uint8_t>& GetGpuCtxCounter() { return GetProfilerData().gpuCtxCounter; }
TRACY_API GpuCtxWrapper& GetGpuCtx() { return GetProfilerThreadData().gpuCtx; }
Change thread id size from 64 to 32 bits. Both Windows and Linux use 32-bit thread identifiers. MacOS has a 64-bit counter, but in practice it will never overflow during profiling and no false aliasing will happen. These changes are only done client-side and in the network protocol. The server still uses 64-bit thread identifiers, to enable virtual threads, etc.
2021-10-07 22:42:52 +00:00
TRACY_API uint32_t GetThreadHandle() { return detail::GetThreadHandleImpl(); }
Move Set/GetThreadName() to Tracy API.
2020-01-25 15:17:03 +00:00
std::atomic<ThreadNameData*>& GetThreadNameData() { return GetProfilerData().threadNameData; }
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# ifdef TRACY_ON_DEMAND
Clean up imported functions in multi-dll projects.
2019-06-07 13:56:46 +00:00
TRACY_API LuaZoneState& GetLuaZoneState() { return GetProfilerThreadData().luaZoneState; }
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# endif
Replacing removing spinlock that is not needed anymore, making `TRACY_MANUAL_LIFETIME` a sub-option of `TRACY_DELAYED_INIT`, and addressing feedback
2020-07-12 17:04:07 +00:00
# ifndef TRACY_MANUAL_LIFETIME
Auto-initialize profiler in delayed init scenario.
2020-05-19 11:55:54 +00:00
namespace
{
const auto& __profiler_init = GetProfiler();
}
Fixing preprocessor formatting
2020-07-08 10:48:37 +00:00
# endif
Auto-initialize profiler in delayed init scenario.
2020-05-19 11:55:54 +00:00
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
#else
// MSVC static initialization order solution. gcc/clang uses init_order() to avoid all this.
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
Initialize tracy before anything else.
2017-10-16 22:36:15 +00:00
// 1a. But s_queue is needed for initialization of variables in point 2.
extern moodycamel::ConcurrentQueue<QueueItem> s_queue;
// 2. If these variables would be in the .CRT$XCB section, they would be initialized only in main thread.
thread_local implies static.
2019-02-19 13:46:24 +00:00
thread_local moodycamel::ProducerToken init_order(107) s_token_detail( s_queue );
Lock counter also must be initialized early.
2017-10-24 20:02:49 +00:00
thread_local ProducerWrapper init_order(108) s_token { s_queue.get_explicit_producer( s_token_detail ) };
Proper init order of thread local thread handle.
2019-06-26 17:32:52 +00:00
thread_local ThreadHandleWrapper init_order(104) s_threadHandle { detail::GetThreadHandleImpl() };
Initialize tracy before anything else.
2017-10-16 22:36:15 +00:00
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# ifdef _MSC_VER
Initialize tracy before anything else.
2017-10-16 22:36:15 +00:00
// 1. Initialize these static variables before all other variables.
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# pragma warning( disable : 4075 )
# pragma init_seg( ".CRT$XCB" )
# endif
Initialize tracy before anything else.
2017-10-16 22:36:15 +00:00
Test if HW timer can be used on arm.
2018-04-27 14:58:45 +00:00
static InitTimeWrapper init_order(101) s_initTime { SetupHwTimer() };
Check if rpmalloc has to be initialized before each operation. The C++11 spec states in [basic.stc.thread] thread storage duration: 2. A variable with thread storage duration shall be initialized before its first odr-use (3.2) and, if constructed, shall be destroyed on thread exit. Previously Tracy relied on the TLS data being initialized: - During thread creation (MSVC). - Or during first use in a thread, but the initialization was performed for the whole TLS block. It seems that new compilers are more granular with how they perform the initialization, hence rpmalloc init has to be checked before each allocation, as it cannot be "folded" into, for example, initialization of the profiler itself.
2021-05-31 00:30:59 +00:00
std::atomic<int> init_order(102) RpInitDone( 0 );
std::atomic<int> init_order(102) RpInitLock( 0 );
Hide rpmalloc init behind thread local boolean.
2021-05-31 20:38:22 +00:00
thread_local bool RpThreadInitDone = false;
Measure time of initialization start.
2017-10-16 23:07:34 +00:00
moodycamel::ConcurrentQueue<QueueItem> init_order(103) s_queue( QueuePrealloc );
Lock counter also must be initialized early.
2017-10-24 20:02:49 +00:00
std::atomic<uint32_t> init_order(104) s_lockCounter( 0 );
GPU context counter is now 8 bit.
2018-06-22 13:10:23 +00:00
std::atomic<uint8_t> init_order(104) s_gpuCtxCounter( 0 );
Manual collection of thread names on android.
2017-10-30 19:45:00 +00:00
Workaround gcc issues.
2017-11-14 22:29:48 +00:00
thread_local GpuCtxWrapper init_order(104) s_gpuCtx { nullptr };
Simplify GPU context handling.
2017-11-13 23:48:26 +00:00
Manual collection of thread names on android.
2017-10-30 19:45:00 +00:00
struct ThreadNameData;
Made s_threadNameDataInstance and s_profilerInstance static.
2018-07-31 11:03:09 +00:00
static std::atomic<ThreadNameData*> init_order(104) s_threadNameDataInstance( nullptr );
Support for multi-DLL projects.
2018-07-30 16:12:42 +00:00
std::atomic<ThreadNameData*>& s_threadNameData = s_threadNameDataInstance;
Manual collection of thread names on android.
2017-10-30 19:45:00 +00:00
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# ifdef TRACY_ON_DEMAND
Fix lua zone state init.
2018-07-13 18:20:37 +00:00
thread_local LuaZoneState init_order(104) s_luaZoneState { 0, false };
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# endif
Implement on-demand Lua zone capture.
2018-07-12 10:53:35 +00:00
Prevent direct access to s_profiler.
2019-02-19 17:38:08 +00:00
static Profiler init_order(105) s_profiler;
Support for multi-DLL projects.
2018-07-30 16:12:42 +00:00
Clean up imported functions in multi-dll projects.
2019-06-07 13:56:46 +00:00
TRACY_API moodycamel::ConcurrentQueue<QueueItem>::ExplicitProducer* GetToken() { return s_token.ptr; }
TRACY_API Profiler& GetProfiler() { return s_profiler; }
TRACY_API moodycamel::ConcurrentQueue<QueueItem>& GetQueue() { return s_queue; }
TRACY_API int64_t GetInitTime() { return s_initTime.val; }
TRACY_API std::atomic<uint32_t>& GetLockCounter() { return s_lockCounter; }
TRACY_API std::atomic<uint8_t>& GetGpuCtxCounter() { return s_gpuCtxCounter; }
TRACY_API GpuCtxWrapper& GetGpuCtx() { return s_gpuCtx; }
Change thread id size from 64 to 32 bits. Both Windows and Linux use 32-bit thread identifiers. MacOS has a 64-bit counter, but in practice it will never overflow during profiling and no false aliasing will happen. These changes are only done client-side and in the network protocol. The server still uses 64-bit thread identifiers, to enable virtual threads, etc.
2021-10-07 22:42:52 +00:00
TRACY_API uint32_t GetThreadHandle() { return s_threadHandle.val; }
Disallow direct access to s_token.
2019-02-19 17:27:00 +00:00
Move Set/GetThreadName() to Tracy API.
2020-01-25 15:17:03 +00:00
std::atomic<ThreadNameData*>& GetThreadNameData() { return s_threadNameData; }
Support for multi-DLL projects.
2018-07-30 16:12:42 +00:00
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# ifdef TRACY_ON_DEMAND
Clean up imported functions in multi-dll projects.
2019-06-07 13:56:46 +00:00
TRACY_API LuaZoneState& GetLuaZoneState() { return s_luaZoneState; }
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# endif
Hide rest of statics.
2019-02-19 18:33:37 +00:00
#endif
Fix DLL code.
2019-02-19 17:45:41 +00:00
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
Profiler::Profiler()
More precise profiler init end time measurement.
2017-10-16 23:07:54 +00:00
: m_timeBegin( 0 )
GetThreadHandle() might be used by application's code.
2019-06-25 13:44:49 +00:00
, m_mainThread( detail::GetThreadHandleImpl() )
Send program start time, not connection time.
2017-10-03 22:34:05 +00:00
, m_epoch( std::chrono::duration_cast<std::chrono::seconds>( std::chrono::system_clock::now().time_since_epoch() ).count() )
Store profiling start time.
2017-09-10 18:14:16 +00:00
, m_shutdown( false )
In case of manual shutdown, don't wait for lock. All threads are freezed at this point, nothing will release it.
2018-08-20 19:49:23 +00:00
, m_shutdownManual( false )
Allow external profiler shutdown requests.
2018-08-19 23:02:27 +00:00
, m_shutdownFinished( false )
Manual allocation of socket memory.
2017-10-18 17:49:17 +00:00
, m_sock( nullptr )
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
, m_broadcast( nullptr )
Support TRACY_NO_EXIT env variable in addition to define.
2018-07-13 21:55:40 +00:00
, m_noExit( false )
Allow specification of port through env variable.
2020-03-08 15:14:36 +00:00
, m_userPort( 0 )
Track zone id for verification purposes.
2019-01-14 21:23:24 +00:00
, m_zoneId( 1 )
Store sampling period.
2020-02-25 22:08:52 +00:00
, m_samplingPeriod( 0 )
Use stream compression. Previously each data packet was compressed independently. After this change all new packets reference the previously sent data, which achieves better compression.
2017-09-17 11:10:42 +00:00
, m_stream( LZ4_createStream() )
Use rpmalloc to allocate tracy client memory.
2017-10-14 15:15:18 +00:00
, m_buffer( (char*)tracy_malloc( TargetFrameSize*3 ) )
Use stream compression. Previously each data packet was compressed independently. After this change all new packets reference the previously sent data, which achieves better compression.
2017-09-17 11:10:42 +00:00
, m_bufferOffset( 0 )
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
, m_bufferStart( 0 )
Move another big buffer out of stack.
2017-11-02 16:37:10 +00:00
, m_lz4Buf( (char*)tracy_malloc( LZ4Size + sizeof( lz4sz_t ) ) )
Add serial queue to profiler.
2018-04-01 17:53:05 +00:00
, m_serialQueue( 1024*1024 )
Don't hold lock on serial queue during dequeue.
2018-04-14 13:46:11 +00:00
, m_serialDequeue( 1024*1024 )
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#ifndef TRACY_NO_FRAME_IMAGE
Revert "Use SPSC queue for frame images." This reverts commit 02e76faff7a17a907457078997c42c1b0d6b0f0f. Let's not limit frame image reporting to just one thread.
2021-10-20 21:18:03 +00:00
, m_fiQueue( 16 )
, m_fiDequeue( 16 )
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#endif
Decrease number of SPSCQueue items to 8K. This matches the query limit set on the server.
2021-11-14 17:51:11 +00:00
, m_symbolQueue( 8*1024 )
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
, m_frameCount( 0 )
Track connection status.
2018-07-10 19:50:00 +00:00
, m_isConnected( false )
Expose m_isConnected in non-on-demand builds.
2020-07-16 09:22:06 +00:00
#ifdef TRACY_ON_DEMAND
Add connection id for on-demand mode. Long-lived zones could send their end events without begin events in a following scenario: 1. On-demand connection is made. 2. Zone begin is emitted, m_active is set to true. 3. Connection is terminated. 4. A new connection is made. 5. Zone end is emitted, because m_active is true. To this point it was assumed that all zone end events will happen before a new connection is made, but it's not necessarily true.
2019-06-09 15:15:47 +00:00
, m_connectionId( 0 )
Add deferred events queue.
2018-07-11 10:14:28 +00:00
, m_deferredQueue( 64*1024 )
Track connection status.
2018-07-10 19:50:00 +00:00
#endif
Implement setting client parameters from server.
2019-11-25 22:59:48 +00:00
, m_paramCallback( nullptr )
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
, m_queryData( nullptr )
Crash handler may be not installed.
2021-07-25 09:46:20 +00:00
, m_crashHandlerInstalled( false )
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
{
assert( !s_instance );
s_instance = this;
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
#ifndef TRACY_DELAYED_INIT
# ifdef _MSC_VER
Initialize tracy before anything else.
2017-10-16 22:36:15 +00:00
// 3. But these variables need to be initialized in main thread within the .CRT$XCB section. Do it here.
s_token_detail = moodycamel::ProducerToken( s_queue );
s_token = ProducerWrapper { s_queue.get_explicit_producer( s_token_detail ) };
Proper init order of thread local thread handle.
2019-06-26 17:32:52 +00:00
s_threadHandle = ThreadHandleWrapper { m_mainThread };
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
# endif
Initialize tracy before anything else.
2017-10-16 22:36:15 +00:00
#endif
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
CalibrateTimer();
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
CalibrateDelay();
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
ReportTopology();
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
Support TRACY_NO_EXIT env variable in addition to define.
2018-07-13 21:55:40 +00:00
#ifndef TRACY_NO_EXIT
PR feedback
2021-04-09 22:33:01 +00:00
const char* noExitEnv = GetEnvVar( "TRACY_NO_EXIT" );
Support TRACY_NO_EXIT env variable in addition to define.
2018-07-13 21:55:40 +00:00
if( noExitEnv && noExitEnv[0] == '1' )
{
m_noExit = true;
}
#endif
PR feedback
2021-04-09 22:33:01 +00:00
const char* userPort = GetEnvVar( "TRACY_PORT" );
Allow specification of port through env variable.
2020-03-08 15:14:36 +00:00
if( userPort )
{
m_userPort = atoi( userPort );
}
Fixing some of the copy-paste errors
2020-07-12 17:12:50 +00:00
#if !defined(TRACY_DELAYED_INIT) || !defined(TRACY_MANUAL_LIFETIME)
Adding manual lifetime management to aid multi-DLL usecase
2020-07-07 07:39:09 +00:00
SpawnWorkerThreads();
#endif
}
void Profiler::SpawnWorkerThreads()
{
Add system tracing skeleton.
2019-08-12 18:08:15 +00:00
#ifdef TRACY_HAS_SYSTEM_TRACING
Store sampling period.
2020-02-25 22:08:52 +00:00
if( SysTraceStart( m_samplingPeriod ) )
Add system tracing skeleton.
2019-08-12 18:08:15 +00:00
{
s_sysTraceThread = (Thread*)tracy_malloc( sizeof( Thread ) );
new(s_sysTraceThread) Thread( SysTraceWorker, nullptr );
Sleep to force rescheduling main thread during init. This fixes problems with first context switch data region possibly not being available for the main thread, if no rescheduling was performed after sys tracing has started.
2020-04-14 20:43:23 +00:00
std::this_thread::sleep_for( std::chrono::milliseconds( 1 ) );
Add system tracing skeleton.
2019-08-12 18:08:15 +00:00
}
#endif
Setup system tracing before launching profiler threads. This makes sure that profiler threads are properly included in sample data on Linux. This was previously working because sample capture was performed system-wide. Now samples are only captured in client context, which includes all spawned threads. Since this inclusion only works for threads which will be spawned after the trace starts, no thread can be created before sampling setup is done.
2021-06-04 12:07:46 +00:00
s_thread = (Thread*)tracy_malloc( sizeof( Thread ) );
new(s_thread) Thread( LaunchWorker, this );
#ifndef TRACY_NO_FRAME_IMAGE
s_compressThread = (Thread*)tracy_malloc( sizeof( Thread ) );
new(s_compressThread) Thread( LaunchCompressWorker, this );
#endif
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#ifdef TRACY_HAS_CALLSTACK
s_symbolThread = (Thread*)tracy_malloc( sizeof( Thread ) );
new(s_symbolThread) Thread( LaunchSymbolWorker, this );
#endif
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Native threads are used on mingw.
2019-11-07 18:01:42 +00:00
s_profilerThreadId = GetThreadId( s_thread->Handle() );
Remove exception handler during profiler destruction.
2021-07-25 09:48:27 +00:00
m_exceptionHandler = AddVectoredExceptionHandler( 1, CrashFilter );
Handle crashes on windows. When a crash happens, put all threads (bar the profiler and crash handling ones) into the freezer, send crash notification message, request profiler shutdown and when it does, terminate process. The list of ignored exceptions is sorta-kinda random at the moment and may need further expansion.
2018-08-19 23:05:09 +00:00
#endif
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
#ifdef __linux__
struct sigaction threadFreezer = {};
threadFreezer.sa_handler = ThreadFreezer;
Restore original signal handlers on profiler exit.
2021-07-25 09:40:22 +00:00
sigaction( SIGPWR, &threadFreezer, &m_prevSignal.pwr );
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
struct sigaction crashHandler = {};
crashHandler.sa_sigaction = CrashHandler;
crashHandler.sa_flags = SA_SIGINFO;
Restore original signal handlers on profiler exit.
2021-07-25 09:40:22 +00:00
sigaction( SIGILL, &crashHandler, &m_prevSignal.ill );
sigaction( SIGFPE, &crashHandler, &m_prevSignal.fpe );
sigaction( SIGSEGV, &crashHandler, &m_prevSignal.segv );
sigaction( SIGPIPE, &crashHandler, &m_prevSignal.pipe );
sigaction( SIGBUS, &crashHandler, &m_prevSignal.bus );
sigaction( SIGABRT, &crashHandler, &m_prevSignal.abrt );
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
#endif
Crash handler may be not installed.
2021-07-25 09:46:20 +00:00
m_crashHandlerInstalled = true;
Windows callstack inspection plumbing.
2018-06-18 23:17:19 +00:00
#ifdef TRACY_HAS_CALLSTACK
InitCallstack();
#endif
Add no-cpu GetTime() variant. In this version the address of cpu output variable is const, so there's no stack address calculation involved.
2017-10-29 15:12:16 +00:00
m_timeBegin.store( GetTime(), std::memory_order_relaxed );
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
}
Profiler::~Profiler()
{
s_instance ptr may be accessed by thread.
2017-09-13 21:36:40 +00:00
m_shutdown.store( true, std::memory_order_relaxed );
Add system tracing skeleton.
2019-08-12 18:08:15 +00:00
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Remove exception handler during profiler destruction.
2021-07-25 09:48:27 +00:00
if( m_crashHandlerInstalled ) RemoveVectoredExceptionHandler( m_exceptionHandler );
#endif
Restore original signal handlers on profiler exit.
2021-07-25 09:40:22 +00:00
#ifdef __linux__
Crash handler may be not installed.
2021-07-25 09:46:20 +00:00
if( m_crashHandlerInstalled )
{
sigaction( SIGPWR, &m_prevSignal.pwr, nullptr );
sigaction( SIGILL, &m_prevSignal.ill, nullptr );
sigaction( SIGFPE, &m_prevSignal.fpe, nullptr );
sigaction( SIGSEGV, &m_prevSignal.segv, nullptr );
sigaction( SIGPIPE, &m_prevSignal.pipe, nullptr );
sigaction( SIGBUS, &m_prevSignal.bus, nullptr );
sigaction( SIGABRT, &m_prevSignal.abrt, nullptr );
}
Restore original signal handlers on profiler exit.
2021-07-25 09:40:22 +00:00
#endif
Add system tracing skeleton.
2019-08-12 18:08:15 +00:00
#ifdef TRACY_HAS_SYSTEM_TRACING
if( s_sysTraceThread )
{
SysTraceStop();
s_sysTraceThread->~Thread();
tracy_free( s_sysTraceThread );
}
#endif
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#ifdef TRACY_HAS_CALLSTACK
s_symbolThread->~Thread();
tracy_free( s_symbolThread );
Signal symbol resolution thread destruction.
2021-10-22 23:46:00 +00:00
s_symbolThreadGone.store( true, std::memory_order_release );
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#endif
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#ifndef TRACY_NO_FRAME_IMAGE
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
s_compressThread->~Thread();
tracy_free( s_compressThread );
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#endif
Use custom threading wrapper instead of std::thread. std::thread may perform memory allocation when a thread is created (it does so on MSVC). Tracy heap is managed by its own allocator and this changes prevents accessing application heap.
2017-10-16 19:13:57 +00:00
s_thread->~Thread();
tracy_free( s_thread );
s_instance ptr may be accessed by thread.
2017-09-13 21:36:40 +00:00
Move another big buffer out of stack.
2017-11-02 16:37:10 +00:00
tracy_free( m_lz4Buf );
Use rpmalloc to allocate tracy client memory.
2017-10-14 15:15:18 +00:00
tracy_free( m_buffer );
Don't include LZ4 headers in tracy headers. The LZ4 implementation is wrapped in tracy namespace, but it also adds some defines, which may conflict with other LZ4 implementations.
2019-05-01 10:57:42 +00:00
LZ4_freeStream( (LZ4_stream_t*)m_stream );
Use stream compression. Previously each data packet was compressed independently. After this change all new packets reference the previously sent data, which achieves better compression.
2017-09-17 11:10:42 +00:00
Manual allocation of socket memory.
2017-10-18 17:49:17 +00:00
if( m_sock )
{
m_sock->~Socket();
tracy_free( m_sock );
}
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
if( m_broadcast )
{
m_broadcast->~UdpBroadcast();
tracy_free( m_broadcast );
}
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
assert( s_instance );
s_instance = nullptr;
}
Mirror TracyView::ShouldExit in TracyProfiler.
2017-09-14 17:23:50 +00:00
bool Profiler::ShouldExit()
{
return s_instance->m_shutdown.load( std::memory_order_relaxed );
}
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
void Profiler::Worker()
{
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
#ifdef __linux__
s_profilerTid = syscall( SYS_gettid );
#endif
Fixing crash on exit due to RP malloc not being deinitialized
2020-07-08 10:50:25 +00:00
ThreadExitHandler threadExitHandler;
SetThreadName() only works on the current thread. This breaking change is required, because kernel trace facilities use kernel thread ids, which are inaccessible from the pthread_t level.
2019-08-14 00:22:45 +00:00
SetThreadName( "Tracy Profiler" );
Separate config for data and broadcast port.
2020-03-08 13:34:09 +00:00
#ifdef TRACY_DATA_PORT
Search for free listen port, if default is occupied.
2020-04-13 19:40:52 +00:00
const bool dataPortSearch = false;
auto dataPort = m_userPort != 0 ? m_userPort : TRACY_DATA_PORT;
Separate config for data and broadcast port.
2020-03-08 13:34:09 +00:00
#else
Search for free listen port, if default is occupied.
2020-04-13 19:40:52 +00:00
const bool dataPortSearch = m_userPort == 0;
auto dataPort = m_userPort != 0 ? m_userPort : 8086;
Separate config for data and broadcast port.
2020-03-08 13:34:09 +00:00
#endif
#ifdef TRACY_BROADCAST_PORT
const auto broadcastPort = TRACY_BROADCAST_PORT;
Allow changing tracy port in client.
2019-09-21 13:11:15 +00:00
#else
Separate config for data and broadcast port.
2020-03-08 13:34:09 +00:00
const auto broadcastPort = 8086;
Allow changing tracy port in client.
2019-09-21 13:11:15 +00:00
#endif
Fix races in rpmalloc initialization. Ensure rpmalloc_thread_initialize() int worker threads is called only after rpmalloc_initialize() was called on the main profiler thread.
2019-07-19 17:25:27 +00:00
while( m_timeBegin.load( std::memory_order_relaxed ) == 0 ) std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
Initialize rpmalloc in profiler worker thread. Thread local variables on gcc are apparently not initialized on thread startup, but on first access to thread local variables block. Previously it was working, because s_token was accessed before any rpmalloc allocation could be performed. Now the first rpmalloc allocation is the Socket class, and rpmalloc is not initialized there, as there was no thread local access yet.
2017-10-18 21:30:54 +00:00
rpmalloc_thread_initialize();
Check mtime of profiled executable.
2021-01-31 16:42:44 +00:00
m_exectime = 0;
const auto execname = GetProcessExecutablePath();
if( execname )
{
struct stat st;
if( stat( execname, &st ) == 0 )
{
m_exectime = (uint64_t)st.st_mtime;
}
}
No need to get process name more than once.
2017-10-17 19:53:09 +00:00
const auto procname = GetProcessName();
const auto pnsz = std::min<size_t>( strlen( procname ), WelcomeMessageProgramNameSize - 1 );
Host info discovery.
2018-08-19 16:15:14 +00:00
const auto hostinfo = GetHostInfo();
Send host info in welcome message.
2018-08-19 16:19:12 +00:00
const auto hisz = std::min<size_t>( strlen( hostinfo ), WelcomeMessageHostInfoSize - 1 );
Host info discovery.
2018-08-19 16:15:14 +00:00
Transfer PID of profiled program.
2019-08-17 20:19:04 +00:00
const uint64_t pid = GetPid();
Combine flags in welcome message.
2021-06-14 23:26:50 +00:00
uint8_t flags = 0;
Send on-demand status in welcome message.
2018-07-10 19:44:23 +00:00
#ifdef TRACY_ON_DEMAND
Combine flags in welcome message.
2021-06-14 23:26:50 +00:00
flags |= WelcomeFlag::OnDemand;
Send on-demand status in welcome message.
2018-07-10 19:44:23 +00:00
#endif
Indicate whether client is running on apple shitware.
2019-06-13 12:05:15 +00:00
#ifdef __APPLE__
Combine flags in welcome message.
2021-06-14 23:26:50 +00:00
flags |= WelcomeFlag::IsApple;
#endif
#ifndef TRACY_NO_CODE_TRANSFER
flags |= WelcomeFlag::CodeTransfer;
Indicate whether client is running on apple shitware.
2019-06-13 12:05:15 +00:00
#endif
Set combine samples flag on win32.
2021-06-14 23:32:18 +00:00
#ifdef _WIN32
flags |= WelcomeFlag::CombineSamples;
#endif
Indicate whether client is running on apple shitware.
2019-06-13 12:05:15 +00:00
Report CPU architecture in welcome message.
2020-03-25 20:28:02 +00:00
#if defined __i386 || defined _M_IX86
uint8_t cpuArch = CpuArchX86;
#elif defined __x86_64__ || defined _M_X64
uint8_t cpuArch = CpuArchX64;
#elif defined __aarch64__
uint8_t cpuArch = CpuArchArm64;
#elif defined __ARM_ARCH
uint8_t cpuArch = CpuArchArm32;
#else
uint8_t cpuArch = CpuArchUnknown;
#endif
Send x86 processor info in welcome message.
2020-05-06 16:57:05 +00:00
#if defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64
uint32_t regs[4];
char manufacturer[12];
CpuId( regs, 0 );
memcpy( manufacturer, regs+1, 4 );
memcpy( manufacturer+4, regs+3, 4 );
memcpy( manufacturer+8, regs+2, 4 );
CpuId( regs, 1 );
uint32_t cpuId = ( regs[0] & 0xFFF ) | ( ( regs[0] & 0xFFF0000 ) >> 4 );
#else
const char manufacturer[12] = {};
uint32_t cpuId = 0;
#endif
Also no need to construct more than one welcome message.
2017-10-17 19:55:40 +00:00
WelcomeMessage welcome;
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
MemWrite( &welcome.timerMul, m_timerMul );
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
MemWrite( &welcome.initBegin, GetInitTime() );
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
MemWrite( &welcome.initEnd, m_timeBegin.load( std::memory_order_relaxed ) );
MemWrite( &welcome.delay, m_delay );
MemWrite( &welcome.resolution, m_resolution );
MemWrite( &welcome.epoch, m_epoch );
Send executable mtime in welcome message.
2021-01-31 16:45:11 +00:00
MemWrite( &welcome.exectime, m_exectime );
Transfer PID of profiled program.
2019-08-17 20:19:04 +00:00
MemWrite( &welcome.pid, pid );
Send sampling period in welcome message.
2020-02-25 22:12:31 +00:00
MemWrite( &welcome.samplingPeriod, m_samplingPeriod );
Combine flags in welcome message.
2021-06-14 23:26:50 +00:00
MemWrite( &welcome.flags, flags );
Report CPU architecture in welcome message.
2020-03-25 20:28:02 +00:00
MemWrite( &welcome.cpuArch, cpuArch );
Send x86 processor info in welcome message.
2020-05-06 16:57:05 +00:00
memcpy( welcome.cpuManufacturer, manufacturer, 12 );
MemWrite( &welcome.cpuId, cpuId );
Also no need to construct more than one welcome message.
2017-10-17 19:55:40 +00:00
memcpy( welcome.programName, procname, pnsz );
memset( welcome.programName + pnsz, 0, WelcomeMessageProgramNameSize - pnsz );
Send host info in welcome message.
2018-08-19 16:19:12 +00:00
memcpy( welcome.hostInfo, hostinfo, hisz );
memset( welcome.hostInfo + hisz, 0, WelcomeMessageHostInfoSize - hisz );
Also no need to construct more than one welcome message.
2017-10-17 19:55:40 +00:00
Hide rest of statics.
2019-02-19 18:33:37 +00:00
moodycamel::ConsumerToken token( GetQueue() );
Dequeue events (and do nothing with them).
2017-09-10 18:23:06 +00:00
Send event data over network.
2017-09-11 20:51:47 +00:00
ListenSocket listen;
Search for free listen port, if default is occupied.
2020-04-13 19:40:52 +00:00
bool isListening = false;
if( !dataPortSearch )
{
isListening = listen.Listen( dataPort, 4 );
}
else
{
for( uint32_t i=0; i<20; i++ )
{
if( listen.Listen( dataPort+i, 4 ) )
{
dataPort += i;
isListening = true;
break;
}
}
}
if( !isListening )
Flush queues when opening listen socket fails.
2018-12-21 17:14:30 +00:00
{
for(;;)
{
if( ShouldExit() )
{
m_shutdownFinished.store( true, std::memory_order_relaxed );
return;
}
ClearQueues( token );
Sleep when clearing queues if listen port is occupied.
2020-04-04 19:08:13 +00:00
std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
Flush queues when opening listen socket fails.
2018-12-21 17:14:30 +00:00
}
}
Send event data over network.
2017-09-11 20:51:47 +00:00
Disable broadcast if TRACY_NO_BROADCAST is defined.
2019-06-17 16:18:58 +00:00
#ifndef TRACY_NO_BROADCAST
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
m_broadcast = (UdpBroadcast*)tracy_malloc( sizeof( UdpBroadcast ) );
new(m_broadcast) UdpBroadcast();
Broadcast to localhost if listening only on localhost.
2020-12-16 14:24:33 +00:00
# ifdef TRACY_ONLY_LOCALHOST
const char* addr = "127.255.255.255";
# else
const char* addr = "255.255.255.255";
# endif
if( !m_broadcast->Open( addr, broadcastPort ) )
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
{
m_broadcast->~UdpBroadcast();
tracy_free( m_broadcast );
m_broadcast = nullptr;
}
Disable broadcast if TRACY_NO_BROADCAST is defined.
2019-06-17 16:18:58 +00:00
#endif
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
Define broadcast message, add versioning.
2019-06-18 18:26:40 +00:00
int broadcastLen = 0;
Send listen port in broadcast message.
2020-03-08 13:37:59 +00:00
auto& broadcastMsg = GetBroadcastMessage( procname, pnsz, broadcastLen, dataPort );
Define broadcast message, add versioning.
2019-06-18 18:26:40 +00:00
uint64_t lastBroadcast = 0;
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Connections loop.
// Each iteration of the loop handles whole connection. Multiple iterations will only
// happen in the on-demand mode or when handshake fails.
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
for(;;)
{
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Wait for incoming connection
Send event data over network.
2017-09-11 20:51:47 +00:00
for(;;)
Dequeue events (and do nothing with them).
2017-09-10 18:23:06 +00:00
{
Add TRACY_NO_EXIT macro.
2017-10-18 18:01:12 +00:00
#ifndef TRACY_NO_EXIT
Allow external profiler shutdown requests.
2018-08-19 23:02:27 +00:00
if( !m_noExit && ShouldExit() )
{
Notify servers that client is no longer listening for connections. This happens in these two cases: - The client is exiting. - A connection attempt is performed. This message type is indicated by negative time value.
2020-09-20 20:19:10 +00:00
if( m_broadcast )
{
broadcastMsg.activeTime = -1;
m_broadcast->Send( broadcastPort, &broadcastMsg, broadcastLen );
}
Allow external profiler shutdown requests.
2018-08-19 23:02:27 +00:00
m_shutdownFinished.store( true, std::memory_order_relaxed );
return;
}
Add TRACY_NO_EXIT macro.
2017-10-18 18:01:12 +00:00
#endif
Move sending data to a separate function.
2017-09-14 17:07:56 +00:00
m_sock = listen.Accept();
if( m_sock ) break;
Collect system time before server connection is made.
2019-02-24 18:12:17 +00:00
#ifndef TRACY_ON_DEMAND
ProcessSysTime();
#endif
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
if( m_broadcast )
{
Broadcast client activity time.
2019-06-18 18:46:12 +00:00
const auto t = std::chrono::high_resolution_clock::now().time_since_epoch().count();
Don't need to keep last broadcast time in Profiler class.
2019-06-18 18:15:09 +00:00
if( t - lastBroadcast > 3000000000 ) // 3s
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
{
Don't need to keep last broadcast time in Profiler class.
2019-06-18 18:15:09 +00:00
lastBroadcast = t;
Broadcast client activity time.
2019-06-18 18:46:12 +00:00
const auto ts = std::chrono::duration_cast<std::chrono::seconds>( std::chrono::system_clock::now().time_since_epoch() ).count();
Send signed active time in broadcast message. This allows special treatment of negative values.
2020-09-20 20:15:10 +00:00
broadcastMsg.activeTime = int32_t( ts - m_epoch );
assert( broadcastMsg.activeTime >= 0 );
Separate config for data and broadcast port.
2020-03-08 13:34:09 +00:00
m_broadcast->Send( broadcastPort, &broadcastMsg, broadcastLen );
UDP broadcast loop.
2019-06-17 00:25:09 +00:00
}
}
Dequeue events (and do nothing with them).
2017-09-10 18:23:06 +00:00
}
Send event data over network.
2017-09-11 20:51:47 +00:00
Notify servers that client is no longer listening for connections. This happens in these two cases: - The client is exiting. - A connection attempt is performed. This message type is indicated by negative time value.
2020-09-20 20:19:10 +00:00
if( m_broadcast )
{
lastBroadcast = 0;
broadcastMsg.activeTime = -1;
m_broadcast->Send( broadcastPort, &broadcastMsg, broadcastLen );
}
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Handshake
Require shibboleth match at start of connection.
2018-09-09 16:26:53 +00:00
{
char shibboleth[HandshakeShibbolethSize];
Replace select() with poll().
2019-02-10 14:45:23 +00:00
auto res = m_sock->ReadRaw( shibboleth, HandshakeShibbolethSize, 2000 );
Require shibboleth match at start of connection.
2018-09-09 16:26:53 +00:00
if( !res || memcmp( shibboleth, HandshakeShibboleth, HandshakeShibbolethSize ) != 0 )
{
m_sock->~Socket();
tracy_free( m_sock );
Prevent double freeing of socket.
2019-06-09 14:10:21 +00:00
m_sock = nullptr;
Require shibboleth match at start of connection.
2018-09-09 16:26:53 +00:00
continue;
}
Send protocol version to verify handshake.
2018-09-09 17:28:53 +00:00
uint32_t protocolVersion;
Replace select() with poll().
2019-02-10 14:45:23 +00:00
res = m_sock->ReadRaw( &protocolVersion, sizeof( protocolVersion ), 2000 );
Send protocol version to verify handshake.
2018-09-09 17:28:53 +00:00
if( !res )
{
m_sock->~Socket();
tracy_free( m_sock );
Prevent double freeing of socket.
2019-06-09 14:10:21 +00:00
m_sock = nullptr;
Send protocol version to verify handshake.
2018-09-09 17:28:53 +00:00
continue;
}
if( protocolVersion != ProtocolVersion )
{
HandshakeStatus status = HandshakeProtocolMismatch;
m_sock->Send( &status, sizeof( status ) );
m_sock->~Socket();
tracy_free( m_sock );
Prevent double freeing of socket.
2019-06-09 14:10:21 +00:00
m_sock = nullptr;
Send protocol version to verify handshake.
2018-09-09 17:28:53 +00:00
continue;
}
Require shibboleth match at start of connection.
2018-09-09 16:26:53 +00:00
}
Track connection status.
2018-07-10 19:50:00 +00:00
#ifdef TRACY_ON_DEMAND
Send current time in on-demand welcome message.
2019-06-21 17:34:34 +00:00
const auto currentTime = GetTime();
Clear queues before new on-demand connection is made.
2018-07-10 20:01:13 +00:00
ClearQueues( token );
Add connection id for on-demand mode. Long-lived zones could send their end events without begin events in a following scenario: 1. On-demand connection is made. 2. Zone begin is emitted, m_active is set to true. 3. Connection is terminated. 4. A new connection is made. 5. Zone end is emitted, because m_active is true. To this point it was assumed that all zone end events will happen before a new connection is made, but it's not necessarily true.
2019-06-09 15:15:47 +00:00
m_connectionId.fetch_add( 1, std::memory_order_release );
Track connection status.
2018-07-10 19:50:00 +00:00
#endif
Expose m_isConnected in non-on-demand builds.
2020-07-16 09:22:06 +00:00
m_isConnected.store( true, std::memory_order_release );
Track connection status.
2018-07-10 19:50:00 +00:00
Send protocol version to verify handshake.
2018-09-09 17:28:53 +00:00
HandshakeStatus handshake = HandshakeWelcome;
m_sock->Send( &handshake, sizeof( handshake ) );
Don't include LZ4 headers in tracy headers. The LZ4 implementation is wrapped in tracy namespace, but it also adds some defines, which may conflict with other LZ4 implementations.
2019-05-01 10:57:42 +00:00
LZ4_resetStream( (LZ4_stream_t*)m_stream );
Send on-demand initial payload message.
2018-07-10 20:37:39 +00:00
m_sock->Send( &welcome, sizeof( welcome ) );
Track thread context. This change exploits the fact that events are processed in batches originating from a single thread. A single message changing thread context is enough to handle multiple messages, as opposed to inclusion of thread identifier in each message.
2019-08-02 18:18:08 +00:00
m_threadCtx = 0;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
m_refTimeSerial = 0;
Send delta times for context switches.
2019-10-25 17:13:11 +00:00
m_refTimeCtx = 0;
Send time deltas in GPU time events.
2019-10-25 17:52:01 +00:00
m_refTimeGpu = 0;
Track thread context. This change exploits the fact that events are processed in batches originating from a single thread. A single message changing thread context is enough to handle multiple messages, as opposed to inclusion of thread identifier in each message.
2019-08-02 18:18:08 +00:00
Send on-demand initial payload message.
2018-07-10 20:37:39 +00:00
#ifdef TRACY_ON_DEMAND
OnDemandPayloadMessage onDemand;
onDemand.frames = m_frameCount.load( std::memory_order_relaxed );
Send current time in on-demand welcome message.
2019-06-21 17:34:34 +00:00
onDemand.currentTime = currentTime;
Send on-demand initial payload message.
2018-07-10 20:37:39 +00:00
m_sock->Send( &onDemand, sizeof( onDemand ) );
Send deferred data.
2018-07-11 10:28:40 +00:00
m_deferredLock.lock();
for( auto& item : m_deferredQueue )
{
Send deferred lock names.
2020-03-08 14:05:35 +00:00
uint64_t ptr;
Send single string for messages.
2020-07-25 23:15:11 +00:00
uint16_t size;
Send deferred data.
2018-07-11 10:28:40 +00:00
const auto idx = MemRead<uint8_t>( &item.hdr.idx );
Send deferred lock names.
2020-03-08 14:05:35 +00:00
switch( (QueueType)idx )
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
{
Send deferred lock names.
2020-03-08 14:05:35 +00:00
case QueueType::MessageAppInfo:
Send single string for messages.
2020-07-25 23:15:11 +00:00
ptr = MemRead<uint64_t>( &item.messageFat.text );
size = MemRead<uint16_t>( &item.messageFat.size );
SendSingleString( (const char*)ptr, size );
Send deferred lock names.
2020-03-08 14:05:35 +00:00
break;
case QueueType::LockName:
Send single string for lock name.
2020-07-25 23:22:09 +00:00
ptr = MemRead<uint64_t>( &item.lockNameFat.name );
size = MemRead<uint16_t>( &item.lockNameFat.size );
SendSingleString( (const char*)ptr, size );
Send deferred lock names.
2020-03-08 14:05:35 +00:00
break;
Fix sending GPU context name in on-demand mode.
2021-02-27 18:59:32 +00:00
case QueueType::GpuContextName:
ptr = MemRead<uint64_t>( &item.gpuContextNameFat.ptr );
size = MemRead<uint16_t>( &item.gpuContextNameFat.size );
SendSingleString( (const char*)ptr, size );
break;
Add default no-op to switch.
2020-03-26 00:07:25 +00:00
default:
break;
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
}
Send deferred data.
2018-07-11 10:28:40 +00:00
AppendData( &item, QueueDataSize[idx] );
}
m_deferredLock.unlock();
Send on-demand initial payload message.
2018-07-10 20:37:39 +00:00
#endif
Use stream compression. Previously each data packet was compressed independently. After this change all new packets reference the previously sent data, which achieves better compression.
2017-09-17 11:10:42 +00:00
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Main communications loop
Send keep alive messages to determine if client disconnected.
2018-07-10 19:33:22 +00:00
int keepAlive = 0;
Send event data over network.
2017-09-11 20:51:47 +00:00
for(;;)
Dequeue events (and do nothing with them).
2017-09-10 18:23:06 +00:00
{
CPU usage retrieval.
2019-02-21 20:59:02 +00:00
ProcessSysTime();
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
const auto status = Dequeue( token );
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
const auto serialStatus = DequeueSerial();
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
if( status == DequeueStatus::ConnectionLost || serialStatus == DequeueStatus::ConnectionLost )
Send event data over network.
2017-09-11 20:51:47 +00:00
{
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
break;
Send event data over network.
2017-09-11 20:51:47 +00:00
}
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
else if( status == DequeueStatus::QueueEmpty && serialStatus == DequeueStatus::QueueEmpty )
Send event data over network.
2017-09-11 20:51:47 +00:00
{
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
if( ShouldExit() ) break;
Send keep alive messages to determine if client disconnected.
2018-07-10 19:33:22 +00:00
if( m_bufferOffset != m_bufferStart )
{
if( !CommitData() ) break;
}
if( keepAlive == 500 )
{
QueueItem ka;
ka.hdr.type = QueueType::KeepAlive;
AppendData( &ka, QueueDataSize[ka.hdr.idx] );
if( !CommitData() ) break;
keepAlive = 0;
}
Don't sleep if queues are empty, but there's queries to handle.
2021-05-21 23:12:42 +00:00
else if( !m_sock->HasData() )
Send keep alive messages to determine if client disconnected.
2018-07-10 19:33:22 +00:00
{
keepAlive++;
std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
}
}
else
{
keepAlive = 0;
Send event data over network.
2017-09-11 20:51:47 +00:00
}
Reply to string requests.
2017-09-14 17:25:16 +00:00
Immediately react to connection termination.
2019-06-09 14:51:39 +00:00
bool connActive = true;
Remove server query quota.
2021-10-20 23:48:52 +00:00
while( m_sock->HasData() )
Reply to string requests.
2017-09-14 17:25:16 +00:00
{
Immediately react to connection termination.
2019-06-09 14:51:39 +00:00
connActive = HandleServerQuery();
Limit client query response rate. Original idea by xavier <xavierb@gmail.com>
2021-05-21 23:05:06 +00:00
if( !connActive ) break;
Reply to string requests.
2017-09-14 17:25:16 +00:00
}
Immediately react to connection termination.
2019-06-09 14:51:39 +00:00
if( !connActive ) break;
Dequeue events (and do nothing with them).
2017-09-10 18:23:06 +00:00
}
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
if( ShouldExit() ) break;
Track connection status.
2018-07-10 19:50:00 +00:00
More strict memory ordering for on-demand connection status.
2019-06-09 14:48:00 +00:00
m_isConnected.store( false, std::memory_order_release );
Expose m_isConnected in non-on-demand builds.
2020-07-16 09:22:06 +00:00
#ifdef TRACY_ON_DEMAND
Discard send buffer data after disconnect.
2019-06-10 00:11:29 +00:00
m_bufferOffset = 0;
Proper buffer reset.
2019-08-04 15:48:19 +00:00
m_bufferStart = 0;
Track connection status.
2018-07-10 19:50:00 +00:00
#endif
Free socket after disconnection.
2018-09-09 16:31:06 +00:00
m_sock->~Socket();
tracy_free( m_sock );
Prevent double freeing of socket.
2019-06-09 14:10:21 +00:00
m_sock = nullptr;
Non-on-demand client is only able to handle one connection.
2018-09-09 17:42:06 +00:00
Fix on-demand mode.
2018-09-09 17:44:41 +00:00
#ifndef TRACY_ON_DEMAND
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Client is no longer available here. Accept incoming connections, but reject handshake.
Non-on-demand client is only able to handle one connection.
2018-09-09 17:42:06 +00:00
for(;;)
{
if( ShouldExit() )
{
m_shutdownFinished.store( true, std::memory_order_relaxed );
return;
}
Use common queue clearing function.
2018-12-21 17:12:26 +00:00
ClearQueues( token );
Non-on-demand client is only able to handle one connection.
2018-09-09 17:42:06 +00:00
m_sock = listen.Accept();
if( m_sock )
{
char shibboleth[HandshakeShibbolethSize];
Replace select() with poll().
2019-02-10 14:45:23 +00:00
auto res = m_sock->ReadRaw( shibboleth, HandshakeShibbolethSize, 1000 );
Non-on-demand client is only able to handle one connection.
2018-09-09 17:42:06 +00:00
if( !res || memcmp( shibboleth, HandshakeShibboleth, HandshakeShibbolethSize ) != 0 )
{
m_sock->~Socket();
tracy_free( m_sock );
Prevent double freeing of socket.
2019-06-09 14:10:21 +00:00
m_sock = nullptr;
Non-on-demand client is only able to handle one connection.
2018-09-09 17:42:06 +00:00
continue;
}
uint32_t protocolVersion;
Replace select() with poll().
2019-02-10 14:45:23 +00:00
res = m_sock->ReadRaw( &protocolVersion, sizeof( protocolVersion ), 1000 );
Non-on-demand client is only able to handle one connection.
2018-09-09 17:42:06 +00:00
if( !res )
{
m_sock->~Socket();
tracy_free( m_sock );
Prevent double freeing of socket.
2019-06-09 14:10:21 +00:00
m_sock = nullptr;
Non-on-demand client is only able to handle one connection.
2018-09-09 17:42:06 +00:00
continue;
}
HandshakeStatus status = HandshakeNotAvailable;
m_sock->Send( &status, sizeof( status ) );
m_sock->~Socket();
tracy_free( m_sock );
}
}
Fix on-demand mode.
2018-09-09 17:44:41 +00:00
#endif
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
}
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// End of connections loop
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
Pump symbols queue during profiler termination.
2021-10-22 23:47:04 +00:00
// Wait for symbols thread to terminate. Symbol resolution will continue in this thread.
#ifdef TRACY_HAS_CALLSTACK
while( s_symbolThreadGone.load() == false ) { YieldThread(); }
#endif
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Client is exiting. Send items remaining in queues.
Fix TRACY_NO_EXIT behavior. Terminate event could be the first event that was sent. In such case server immediately closed the connection, as there was no outstanding data to receive. Fix by sending all data in the queue before sending terminate event.
2018-01-11 12:43:54 +00:00
for(;;)
{
const auto status = Dequeue( token );
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
const auto serialStatus = DequeueSerial();
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
if( status == DequeueStatus::ConnectionLost || serialStatus == DequeueStatus::ConnectionLost )
Fix TRACY_NO_EXIT behavior. Terminate event could be the first event that was sent. In such case server immediately closed the connection, as there was no outstanding data to receive. Fix by sending all data in the queue before sending terminate event.
2018-01-11 12:43:54 +00:00
{
We're done here, don't try to send termination request.
2019-06-09 14:22:48 +00:00
m_shutdownFinished.store( true, std::memory_order_relaxed );
return;
Fix TRACY_NO_EXIT behavior. Terminate event could be the first event that was sent. In such case server immediately closed the connection, as there was no outstanding data to receive. Fix by sending all data in the queue before sending terminate event.
2018-01-11 12:43:54 +00:00
}
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
else if( status == DequeueStatus::QueueEmpty && serialStatus == DequeueStatus::QueueEmpty )
Fix TRACY_NO_EXIT behavior. Terminate event could be the first event that was sent. In such case server immediately closed the connection, as there was no outstanding data to receive. Fix by sending all data in the queue before sending terminate event.
2018-01-11 12:43:54 +00:00
{
if( m_bufferOffset != m_bufferStart ) CommitData();
break;
}
while( m_sock->HasData() )
{
We're done here, don't try to send termination request.
2019-06-09 14:22:48 +00:00
if( !HandleServerQuery() )
{
m_shutdownFinished.store( true, std::memory_order_relaxed );
return;
}
Fix TRACY_NO_EXIT behavior. Terminate event could be the first event that was sent. In such case server immediately closed the connection, as there was no outstanding data to receive. Fix by sending all data in the queue before sending terminate event.
2018-01-11 12:43:54 +00:00
}
Pump symbols queue during profiler termination.
2021-10-22 23:47:04 +00:00
#ifdef TRACY_HAS_CALLSTACK
Adapt to SPSCQueue interface.
2021-11-14 17:50:59 +00:00
for(;;)
{
auto si = m_symbolQueue.front();
if( !si ) break;
HandleSymbolQueueItem( *si );
m_symbolQueue.pop();
}
Pump symbols queue during profiler termination.
2021-10-22 23:47:04 +00:00
#endif
Fix TRACY_NO_EXIT behavior. Terminate event could be the first event that was sent. In such case server immediately closed the connection, as there was no outstanding data to receive. Fix by sending all data in the queue before sending terminate event.
2018-01-11 12:43:54 +00:00
}
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Send client termination notice to the server
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
QueueItem terminate;
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
MemWrite( &terminate.hdr.type, QueueType::Terminate );
Allow external profiler shutdown requests.
2018-08-19 23:02:27 +00:00
if( !SendData( (const char*)&terminate, 1 ) )
{
m_shutdownFinished.store( true, std::memory_order_relaxed );
return;
}
Add comments to client connection handling.
2019-06-09 13:55:18 +00:00
// Handle remaining server queries
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
for(;;)
{
if( m_sock->HasData() )
{
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
while( m_sock->HasData() )
{
if( !HandleServerQuery() )
{
Allow external profiler shutdown requests.
2018-08-19 23:02:27 +00:00
m_shutdownFinished.store( true, std::memory_order_relaxed );
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
return;
}
}
Pump symbols queue during profiler termination.
2021-10-22 23:47:04 +00:00
#ifdef TRACY_HAS_CALLSTACK
Adapt to SPSCQueue interface.
2021-11-14 17:50:59 +00:00
for(;;)
{
auto si = m_symbolQueue.front();
if( !si ) break;
HandleSymbolQueueItem( *si );
m_symbolQueue.pop();
}
Pump symbols queue during profiler termination.
2021-10-22 23:47:04 +00:00
#endif
Fix conflicts with X.h.
2019-11-14 17:24:29 +00:00
while( Dequeue( token ) == DequeueStatus::DataDequeued ) {}
while( DequeueSerial() == DequeueStatus::DataDequeued ) {}
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
if( m_bufferOffset != m_bufferStart )
{
Allow external profiler shutdown requests.
2018-08-19 23:02:27 +00:00
if( !CommitData() )
{
m_shutdownFinished.store( true, std::memory_order_relaxed );
return;
}
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
}
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
}
else
{
Send data before sleeping during shutdown.
2017-11-11 13:23:55 +00:00
if( m_bufferOffset != m_bufferStart ) CommitData();
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
}
}
}
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#ifndef TRACY_NO_FRAME_IMAGE
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
void Profiler::CompressWorker()
{
Fixing crash on exit due to RP malloc not being deinitialized
2020-07-08 10:50:25 +00:00
ThreadExitHandler threadExitHandler;
Shorter thread names.
2019-08-20 14:22:54 +00:00
SetThreadName( "Tracy DXT1" );
Fix races in rpmalloc initialization. Ensure rpmalloc_thread_initialize() int worker threads is called only after rpmalloc_initialize() was called on the main profiler thread.
2019-07-19 17:25:27 +00:00
while( m_timeBegin.load( std::memory_order_relaxed ) == 0 ) std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
Initialize rpmalloc in compression thread.
2019-06-27 16:11:52 +00:00
rpmalloc_thread_initialize();
Cosmetics.
2021-10-20 23:49:20 +00:00
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
for(;;)
{
const auto shouldExit = ShouldExit();
Revert "Use SPSC queue for frame images." This reverts commit 02e76faff7a17a907457078997c42c1b0d6b0f0f. Let's not limit frame image reporting to just one thread.
2021-10-20 21:18:03 +00:00
{
bool lockHeld = true;
while( !m_fiLock.try_lock() )
{
if( m_shutdownManual.load( std::memory_order_relaxed ) )
{
lockHeld = false;
break;
}
}
if( !m_fiQueue.empty() ) m_fiQueue.swap( m_fiDequeue );
if( lockHeld )
{
m_fiLock.unlock();
}
}
const auto sz = m_fiDequeue.size();
if( sz > 0 )
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
{
Revert "Use SPSC queue for frame images." This reverts commit 02e76faff7a17a907457078997c42c1b0d6b0f0f. Let's not limit frame image reporting to just one thread.
2021-10-20 21:18:03 +00:00
auto fi = m_fiDequeue.data();
auto end = fi + sz;
while( fi != end )
{
const auto w = fi->w;
const auto h = fi->h;
const auto csz = size_t( w * h / 2 );
auto etc1buf = (char*)tracy_malloc( csz );
CompressImageDxt1( (const char*)fi->image, etc1buf, w, h );
tracy_free( fi->image );
TracyLfqPrepare( QueueType::FrameImage );
MemWrite( &item->frameImageFat.image, (uint64_t)etc1buf );
MemWrite( &item->frameImageFat.frame, fi->frame );
MemWrite( &item->frameImageFat.w, w );
MemWrite( &item->frameImageFat.h, h );
uint8_t flip = fi->flip;
MemWrite( &item->frameImageFat.flip, flip );
TracyLfqCommit;
fi++;
}
m_fiDequeue.clear();
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
}
else
{
std::this_thread::sleep_for( std::chrono::milliseconds( 20 ) );
}
Revert "Use SPSC queue for frame images." This reverts commit 02e76faff7a17a907457078997c42c1b0d6b0f0f. Let's not limit frame image reporting to just one thread.
2021-10-20 21:18:03 +00:00
if( shouldExit )
{
return;
}
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
}
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
}
Added support for TRACY_NO_FRAME_IMAGE define.
2021-04-29 18:55:16 +00:00
#endif
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
static void FreeAssociatedMemory( const QueueItem& item )
Clear queues before new on-demand connection is made.
2018-07-10 20:01:13 +00:00
{
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
if( item.hdr.idx >= (int)QueueType::Terminate ) return;
uint64_t ptr;
switch( item.hdr.type )
{
case QueueType::ZoneText:
case QueueType::ZoneName:
Send single string for zone text and name.
2020-07-25 22:53:55 +00:00
ptr = MemRead<uint64_t>( &item.zoneTextFat.text );
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
tracy_free( (void*)ptr );
break;
Transfer of colored messages.
2019-05-10 18:17:44 +00:00
case QueueType::MessageColor:
Plumbing for message call stacks.
2019-11-14 22:40:41 +00:00
case QueueType::MessageColorCallstack:
Fix switch for memory free. Because of the layout difference between messageFat and messageColorFat, this was referencing the text member 3-bytes offset from where it should have been.
2020-12-08 03:07:12 +00:00
ptr = MemRead<uint64_t>( &item.messageColorFat.text );
tracy_free( (void*)ptr );
break;
case QueueType::Message:
case QueueType::MessageCallstack:
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
#ifndef TRACY_ON_DEMAND
case QueueType::MessageAppInfo:
#endif
Send single string for messages.
2020-07-25 23:15:11 +00:00
ptr = MemRead<uint64_t>( &item.messageFat.text );
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
tracy_free( (void*)ptr );
break;
case QueueType::ZoneBeginAllocSrcLoc:
Separate message for zone begin with alloc src loc and callstack.
2019-03-03 16:47:26 +00:00
case QueueType::ZoneBeginAllocSrcLocCallstack:
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
ptr = MemRead<uint64_t>( &item.zoneBegin.srcloc );
tracy_free( (void*)ptr );
break;
Add transient OpenGL zones.
2021-01-15 19:13:09 +00:00
case QueueType::GpuZoneBeginAllocSrcLoc:
case QueueType::GpuZoneBeginAllocSrcLocCallstack:
case QueueType::GpuZoneBeginAllocSrcLocSerial:
case QueueType::GpuZoneBeginAllocSrcLocCallstackSerial:
ptr = MemRead<uint64_t>( &item.gpuZoneBegin.srcloc );
tracy_free( (void*)ptr );
break;
Rename CallstackMemory to CallstackSerial.
2021-01-15 19:49:39 +00:00
case QueueType::CallstackSerial:
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
case QueueType::Callstack:
No need for lean callstack, callstack memory messages.
2020-07-26 12:15:16 +00:00
ptr = MemRead<uint64_t>( &item.callstackFat.ptr );
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
tracy_free( (void*)ptr );
break;
Send native callstack along with allocated callstack.
2019-03-05 01:00:31 +00:00
case QueueType::CallstackAlloc:
No need for lean callstack alloc message.
2020-07-26 12:25:32 +00:00
ptr = MemRead<uint64_t>( &item.callstackAllocFat.nativePtr );
Send native callstack along with allocated callstack.
2019-03-05 01:00:31 +00:00
tracy_free( (void*)ptr );
No need for lean callstack alloc message.
2020-07-26 12:25:32 +00:00
ptr = MemRead<uint64_t>( &item.callstackAllocFat.ptr );
Send native callstack before allocated one.
2019-03-05 18:18:43 +00:00
tracy_free( (void*)ptr );
Send native callstack along with allocated callstack.
2019-03-05 01:00:31 +00:00
break;
Send/free callstack sample payloads.
2020-02-22 15:05:01 +00:00
case QueueType::CallstackSample:
No need for lean callstack sample message.
2020-07-26 12:28:13 +00:00
ptr = MemRead<uint64_t>( &item.callstackSampleFat.ptr );
Send/free callstack sample payloads.
2020-02-22 15:05:01 +00:00
tracy_free( (void*)ptr );
break;
Frame image transfer prototype.
2019-06-06 19:39:54 +00:00
case QueueType::FrameImage:
No need for lean frame image message.
2020-07-26 12:18:48 +00:00
ptr = MemRead<uint64_t>( &item.frameImageFat.image );
Frame image transfer prototype.
2019-06-06 19:39:54 +00:00
tracy_free( (void*)ptr );
break;
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#ifdef TRACY_HAS_CALLSTACK
case QueueType::CallstackFrameSize:
{
InitRpmalloc();
auto size = MemRead<uint8_t>( &item.callstackFrameSizeFat.size );
auto data = (const CallstackEntry*)MemRead<uint64_t>( &item.callstackFrameSizeFat.data );
for( uint8_t i=0; i<size; i++ )
{
const auto& frame = data[i];
tracy_free_fast( (void*)frame.name );
tracy_free_fast( (void*)frame.file );
}
tracy_free_fast( (void*)data );
break;
}
case QueueType::SymbolInformation:
{
uint8_t needFree = MemRead<uint8_t>( &item.symbolInformationFat.needFree );
if( needFree )
{
ptr = MemRead<uint64_t>( &item.symbolInformationFat.fileString );
tracy_free( (void*)ptr );
}
break;
}
case QueueType::CodeInformation:
{
uint8_t needFree = MemRead<uint8_t>( &item.codeInformationFat.needFree );
if( needFree )
{
ptr = MemRead<uint64_t>( &item.codeInformationFat.fileString );
tracy_free( (void*)ptr );
}
break;
}
#endif
Custom lock name transfer.
2020-03-08 12:47:38 +00:00
#ifndef TRACY_ON_DEMAND
case QueueType::LockName:
Send single string for lock name.
2020-07-25 23:22:09 +00:00
ptr = MemRead<uint64_t>( &item.lockNameFat.name );
Custom lock name transfer.
2020-03-08 12:47:38 +00:00
tracy_free( (void*)ptr );
break;
Add GPU context name transfer to the protocol.
2021-01-31 17:46:42 +00:00
case QueueType::GpuContextName:
ptr = MemRead<uint64_t>( &item.gpuContextNameFat.ptr );
tracy_free( (void*)ptr );
break;
Custom lock name transfer.
2020-03-08 12:47:38 +00:00
#endif
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
#ifdef TRACY_ON_DEMAND
case QueueType::MessageAppInfo:
Add GPU context name transfer to the protocol.
2021-01-31 17:46:42 +00:00
case QueueType::GpuContextName:
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
// Don't free memory associated with deferred messages.
break;
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#endif
#ifdef TRACY_HAS_SYSTEM_TRACING
case QueueType::ExternalNameMetadata:
ptr = MemRead<uint64_t>( &item.externalNameMetadata.name );
tracy_free( (void*)ptr );
ptr = MemRead<uint64_t>( &item.externalNameMetadata.threadName );
tracy_free_fast( (void*)ptr );
break;
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
#endif
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
default:
break;
}
}
Clear queues before new on-demand connection is made.
2018-07-10 20:01:13 +00:00
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
void Profiler::ClearQueues( moodycamel::ConsumerToken& token )
{
for(;;)
{
Restrict client to C++11.
2020-05-13 16:15:12 +00:00
const auto sz = GetQueue().try_dequeue_bulk_single( token, [](const uint64_t&){}, []( QueueItem* item, size_t sz ) { assert( sz > 0 ); while( sz-- > 0 ) FreeAssociatedMemory( *item++ ); } );
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
if( sz == 0 ) break;
}
Clear queues before new on-demand connection is made.
2018-07-10 20:01:13 +00:00
Add a separate method for clearing serial queue.
2019-08-14 20:39:12 +00:00
ClearSerial();
}
void Profiler::ClearSerial()
{
bool lockHeld = true;
while( !m_serialLock.try_lock() )
Use proper pattern for acquiring serial lock. This fixes a potential hang during crash handling. Also, lock duration is reduced.
2018-12-21 17:10:29 +00:00
{
Add a separate method for clearing serial queue.
2019-08-14 20:39:12 +00:00
if( m_shutdownManual.load( std::memory_order_relaxed ) )
Use proper pattern for acquiring serial lock. This fixes a potential hang during crash handling. Also, lock duration is reduced.
2018-12-21 17:10:29 +00:00
{
Add a separate method for clearing serial queue.
2019-08-14 20:39:12 +00:00
lockHeld = false;
break;
Use proper pattern for acquiring serial lock. This fixes a potential hang during crash handling. Also, lock duration is reduced.
2018-12-21 17:10:29 +00:00
}
}
Add a separate method for clearing serial queue.
2019-08-14 20:39:12 +00:00
for( auto& v : m_serialQueue ) FreeAssociatedMemory( v );
m_serialQueue.clear();
if( lockHeld )
{
m_serialLock.unlock();
}
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
for( auto& v : m_serialDequeue ) FreeAssociatedMemory( v );
Clear queues before new on-demand connection is made.
2018-07-10 20:01:13 +00:00
m_serialDequeue.clear();
}
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
Profiler::DequeueStatus Profiler::Dequeue( moodycamel::ConsumerToken& token )
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
bool connectionLost = false;
const auto sz = GetQueue().try_dequeue_bulk_single( token,
Change thread id size from 64 to 32 bits. Both Windows and Linux use 32-bit thread identifiers. MacOS has a 64-bit counter, but in practice it will never overflow during profiling and no false aliasing will happen. These changes are only done client-side and in the network protocol. The server still uses 64-bit thread identifiers, to enable virtual threads, etc.
2021-10-07 22:42:52 +00:00
[this, &connectionLost] ( const uint32_t& threadId )
Track thread context. This change exploits the fact that events are processed in batches originating from a single thread. A single message changing thread context is enough to handle multiple messages, as opposed to inclusion of thread identifier in each message.
2019-08-02 18:18:08 +00:00
{
Move thread context check to a separate function.
2021-10-09 13:16:36 +00:00
if( ThreadCtxCheck( threadId ) == ThreadCtxStatus::ConnectionLost ) connectionLost = true;
Process queue data in-place.
2020-02-23 13:50:50 +00:00
},
[this, &connectionLost] ( QueueItem* item, size_t sz )
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
if( connectionLost ) return;
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
InitRpmalloc();
Process queue data in-place.
2020-02-23 13:50:50 +00:00
assert( sz > 0 );
int64_t refThread = m_refTimeThread;
int64_t refCtx = m_refTimeCtx;
int64_t refGpu = m_refTimeGpu;
while( sz-- > 0 )
Preemptive sending of custom strings.
2017-11-11 14:22:55 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
uint64_t ptr;
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
uint16_t size;
Send lean allocated source locations.
2020-05-10 17:20:59 +00:00
auto idx = MemRead<uint8_t>( &item->hdr.idx );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
if( idx < (int)QueueType::Terminate )
Track thread context. This change exploits the fact that events are processed in batches originating from a single thread. A single message changing thread context is enough to handle multiple messages, as opposed to inclusion of thread identifier in each message.
2019-08-02 18:18:08 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
switch( (QueueType)idx )
{
case QueueType::ZoneText:
case QueueType::ZoneName:
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
ptr = MemRead<uint64_t>( &item->zoneTextFat.text );
size = MemRead<uint16_t>( &item->zoneTextFat.size );
Send single string for zone text and name.
2020-07-25 22:53:55 +00:00
SendSingleString( (const char*)ptr, size );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
case QueueType::Message:
case QueueType::MessageCallstack:
Preserve messages size.
2020-07-21 18:22:59 +00:00
ptr = MemRead<uint64_t>( &item->messageFat.text );
size = MemRead<uint16_t>( &item->messageFat.size );
Send single string for messages.
2020-07-25 23:15:11 +00:00
SendSingleString( (const char*)ptr, size );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Preserve messages size.
2020-07-21 18:22:59 +00:00
break;
case QueueType::MessageColor:
Process queue data in-place.
2020-02-23 13:50:50 +00:00
case QueueType::MessageColorCallstack:
Preserve messages size.
2020-07-21 18:22:59 +00:00
ptr = MemRead<uint64_t>( &item->messageColorFat.text );
size = MemRead<uint16_t>( &item->messageColorFat.size );
Send single string for messages.
2020-07-25 23:15:11 +00:00
SendSingleString( (const char*)ptr, size );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
case QueueType::MessageAppInfo:
Send single string for messages.
2020-07-25 23:15:11 +00:00
ptr = MemRead<uint64_t>( &item->messageFat.text );
size = MemRead<uint16_t>( &item->messageFat.size );
SendSingleString( (const char*)ptr, size );
Cosmetics.
2019-08-14 21:05:58 +00:00
#ifndef TRACY_ON_DEMAND
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Cosmetics.
2019-08-14 21:05:58 +00:00
#endif
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
case QueueType::ZoneBeginAllocSrcLoc:
case QueueType::ZoneBeginAllocSrcLocCallstack:
Native callstacks are now optional in allocated callstack messages.
2019-11-25 21:54:10 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
int64_t t = MemRead<int64_t>( &item->zoneBegin.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->zoneBegin.time, dt );
ptr = MemRead<uint64_t>( &item->zoneBegin.srcloc );
SendSourceLocationPayload( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
}
case QueueType::Callstack:
No need for lean callstack, callstack memory messages.
2020-07-26 12:15:16 +00:00
ptr = MemRead<uint64_t>( &item->callstackFat.ptr );
Native callstacks are now optional in allocated callstack messages.
2019-11-25 21:54:10 +00:00
SendCallstackPayload( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
case QueueType::CallstackAlloc:
No need for lean callstack alloc message.
2020-07-26 12:25:32 +00:00
ptr = MemRead<uint64_t>( &item->callstackAllocFat.nativePtr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
if( ptr != 0 )
{
CutCallstack( (void*)ptr, "lua_pcall" );
SendCallstackPayload( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
}
No need for lean callstack alloc message.
2020-07-26 12:25:32 +00:00
ptr = MemRead<uint64_t>( &item->callstackAllocFat.ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
SendCallstackAlloc( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
case QueueType::CallstackSample:
{
No need for lean callstack sample message.
2020-07-26 12:28:13 +00:00
ptr = MemRead<uint64_t>( &item->callstackSampleFat.ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
SendCallstackPayload64( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
No need for lean callstack sample message.
2020-07-26 12:28:13 +00:00
int64_t t = MemRead<int64_t>( &item->callstackSampleFat.time );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
int64_t dt = t - refCtx;
refCtx = t;
No need for lean callstack sample message.
2020-07-26 12:28:13 +00:00
MemWrite( &item->callstackSampleFat.time, dt );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
}
case QueueType::FrameImage:
{
No need for lean frame image message.
2020-07-26 12:18:48 +00:00
ptr = MemRead<uint64_t>( &item->frameImageFat.image );
const auto w = MemRead<uint16_t>( &item->frameImageFat.w );
const auto h = MemRead<uint16_t>( &item->frameImageFat.h );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
const auto csz = size_t( w * h / 2 );
SendLongString( ptr, (const char*)ptr, csz, QueueType::FrameImageData );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
break;
}
case QueueType::ZoneBegin:
case QueueType::ZoneBeginCallstack:
{
int64_t t = MemRead<int64_t>( &item->zoneBegin.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->zoneBegin.time, dt );
break;
}
case QueueType::ZoneEnd:
{
int64_t t = MemRead<int64_t>( &item->zoneEnd.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->zoneEnd.time, dt );
break;
}
case QueueType::GpuZoneBegin:
case QueueType::GpuZoneBeginCallstack:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneBegin.cpuTime );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->gpuZoneBegin.cpuTime, dt );
break;
}
Add transient OpenGL zones.
2021-01-15 19:13:09 +00:00
case QueueType::GpuZoneBeginAllocSrcLoc:
case QueueType::GpuZoneBeginAllocSrcLocCallstack:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneBegin.cpuTime );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->gpuZoneBegin.cpuTime, dt );
ptr = MemRead<uint64_t>( &item->gpuZoneBegin.srcloc );
SendSourceLocationPayload( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Add transient OpenGL zones.
2021-01-15 19:13:09 +00:00
break;
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
case QueueType::GpuZoneEnd:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneEnd.cpuTime );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->gpuZoneEnd.cpuTime, dt );
break;
}
Add GPU context name transfer to the protocol.
2021-01-31 17:46:42 +00:00
case QueueType::GpuContextName:
ptr = MemRead<uint64_t>( &item->gpuContextNameFat.ptr );
Reuse existing variable.
2021-02-10 17:56:07 +00:00
size = MemRead<uint16_t>( &item->gpuContextNameFat.size );
Add GPU context name transfer to the protocol.
2021-01-31 17:46:42 +00:00
SendSingleString( (const char*)ptr, size );
#ifndef TRACY_ON_DEMAND
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Add GPU context name transfer to the protocol.
2021-01-31 17:46:42 +00:00
#endif
break;
Process queue data in-place.
2020-02-23 13:50:50 +00:00
case QueueType::PlotData:
{
int64_t t = MemRead<int64_t>( &item->plotData.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->plotData.time, dt );
break;
}
case QueueType::ContextSwitch:
{
int64_t t = MemRead<int64_t>( &item->contextSwitch.time );
int64_t dt = t - refCtx;
refCtx = t;
MemWrite( &item->contextSwitch.time, dt );
break;
}
case QueueType::ThreadWakeup:
{
int64_t t = MemRead<int64_t>( &item->threadWakeup.time );
int64_t dt = t - refCtx;
refCtx = t;
MemWrite( &item->threadWakeup.time, dt );
break;
}
case QueueType::GpuTime:
{
int64_t t = MemRead<int64_t>( &item->gpuTime.gpuTime );
int64_t dt = t - refGpu;
refGpu = t;
MemWrite( &item->gpuTime.gpuTime, dt );
break;
}
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
#ifdef TRACY_HAS_CALLSTACK
case QueueType::CallstackFrameSize:
{
auto data = (const CallstackEntry*)MemRead<uint64_t>( &item->callstackFrameSizeFat.data );
auto datasz = MemRead<uint8_t>( &item->callstackFrameSizeFat.size );
auto imageName = (const char*)MemRead<uint64_t>( &item->callstackFrameSizeFat.imageName );
SendSingleString( imageName );
AppendData( item++, QueueDataSize[idx] );
for( uint8_t i=0; i<datasz; i++ )
{
const auto& frame = data[i];
SendSingleString( frame.name );
SendSecondString( frame.file );
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CallstackFrame );
MemWrite( &item.callstackFrame.line, frame.line );
MemWrite( &item.callstackFrame.symAddr, frame.symAddr );
MemWrite( &item.callstackFrame.symLen, frame.symLen );
AppendData( &item, QueueDataSize[(int)QueueType::CallstackFrame] );
tracy_free_fast( (void*)frame.name );
tracy_free_fast( (void*)frame.file );
}
tracy_free_fast( (void*)data );
continue;
}
case QueueType::SymbolInformation:
{
auto fileString = (const char*)MemRead<uint64_t>( &item->symbolInformationFat.fileString );
auto needFree = MemRead<uint8_t>( &item->symbolInformationFat.needFree );
SendSingleString( fileString );
if( needFree ) tracy_free_fast( (void*)fileString );
break;
}
case QueueType::CodeInformation:
{
auto fileString = (const char*)MemRead<uint64_t>( &item->codeInformationFat.fileString );
auto needFree = MemRead<uint8_t>( &item->codeInformationFat.needFree );
SendSingleString( fileString );
if( needFree ) tracy_free_fast( (void*)fileString );
break;
}
#endif
#ifdef TRACY_HAS_SYSTEM_TRACING
case QueueType::ExternalNameMetadata:
{
auto thread = MemRead<uint64_t>( &item->externalNameMetadata.thread );
auto name = (const char*)MemRead<uint64_t>( &item->externalNameMetadata.name );
auto threadName = (const char*)MemRead<uint64_t>( &item->externalNameMetadata.threadName );
SendString( thread, threadName, QueueType::ExternalThreadName );
SendString( thread, name, QueueType::ExternalName );
tracy_free( (void*)threadName );
tracy_free_fast( (void*)name );
++item;
continue;
}
#endif
Process queue data in-place.
2020-02-23 13:50:50 +00:00
default:
assert( false );
break;
Native callstacks are now optional in allocated callstack messages.
2019-11-25 21:54:10 +00:00
}
Send delta times for context switches.
2019-10-25 17:13:11 +00:00
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
if( !AppendData( item++, QueueDataSize[idx] ) )
Send time deltas in GPU time events.
2019-10-25 17:52:01 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
connectionLost = true;
m_refTimeThread = refThread;
m_refTimeCtx = refCtx;
m_refTimeGpu = refGpu;
return;
Track thread context. This change exploits the fact that events are processed in batches originating from a single thread. A single message changing thread context is enough to handle multiple messages, as opposed to inclusion of thread identifier in each message.
2019-08-02 18:18:08 +00:00
}
Preemptive sending of custom strings.
2017-11-11 14:22:55 +00:00
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
m_refTimeThread = refThread;
m_refTimeCtx = refCtx;
m_refTimeGpu = refGpu;
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
);
if( connectionLost ) return DequeueStatus::ConnectionLost;
return sz > 0 ? DequeueStatus::DataDequeued : DequeueStatus::QueueEmpty;
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
}
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
Profiler::DequeueStatus Profiler::DequeueContextSwitches( tracy::moodycamel::ConsumerToken& token, int64_t& timeStop )
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
const auto sz = GetQueue().try_dequeue_bulk_single( token, [] ( const uint64_t& ) {},
[this, &timeStop] ( QueueItem* item, size_t sz )
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
assert( sz > 0 );
int64_t refCtx = m_refTimeCtx;
while( sz-- > 0 )
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
FreeAssociatedMemory( *item );
if( timeStop < 0 ) return;
const auto idx = MemRead<uint8_t>( &item->hdr.idx );
if( idx == (uint8_t)QueueType::ContextSwitch )
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
const auto csTime = MemRead<int64_t>( &item->contextSwitch.time );
if( csTime > timeStop )
{
timeStop = -1;
m_refTimeCtx = refCtx;
return;
}
int64_t dt = csTime - refCtx;
refCtx = csTime;
MemWrite( &item->contextSwitch.time, dt );
if( !AppendData( item, QueueDataSize[(int)QueueType::ContextSwitch] ) )
{
timeStop = -2;
m_refTimeCtx = refCtx;
return;
}
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
else if( idx == (uint8_t)QueueType::ThreadWakeup )
Send thread wakeups when handling disconnect request.
2019-10-25 16:22:42 +00:00
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
const auto csTime = MemRead<int64_t>( &item->threadWakeup.time );
if( csTime > timeStop )
{
timeStop = -1;
m_refTimeCtx = refCtx;
return;
}
int64_t dt = csTime - refCtx;
refCtx = csTime;
MemWrite( &item->threadWakeup.time, dt );
if( !AppendData( item, QueueDataSize[(int)QueueType::ThreadWakeup] ) )
{
timeStop = -2;
m_refTimeCtx = refCtx;
return;
}
Send thread wakeups when handling disconnect request.
2019-10-25 16:22:42 +00:00
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
item++;
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
m_refTimeCtx = refCtx;
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
}
Process queue data in-place.
2020-02-23 13:50:50 +00:00
);
if( timeStop == -2 ) return DequeueStatus::ConnectionLost;
return ( timeStop == -1 || sz > 0 ) ? DequeueStatus::DataDequeued : DequeueStatus::QueueEmpty;
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
}
Add macro for handling serial dequeue thread context checks.
2021-10-09 13:30:58 +00:00
#define ThreadCtxCheckSerial( _name ) \
uint32_t thread = MemRead<uint32_t>( &item->_name.thread ); \
switch( ThreadCtxCheck( thread ) ) \
{ \
case ThreadCtxStatus::Same: break; \
case ThreadCtxStatus::Changed: assert( m_refTimeThread == 0 ); refThread = 0; break; \
case ThreadCtxStatus::ConnectionLost: return DequeueStatus::ConnectionLost; \
default: assert( false ); break; \
}
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
Profiler::DequeueStatus Profiler::DequeueSerial()
{
Don't hold lock on serial queue during dequeue.
2018-04-14 13:46:11 +00:00
{
In case of manual shutdown, don't wait for lock. All threads are freezed at this point, nothing will release it.
2018-08-20 19:49:23 +00:00
bool lockHeld = true;
while( !m_serialLock.try_lock() )
{
if( m_shutdownManual.load( std::memory_order_relaxed ) )
{
lockHeld = false;
break;
}
}
Swap queue and dequeue only if queue has contents.
2019-06-27 11:37:09 +00:00
if( !m_serialQueue.empty() ) m_serialQueue.swap( m_serialDequeue );
In case of manual shutdown, don't wait for lock. All threads are freezed at this point, nothing will release it.
2018-08-20 19:49:23 +00:00
if( lockHeld )
{
m_serialLock.unlock();
}
Don't hold lock on serial queue during dequeue.
2018-04-14 13:46:11 +00:00
}
const auto sz = m_serialDequeue.size();
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
if( sz > 0 )
{
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
InitRpmalloc();
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t refSerial = m_refTimeSerial;
int64_t refGpu = m_refTimeGpu;
Handle serialized zones.
2021-10-09 13:31:45 +00:00
#ifdef TRACY_FIBERS
int64_t refThread = m_refTimeThread;
#endif
Don't hold lock on serial queue during dequeue.
2018-04-14 13:46:11 +00:00
auto item = m_serialDequeue.data();
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
auto end = item + sz;
while( item != end )
{
Issue predictive callback payload transfer.
2018-06-19 17:09:57 +00:00
uint64_t ptr;
Send lean memory callstacks.
2020-05-10 17:28:08 +00:00
auto idx = MemRead<uint8_t>( &item->hdr.idx );
Issue predictive callback payload transfer.
2018-06-19 17:09:57 +00:00
if( idx < (int)QueueType::Terminate )
{
switch( (QueueType)idx )
{
Rename CallstackMemory to CallstackSerial.
2021-01-15 19:49:39 +00:00
case QueueType::CallstackSerial:
No need for lean callstack, callstack memory messages.
2020-07-26 12:15:16 +00:00
ptr = MemRead<uint64_t>( &item->callstackFat.ptr );
Issue predictive callback payload transfer.
2018-06-19 17:09:57 +00:00
SendCallstackPayload( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Issue predictive callback payload transfer.
2018-06-19 17:09:57 +00:00
break;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
case QueueType::LockWait:
case QueueType::LockSharedWait:
{
int64_t t = MemRead<int64_t>( &item->lockWait.time );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refSerial;
refSerial = t;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
MemWrite( &item->lockWait.time, dt );
break;
}
case QueueType::LockObtain:
case QueueType::LockSharedObtain:
{
int64_t t = MemRead<int64_t>( &item->lockObtain.time );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refSerial;
refSerial = t;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
MemWrite( &item->lockObtain.time, dt );
break;
}
case QueueType::LockRelease:
case QueueType::LockSharedRelease:
{
int64_t t = MemRead<int64_t>( &item->lockRelease.time );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refSerial;
refSerial = t;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
MemWrite( &item->lockRelease.time, dt );
break;
}
Completely serialize lock events.
2020-07-26 11:45:53 +00:00
case QueueType::LockName:
{
ptr = MemRead<uint64_t>( &item->lockNameFat.name );
uint16_t size = MemRead<uint16_t>( &item->lockNameFat.size );
SendSingleString( (const char*)ptr, size );
#ifndef TRACY_ON_DEMAND
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Completely serialize lock events.
2020-07-26 11:45:53 +00:00
#endif
break;
}
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
case QueueType::MemAlloc:
Add support for custom allocator tracking to client.
2020-09-22 16:22:34 +00:00
case QueueType::MemAllocNamed:
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
case QueueType::MemAllocCallstack:
Add support for custom allocator tracking to client.
2020-09-22 16:22:34 +00:00
case QueueType::MemAllocCallstackNamed:
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
{
int64_t t = MemRead<int64_t>( &item->memAlloc.time );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refSerial;
refSerial = t;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
MemWrite( &item->memAlloc.time, dt );
break;
}
case QueueType::MemFree:
Add support for custom allocator tracking to client.
2020-09-22 16:22:34 +00:00
case QueueType::MemFreeNamed:
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
case QueueType::MemFreeCallstack:
Add support for custom allocator tracking to client.
2020-09-22 16:22:34 +00:00
case QueueType::MemFreeCallstackNamed:
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
{
int64_t t = MemRead<int64_t>( &item->memFree.time );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refSerial;
refSerial = t;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
MemWrite( &item->memFree.time, dt );
break;
}
case QueueType::GpuZoneBeginSerial:
case QueueType::GpuZoneBeginCallstackSerial:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneBegin.cpuTime );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refSerial;
refSerial = t;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
MemWrite( &item->gpuZoneBegin.cpuTime, dt );
break;
}
Add transient OpenGL zones.
2021-01-15 19:13:09 +00:00
case QueueType::GpuZoneBeginAllocSrcLocSerial:
case QueueType::GpuZoneBeginAllocSrcLocCallstackSerial:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneBegin.cpuTime );
int64_t dt = t - refSerial;
refSerial = t;
MemWrite( &item->gpuZoneBegin.cpuTime, dt );
ptr = MemRead<uint64_t>( &item->gpuZoneBegin.srcloc );
SendSourceLocationPayload( ptr );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Add transient OpenGL zones.
2021-01-15 19:13:09 +00:00
break;
}
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
case QueueType::GpuZoneEndSerial:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneEnd.cpuTime );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refSerial;
refSerial = t;
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
MemWrite( &item->gpuZoneEnd.cpuTime, dt );
break;
}
Send time deltas in GPU time events.
2019-10-25 17:52:01 +00:00
case QueueType::GpuTime:
{
int64_t t = MemRead<int64_t>( &item->gpuTime.gpuTime );
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
int64_t dt = t - refGpu;
refGpu = t;
Send time deltas in GPU time events.
2019-10-25 17:52:01 +00:00
MemWrite( &item->gpuTime.gpuTime, dt );
break;
}
Add GPU context name transfer to the protocol.
2021-01-31 17:46:42 +00:00
case QueueType::GpuContextName:
{
ptr = MemRead<uint64_t>( &item->gpuContextNameFat.ptr );
uint16_t size = MemRead<uint16_t>( &item->gpuContextNameFat.size );
SendSingleString( (const char*)ptr, size );
#ifndef TRACY_ON_DEMAND
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( (void*)ptr );
Add GPU context name transfer to the protocol.
2021-01-31 17:46:42 +00:00
#endif
break;
}
Handle serialized zones.
2021-10-09 13:31:45 +00:00
#ifdef TRACY_FIBERS
case QueueType::ZoneBegin:
case QueueType::ZoneBeginCallstack:
{
ThreadCtxCheckSerial( zoneBeginThread );
int64_t t = MemRead<int64_t>( &item->zoneBegin.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->zoneBegin.time, dt );
break;
}
case QueueType::ZoneBeginAllocSrcLoc:
case QueueType::ZoneBeginAllocSrcLocCallstack:
{
ThreadCtxCheckSerial( zoneBeginThread );
int64_t t = MemRead<int64_t>( &item->zoneBegin.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->zoneBegin.time, dt );
ptr = MemRead<uint64_t>( &item->zoneBegin.srcloc );
SendSourceLocationPayload( ptr );
tracy_free_fast( (void*)ptr );
break;
}
case QueueType::ZoneEnd:
{
ThreadCtxCheckSerial( zoneEndThread );
int64_t t = MemRead<int64_t>( &item->zoneEnd.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->zoneEnd.time, dt );
break;
}
case QueueType::ZoneText:
case QueueType::ZoneName:
{
ThreadCtxCheckSerial( zoneTextFatThread );
ptr = MemRead<uint64_t>( &item->zoneTextFat.text );
uint16_t size = MemRead<uint16_t>( &item->zoneTextFat.size );
SendSingleString( (const char*)ptr, size );
tracy_free_fast( (void*)ptr );
break;
}
Messages may now use serialized queue.
2021-10-10 13:54:21 +00:00
case QueueType::Message:
case QueueType::MessageCallstack:
{
ThreadCtxCheckSerial( messageFatThread );
ptr = MemRead<uint64_t>( &item->messageFat.text );
uint16_t size = MemRead<uint16_t>( &item->messageFat.size );
SendSingleString( (const char*)ptr, size );
tracy_free_fast( (void*)ptr );
break;
}
case QueueType::MessageColor:
case QueueType::MessageColorCallstack:
{
ThreadCtxCheckSerial( messageColorFatThread );
ptr = MemRead<uint64_t>( &item->messageColorFat.text );
uint16_t size = MemRead<uint16_t>( &item->messageColorFat.size );
SendSingleString( (const char*)ptr, size );
tracy_free_fast( (void*)ptr );
break;
}
Implement callstack serialization.
2021-10-10 14:14:17 +00:00
case QueueType::Callstack:
{
ThreadCtxCheckSerial( callstackFatThread );
ptr = MemRead<uint64_t>( &item->callstackFat.ptr );
SendCallstackPayload( ptr );
tracy_free_fast( (void*)ptr );
break;
}
case QueueType::CallstackAlloc:
{
ThreadCtxCheckSerial( callstackAllocFatThread );
ptr = MemRead<uint64_t>( &item->callstackAllocFat.nativePtr );
if( ptr != 0 )
{
CutCallstack( (void*)ptr, "lua_pcall" );
SendCallstackPayload( ptr );
tracy_free_fast( (void*)ptr );
}
ptr = MemRead<uint64_t>( &item->callstackAllocFat.ptr );
SendCallstackAlloc( ptr );
tracy_free_fast( (void*)ptr );
break;
}
Add fiber support on client side.
2021-11-01 22:56:19 +00:00
case QueueType::FiberEnter:
{
ThreadCtxCheckSerial( fiberEnter );
int64_t t = MemRead<int64_t>( &item->fiberEnter.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->fiberEnter.time, dt );
break;
}
case QueueType::FiberLeave:
{
ThreadCtxCheckSerial( fiberLeave );
int64_t t = MemRead<int64_t>( &item->fiberLeave.time );
int64_t dt = t - refThread;
refThread = t;
MemWrite( &item->fiberLeave.time, dt );
break;
}
Fix processing of serialized zone color, value and validation.
2021-10-10 12:43:36 +00:00
#endif
default:
assert( false );
break;
}
}
#ifdef TRACY_FIBERS
else
{
switch( (QueueType)idx )
{
Handle serialized zones.
2021-10-09 13:31:45 +00:00
case QueueType::ZoneColor:
{
ThreadCtxCheckSerial( zoneColorThread );
break;
}
case QueueType::ZoneValue:
{
ThreadCtxCheckSerial( zoneValueThread );
break;
}
Allow serialized zone validation.
2021-10-09 13:50:09 +00:00
case QueueType::ZoneValidation:
{
ThreadCtxCheckSerial( zoneValidationThread );
break;
}
Messages may now use serialized queue.
2021-10-10 13:54:21 +00:00
case QueueType::MessageLiteral:
case QueueType::MessageLiteralCallstack:
{
ThreadCtxCheckSerial( messageLiteralThread );
break;
}
case QueueType::MessageLiteralColor:
case QueueType::MessageLiteralColorCallstack:
{
ThreadCtxCheckSerial( messageColorLiteralThread );
break;
}
Crash reports may be serialized.
2021-10-10 13:58:24 +00:00
case QueueType::CrashReport:
{
ThreadCtxCheckSerial( crashReportThread );
break;
}
Issue predictive callback payload transfer.
2018-06-19 17:09:57 +00:00
default:
break;
}
}
Fix processing of serialized zone color, value and validation.
2021-10-10 12:43:36 +00:00
#endif
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
if( !AppendData( item, QueueDataSize[idx] ) ) return DequeueStatus::ConnectionLost;
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
item++;
}
Don't write reference time to memory in each iteration.
2020-02-22 15:54:02 +00:00
m_refTimeSerial = refSerial;
m_refTimeGpu = refGpu;
Handle serialized zones.
2021-10-09 13:31:45 +00:00
#ifdef TRACY_FIBERS
m_refTimeThread = refThread;
#endif
Don't hold lock on serial queue during dequeue.
2018-04-14 13:46:11 +00:00
m_serialDequeue.clear();
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
}
else
{
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
return DequeueStatus::QueueEmpty;
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
}
Fix conflicts with X.h.
2019-11-14 17:24:29 +00:00
return DequeueStatus::DataDequeued;
Serial queue dequeuing.
2018-04-01 18:04:35 +00:00
}
Move thread context check to a separate function.
2021-10-09 13:16:36 +00:00
Profiler::ThreadCtxStatus Profiler::ThreadCtxCheck( uint32_t threadId )
{
if( m_threadCtx == threadId ) return ThreadCtxStatus::Same;
QueueItem item;
MemWrite( &item.hdr.type, QueueType::ThreadContext );
MemWrite( &item.threadCtx.thread, threadId );
if( !AppendData( &item, QueueDataSize[(int)QueueType::ThreadContext] ) ) return ThreadCtxStatus::ConnectionLost;
m_threadCtx = threadId;
m_refTimeThread = 0;
return ThreadCtxStatus::Changed;
}
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
bool Profiler::CommitData()
{
bool ret = SendData( m_buffer + m_bufferStart, m_bufferOffset - m_bufferStart );
if( m_bufferOffset > TargetFrameSize * 2 ) m_bufferOffset = 0;
m_bufferStart = m_bufferOffset;
return ret;
}
Move sending data to a separate function.
2017-09-14 17:07:56 +00:00
bool Profiler::SendData( const char* data, size_t len )
{
Don't include LZ4 headers in tracy headers. The LZ4 implementation is wrapped in tracy namespace, but it also adds some defines, which may conflict with other LZ4 implementations.
2019-05-01 10:57:42 +00:00
const lz4sz_t lz4sz = LZ4_compress_fast_continue( (LZ4_stream_t*)m_stream, data, m_lz4Buf + sizeof( lz4sz_t ), (int)len, LZ4Size, 1 );
Move another big buffer out of stack.
2017-11-02 16:37:10 +00:00
memcpy( m_lz4Buf, &lz4sz, sizeof( lz4sz ) );
Remove ability to disable LZ4 compression.
2017-11-10 16:34:11 +00:00
return m_sock->Send( m_lz4Buf, lz4sz + sizeof( lz4sz_t ) ) != -1;
Move sending data to a separate function.
2017-09-14 17:07:56 +00:00
}
Add SendString() with length parameter.
2020-07-21 00:19:22 +00:00
void Profiler::SendString( uint64_t str, const char* ptr, size_t len, QueueType type )
Add ability to send strings over network.
2017-09-14 17:24:35 +00:00
{
Also retrieve external thread names.
2019-08-16 17:49:16 +00:00
assert( type == QueueType::StringData ||
type == QueueType::ThreadName ||
type == QueueType::PlotName ||
type == QueueType::FrameName ||
type == QueueType::ExternalName ||
Fiber name transport.
2021-11-03 17:57:30 +00:00
type == QueueType::ExternalThreadName ||
type == QueueType::FiberName );
Add ability to send strings over network.
2017-09-14 17:24:35 +00:00
Zone ids are unnecessary.
2017-10-03 14:41:32 +00:00
QueueItem item;
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
MemWrite( &item.hdr.type, type );
MemWrite( &item.stringTransfer.ptr, str );
Add ability to send strings over network.
2017-09-14 17:24:35 +00:00
assert( len <= std::numeric_limits<uint16_t>::max() );
Silence some type mismatch warnings.
2017-10-16 18:42:53 +00:00
auto l16 = uint16_t( len );
Data packets can't cross data buffer boundary.
2017-11-11 14:08:03 +00:00
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
NeedDataSize( QueueDataSize[(int)type] + sizeof( l16 ) + l16 );
Data packets can't cross data buffer boundary.
2017-11-11 14:08:03 +00:00
Don't perform multiple NeedDataSize checks.
2018-06-23 00:19:23 +00:00
AppendDataUnsafe( &item, QueueDataSize[(int)type] );
AppendDataUnsafe( &l16, sizeof( l16 ) );
AppendDataUnsafe( ptr, l16 );
Add ability to send strings over network.
2017-09-14 17:24:35 +00:00
}
Implement transport of single string data. In most cases only one string is sent per message and no pointer tracking is needed. This is only plumbing work, no changes to messages have been made yet.
2020-07-25 21:13:01 +00:00
void Profiler::SendSingleString( const char* ptr, size_t len )
{
QueueItem item;
MemWrite( &item.hdr.type, QueueType::SingleStringData );
assert( len <= std::numeric_limits<uint16_t>::max() );
auto l16 = uint16_t( len );
NeedDataSize( QueueDataSize[(int)QueueType::SingleStringData] + sizeof( l16 ) + l16 );
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::SingleStringData] );
AppendDataUnsafe( &l16, sizeof( l16 ) );
AppendDataUnsafe( ptr, l16 );
}
Add second single string transfer.
2020-07-25 23:32:49 +00:00
void Profiler::SendSecondString( const char* ptr, size_t len )
{
QueueItem item;
MemWrite( &item.hdr.type, QueueType::SecondStringData );
assert( len <= std::numeric_limits<uint16_t>::max() );
auto l16 = uint16_t( len );
NeedDataSize( QueueDataSize[(int)QueueType::SecondStringData] + sizeof( l16 ) + l16 );
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::SecondStringData] );
AppendDataUnsafe( &l16, sizeof( l16 ) );
AppendDataUnsafe( ptr, l16 );
}
Compress frame images to ETC1 before sending.
2019-06-06 22:22:00 +00:00
void Profiler::SendLongString( uint64_t str, const char* ptr, size_t len, QueueType type )
Frame image transfer prototype.
2019-06-06 19:39:54 +00:00
{
Add code transfer from client to server.
2020-03-25 19:04:55 +00:00
assert( type == QueueType::FrameImageData ||
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
type == QueueType::SymbolCode ||
type == QueueType::SourceCode );
Frame image transfer prototype.
2019-06-06 19:39:54 +00:00
QueueItem item;
MemWrite( &item.hdr.type, type );
MemWrite( &item.stringTransfer.ptr, str );
assert( len <= std::numeric_limits<uint32_t>::max() );
assert( QueueDataSize[(int)type] + sizeof( uint32_t ) + len <= TargetFrameSize );
auto l32 = uint32_t( len );
NeedDataSize( QueueDataSize[(int)type] + sizeof( l32 ) + l32 );
AppendDataUnsafe( &item, QueueDataSize[(int)type] );
AppendDataUnsafe( &l32, sizeof( l32 ) );
AppendDataUnsafe( ptr, l32 );
}
Send source location answer in stream, not as separate packet.
2017-09-26 17:00:25 +00:00
void Profiler::SendSourceLocation( uint64_t ptr )
Store source location in a single object. Source file, function name and line number are now stored in a const static container object. This has the following benefits: - Slightly lighter profiling workload (3 instructions less). - Profiling queue event size is significantly reduced, by 12 bytes. This has an effect on all queue event types. - Source location grouping has now no cost, as it's performed at the compilation stage. This allows simplification of server code. The downside is that the full source location resolution is now performed in two steps, as the server has to query both source location container and strings contained within. This has almost no real impact on profiler operation.
2017-09-26 00:28:14 +00:00
{
Rename client's SourceLocation to SourceLocationData.
2018-07-27 22:34:04 +00:00
auto srcloc = (const SourceLocationData*)ptr;
Store source location in a single object. Source file, function name and line number are now stored in a const static container object. This has the following benefits: - Slightly lighter profiling workload (3 instructions less). - Profiling queue event size is significantly reduced, by 12 bytes. This has an effect on all queue event types. - Source location grouping has now no cost, as it's performed at the compilation stage. This allows simplification of server code. The downside is that the full source location resolution is now performed in two steps, as the server has to query both source location container and strings contained within. This has almost no real impact on profiler operation.
2017-09-26 00:28:14 +00:00
QueueItem item;
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
MemWrite( &item.hdr.type, QueueType::SourceLocation );
MemWrite( &item.srcloc.name, (uint64_t)srcloc->name );
MemWrite( &item.srcloc.file, (uint64_t)srcloc->file );
MemWrite( &item.srcloc.function, (uint64_t)srcloc->function );
MemWrite( &item.srcloc.line, srcloc->line );
MemWrite( &item.srcloc.r, uint8_t( ( srcloc->color ) & 0xFF ) );
MemWrite( &item.srcloc.g, uint8_t( ( srcloc->color >> 8 ) & 0xFF ) );
MemWrite( &item.srcloc.b, uint8_t( ( srcloc->color >> 16 ) & 0xFF ) );
AppendData( &item, QueueDataSize[(int)QueueType::SourceLocation] );
Store source location in a single object. Source file, function name and line number are now stored in a const static container object. This has the following benefits: - Slightly lighter profiling workload (3 instructions less). - Profiling queue event size is significantly reduced, by 12 bytes. This has an effect on all queue event types. - Source location grouping has now no cost, as it's performed at the compilation stage. This allows simplification of server code. The downside is that the full source location resolution is now performed in two steps, as the server has to query both source location container and strings contained within. This has almost no real impact on profiler operation.
2017-09-26 00:28:14 +00:00
}
No return status is needed here.
2018-06-19 17:00:57 +00:00
void Profiler::SendSourceLocationPayload( uint64_t _ptr )
Source location payload transfer. No storage yet.
2017-11-05 15:46:00 +00:00
{
auto ptr = (const char*)_ptr;
QueueItem item;
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
MemWrite( &item.hdr.type, QueueType::SourceLocationPayload );
MemWrite( &item.stringTransfer.ptr, _ptr );
Source location payload transfer. No storage yet.
2017-11-05 15:46:00 +00:00
Reduce allocated source location size by 2 bytes.
2020-07-05 15:11:15 +00:00
uint16_t len;
memcpy( &len, ptr, sizeof( len ) );
assert( len > 2 );
len -= 2;
ptr += 2;
Data packets can't cross data buffer boundary.
2017-11-11 14:08:03 +00:00
Reduce allocated source location size by 2 bytes.
2020-07-05 15:11:15 +00:00
NeedDataSize( QueueDataSize[(int)QueueType::SourceLocationPayload] + sizeof( len ) + len );
Data packets can't cross data buffer boundary.
2017-11-11 14:08:03 +00:00
Don't perform multiple NeedDataSize checks.
2018-06-23 00:19:23 +00:00
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::SourceLocationPayload] );
Reduce allocated source location size by 2 bytes.
2020-07-05 15:11:15 +00:00
AppendDataUnsafe( &len, sizeof( len ) );
AppendDataUnsafe( ptr, len );
Source location payload transfer. No storage yet.
2017-11-05 15:46:00 +00:00
}
Callstack payload transfer.
2018-06-19 17:09:43 +00:00
void Profiler::SendCallstackPayload( uint64_t _ptr )
{
auto ptr = (uintptr_t*)_ptr;
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CallstackPayload );
MemWrite( &item.stringTransfer.ptr, _ptr );
const auto sz = *ptr++;
const auto len = sz * sizeof( uint64_t );
const auto l16 = uint16_t( len );
NeedDataSize( QueueDataSize[(int)QueueType::CallstackPayload] + sizeof( l16 ) + l16 );
Don't perform multiple NeedDataSize checks.
2018-06-23 00:19:23 +00:00
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::CallstackPayload] );
AppendDataUnsafe( &l16, sizeof( l16 ) );
Callstack payload transfer.
2018-06-19 17:09:43 +00:00
Fixed compiler warnings.
2018-08-01 12:07:30 +00:00
if( compile_time_condition<sizeof( uintptr_t ) == sizeof( uint64_t )>::value )
Callstack payload transfer.
2018-06-19 17:09:43 +00:00
{
Don't perform multiple NeedDataSize checks.
2018-06-23 00:19:23 +00:00
AppendDataUnsafe( ptr, sizeof( uint64_t ) * sz );
Send callstack payload without iteration, if possible.
2018-06-23 00:13:52 +00:00
}
else
{
for( uintptr_t i=0; i<sz; i++ )
{
const auto val = uint64_t( *ptr++ );
Don't perform multiple NeedDataSize checks.
2018-06-23 00:19:23 +00:00
AppendDataUnsafe( &val, sizeof( uint64_t ) );
Send callstack payload without iteration, if possible.
2018-06-23 00:13:52 +00:00
}
Callstack payload transfer.
2018-06-19 17:09:43 +00:00
}
}
64-bit only version of callstack payload sender.
2020-02-22 13:05:01 +00:00
void Profiler::SendCallstackPayload64( uint64_t _ptr )
{
auto ptr = (uint64_t*)_ptr;
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CallstackPayload );
MemWrite( &item.stringTransfer.ptr, _ptr );
const auto sz = *ptr++;
const auto len = sz * sizeof( uint64_t );
const auto l16 = uint16_t( len );
NeedDataSize( QueueDataSize[(int)QueueType::CallstackPayload] + sizeof( l16 ) + l16 );
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::CallstackPayload] );
AppendDataUnsafe( &l16, sizeof( l16 ) );
AppendDataUnsafe( ptr, sizeof( uint64_t ) * sz );
}
Send callstack alloc payload.
2019-02-28 19:30:07 +00:00
void Profiler::SendCallstackAlloc( uint64_t _ptr )
{
auto ptr = (const char*)_ptr;
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CallstackAllocPayload );
MemWrite( &item.stringTransfer.ptr, _ptr );
Reduce memory requirements of allocated call stacks.
2020-07-05 15:33:29 +00:00
uint16_t len;
memcpy( &len, ptr, 2 );
ptr += 2;
Send callstack alloc payload.
2019-02-28 19:30:07 +00:00
Reduce memory requirements of allocated call stacks.
2020-07-05 15:33:29 +00:00
NeedDataSize( QueueDataSize[(int)QueueType::CallstackAllocPayload] + sizeof( len ) + len );
Send callstack alloc payload.
2019-02-28 19:30:07 +00:00
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::CallstackAllocPayload] );
Reduce memory requirements of allocated call stacks.
2020-07-05 15:33:29 +00:00
AppendDataUnsafe( &len, sizeof( len ) );
AppendDataUnsafe( ptr, len );
Send callstack alloc payload.
2019-02-28 19:30:07 +00:00
}
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
void Profiler::QueueCallstackFrame( uint64_t ptr )
{
#ifdef TRACY_HAS_CALLSTACK
m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::CallstackFrame, ptr } );
#else
AckServerQuery();
#endif
}
void Profiler::QueueSymbolQuery( uint64_t symbol )
{
#ifdef TRACY_HAS_CALLSTACK
// Special handling for kernel frames
if( symbol >> 63 != 0 )
{
SendSingleString( "<kernel>" );
QueueItem item;
MemWrite( &item.hdr.type, QueueType::SymbolInformation );
MemWrite( &item.symbolInformation.line, 0 );
MemWrite( &item.symbolInformation.symAddr, symbol );
AppendData( &item, QueueDataSize[(int)QueueType::SymbolInformation] );
}
else
{
m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::SymbolQuery, symbol } );
}
#else
AckServerQuery();
#endif
}
void Profiler::QueueCodeLocation( uint64_t ptr )
{
#ifdef TRACY_HAS_CALLSTACK
m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::CodeLocation, ptr } );
#else
AckServerQuery();
#endif
}
void Profiler::QueueExternalName( uint64_t ptr )
{
#ifdef TRACY_HAS_SYSTEM_TRACING
m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::ExternalName, ptr } );
#endif
}
#ifdef TRACY_HAS_CALLSTACK
Extract symbol queue item handling.
2021-10-22 23:35:01 +00:00
void Profiler::HandleSymbolQueueItem( const SymbolQueueItem& si )
{
switch( si.type )
{
case SymbolQueueItemType::CallstackFrame:
{
const auto frameData = DecodeCallstackPtr( si.ptr );
auto data = tracy_malloc_fast( sizeof( CallstackEntry ) * frameData.size );
memcpy( data, frameData.data, sizeof( CallstackEntry ) * frameData.size );
TracyLfqPrepare( QueueType::CallstackFrameSize );
MemWrite( &item->callstackFrameSizeFat.ptr, si.ptr );
MemWrite( &item->callstackFrameSizeFat.size, frameData.size );
MemWrite( &item->callstackFrameSizeFat.data, (uint64_t)data );
MemWrite( &item->callstackFrameSizeFat.imageName, (uint64_t)frameData.imageName );
TracyLfqCommit;
break;
}
case SymbolQueueItemType::SymbolQuery:
{
#ifdef __ANDROID__
// On Android it's common for code to be in mappings that are only executable
// but not readable.
if( !EnsureReadable( si.ptr ) )
{
TracyLfqPrepare( QueueType::AckServerQueryNoop );
TracyLfqCommit;
break;
}
#endif
const auto sym = DecodeSymbolAddress( si.ptr );
TracyLfqPrepare( QueueType::SymbolInformation );
MemWrite( &item->symbolInformationFat.line, sym.line );
MemWrite( &item->symbolInformationFat.symAddr, si.ptr );
MemWrite( &item->symbolInformationFat.fileString, (uint64_t)sym.file );
MemWrite( &item->symbolInformationFat.needFree, (uint8_t)sym.needFree );
TracyLfqCommit;
break;
}
case SymbolQueueItemType::CodeLocation:
{
const auto sym = DecodeCodeAddress( si.ptr );
const uint64_t offset = si.ptr - sym.symAddr;
TracyLfqPrepare( QueueType::CodeInformation );
MemWrite( &item->codeInformationFat.ptrOffset, offset );
MemWrite( &item->codeInformationFat.line, sym.line );
MemWrite( &item->codeInformationFat.symAddr, sym.symAddr );
MemWrite( &item->codeInformationFat.fileString, (uint64_t)sym.file );
MemWrite( &item->codeInformationFat.needFree, (uint8_t)sym.needFree );
TracyLfqCommit;
break;
}
#ifdef TRACY_HAS_SYSTEM_TRACING
case SymbolQueueItemType::ExternalName:
{
const char* threadName;
const char* name;
SysTraceGetExternalName( si.ptr, threadName, name );
TracyLfqPrepare( QueueType::ExternalNameMetadata );
MemWrite( &item->externalNameMetadata.thread, si.ptr );
MemWrite( &item->externalNameMetadata.name, (uint64_t)name );
MemWrite( &item->externalNameMetadata.threadName, (uint64_t)threadName );
TracyLfqCommit;
break;
}
#endif
default:
assert( false );
break;
}
}
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
void Profiler::SymbolWorker()
{
ThreadExitHandler threadExitHandler;
SetThreadName( "Tracy Symbol Worker" );
while( m_timeBegin.load( std::memory_order_relaxed ) == 0 ) std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
rpmalloc_thread_initialize();
for(;;)
{
const auto shouldExit = ShouldExit();
Drain symbols queue if on-demand and not connected.
2021-10-22 23:54:38 +00:00
#ifdef TRACY_ON_DEMAND
if( !IsConnected() )
{
if( shouldExit ) return;
Adapt to SPSCQueue interface.
2021-11-14 17:50:59 +00:00
while( m_symbolQueue.front() ) m_symbolQueue.pop();
Drain symbols queue if on-demand and not connected.
2021-10-22 23:54:38 +00:00
std::this_thread::sleep_for( std::chrono::milliseconds( 20 ) );
continue;
}
#endif
Adapt to SPSCQueue interface.
2021-11-14 17:50:59 +00:00
auto si = m_symbolQueue.front();
if( si )
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
{
Adapt to SPSCQueue interface.
2021-11-14 17:50:59 +00:00
HandleSymbolQueueItem( *si );
m_symbolQueue.pop();
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
}
else
{
if( shouldExit ) return;
std::this_thread::sleep_for( std::chrono::milliseconds( 20 ) );
}
}
}
#endif
Rework client handling of server requests.
2017-09-21 23:54:04 +00:00
bool Profiler::HandleServerQuery()
{
Issue just one read call when handling server queries.
2020-04-13 12:26:59 +00:00
ServerQueryPacket payload;
if( !m_sock->Read( &payload, sizeof( payload ), 10 ) ) return false;
Rework client handling of server requests.
2017-09-21 23:54:04 +00:00
uint8_t type;
uint64_t ptr;
Add extra parameter to server queries.
2020-03-25 19:04:01 +00:00
uint32_t extra;
Issue just one read call when handling server queries.
2020-04-13 12:26:59 +00:00
memcpy( &type, &payload.type, sizeof( payload.type ) );
memcpy( &ptr, &payload.ptr, sizeof( payload.ptr ) );
memcpy( &extra, &payload.extra, sizeof( payload.extra ) );
Rework client handling of server requests.
2017-09-21 23:54:04 +00:00
switch( type )
{
case ServerQueryString:
SendString( ptr, (const char*)ptr, QueueType::StringData );
break;
Thread name queries.
2017-09-21 23:55:02 +00:00
case ServerQueryThreadString:
Send main thread name.
2017-09-22 23:38:26 +00:00
if( ptr == m_mainThread )
{
Don't calculate known strings length.
2020-07-21 15:21:09 +00:00
SendString( ptr, "Main thread", 11, QueueType::ThreadName );
Send main thread name.
2017-09-22 23:38:26 +00:00
}
else
{
SendString( ptr, GetThreadName( ptr ), QueueType::ThreadName );
}
Thread name queries.
2017-09-21 23:55:02 +00:00
break;
Store source location in a single object. Source file, function name and line number are now stored in a const static container object. This has the following benefits: - Slightly lighter profiling workload (3 instructions less). - Profiling queue event size is significantly reduced, by 12 bytes. This has an effect on all queue event types. - Source location grouping has now no cost, as it's performed at the compilation stage. This allows simplification of server code. The downside is that the full source location resolution is now performed in two steps, as the server has to query both source location container and strings contained within. This has almost no real impact on profiler operation.
2017-09-26 00:28:14 +00:00
case ServerQuerySourceLocation:
SendSourceLocation( ptr );
break;
Receive plot data.
2017-10-13 01:36:59 +00:00
case ServerQueryPlotName:
SendString( ptr, (const char*)ptr, QueueType::PlotName );
break;
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
case ServerQueryTerminate:
return false;
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
case ServerQueryCallstackFrame:
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
QueueCallstackFrame( ptr );
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
break;
Handle frame name queries.
2018-08-04 18:48:21 +00:00
case ServerQueryFrameName:
SendString( ptr, (const char*)ptr, QueueType::FrameName );
break;
Proper handling of disconnect request.
2019-08-01 21:14:09 +00:00
case ServerQueryDisconnect:
HandleDisconnect();
return false;
Fix TRACY_NO_SYSTEM_TRACING.
2019-08-26 16:02:10 +00:00
#ifdef TRACY_HAS_SYSTEM_TRACING
Implement retrieval of external process names.
2019-08-16 17:22:23 +00:00
case ServerQueryExternalName:
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
QueueExternalName( ptr );
Implement retrieval of external process names.
2019-08-16 17:22:23 +00:00
break;
Fix TRACY_NO_SYSTEM_TRACING.
2019-08-26 16:02:10 +00:00
#endif
Implement setting client parameters from server.
2019-11-25 22:59:48 +00:00
case ServerQueryParameter:
HandleParameter( ptr );
break;
Perform symbol information queries.
2020-02-26 21:35:15 +00:00
case ServerQuerySymbol:
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
QueueSymbolQuery( ptr );
Perform symbol information queries.
2020-02-26 21:35:15 +00:00
break;
Allow disabling code transfer.
2020-08-15 23:31:54 +00:00
#ifndef TRACY_NO_CODE_TRANSFER
Add code transfer from client to server.
2020-03-25 19:04:55 +00:00
case ServerQuerySymbolCode:
HandleSymbolCodeQuery( ptr, extra );
break;
Allow disabling code transfer.
2020-08-15 23:31:54 +00:00
#endif
Query source location of each assembly instruction.
2020-04-01 19:43:03 +00:00
case ServerQueryCodeLocation:
Move symbol resolution to a separate thread.
2021-10-22 20:25:09 +00:00
QueueCodeLocation( ptr );
Query source location of each assembly instruction.
2020-04-01 19:43:03 +00:00
break;
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
case ServerQuerySourceCode:
HandleSourceCodeQuery();
break;
case ServerQueryDataTransfer:
assert( !m_queryData );
m_queryDataPtr = m_queryData = (char*)tracy_malloc( ptr + 11 );
AckServerQuery();
break;
case ServerQueryDataTransferPart:
memcpy( m_queryDataPtr, &ptr, 8 );
memcpy( m_queryDataPtr+8, &extra, 4 );
m_queryDataPtr += 12;
AckServerQuery();
break;
Fiber name transport.
2021-11-03 17:57:30 +00:00
#ifdef TRACY_FIBERS
case ServerQueryFiberName:
SendString( ptr, (const char*)ptr, QueueType::FiberName );
break;
#endif
Rework client handling of server requests.
2017-09-21 23:54:04 +00:00
default:
assert( false );
break;
}
return true;
}
Proper handling of disconnect request.
2019-08-01 21:14:09 +00:00
void Profiler::HandleDisconnect()
{
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
moodycamel::ConsumerToken token( GetQueue() );
Fix TRACY_NO_SYSTEM_TRACING.
2019-08-26 16:02:10 +00:00
#ifdef TRACY_HAS_SYSTEM_TRACING
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
if( s_sysTraceThread )
{
auto timestamp = GetTime();
for(;;)
{
const auto status = DequeueContextSwitches( token, timestamp );
if( status == DequeueStatus::ConnectionLost )
{
return;
}
else if( status == DequeueStatus::QueueEmpty )
{
if( m_bufferOffset != m_bufferStart )
{
if( !CommitData() ) return;
}
}
if( timestamp < 0 )
{
if( m_bufferOffset != m_bufferStart )
{
if( !CommitData() ) return;
}
break;
}
ClearSerial();
if( m_sock->HasData() )
{
while( m_sock->HasData() )
{
if( !HandleServerQuery() ) return;
}
if( m_bufferOffset != m_bufferStart )
{
if( !CommitData() ) return;
}
}
else
{
if( m_bufferOffset != m_bufferStart )
{
if( !CommitData() ) return;
}
std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
}
}
}
Fix TRACY_NO_SYSTEM_TRACING.
2019-08-26 16:02:10 +00:00
#endif
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
Proper handling of disconnect request.
2019-08-01 21:14:09 +00:00
QueueItem terminate;
MemWrite( &terminate.hdr.type, QueueType::Terminate );
if( !SendData( (const char*)&terminate, 1 ) ) return;
for(;;)
{
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
ClearQueues( token );
Proper handling of disconnect request.
2019-08-01 21:14:09 +00:00
if( m_sock->HasData() )
{
while( m_sock->HasData() )
{
if( !HandleServerQuery() ) return;
}
if( m_bufferOffset != m_bufferStart )
{
if( !CommitData() ) return;
}
}
else
{
if( m_bufferOffset != m_bufferStart )
{
if( !CommitData() ) return;
}
std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
}
}
}
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
void Profiler::CalibrateTimer()
{
s/TRACY_RDTSCP_SUPPORTED/TRACY_HW_TIMER/
2018-04-26 13:25:54 +00:00
#ifdef TRACY_HW_TIMER
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
std::atomic_signal_fence( std::memory_order_acq_rel );
const auto t0 = std::chrono::high_resolution_clock::now();
Use GetTime() in CalibrateTimer().
2018-04-26 13:29:09 +00:00
const auto r0 = GetTime();
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
std::atomic_signal_fence( std::memory_order_acq_rel );
Reduce timer calibration delay to 200 ms.
2017-11-25 12:34:26 +00:00
std::this_thread::sleep_for( std::chrono::milliseconds( 200 ) );
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
std::atomic_signal_fence( std::memory_order_acq_rel );
const auto t1 = std::chrono::high_resolution_clock::now();
Use GetTime() in CalibrateTimer().
2018-04-26 13:29:09 +00:00
const auto r1 = GetTime();
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
std::atomic_signal_fence( std::memory_order_acq_rel );
const auto dt = std::chrono::duration_cast<std::chrono::nanoseconds>( t1 - t0 ).count();
const auto dr = r1 - r0;
m_timerMul = double( dt ) / double( dr );
Offload TSC -> time conversion to server.
2017-09-25 22:13:24 +00:00
#else
m_timerMul = 1.;
Use rdtscp to measure time on windows.
2017-09-23 19:33:05 +00:00
#endif
}
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
void Profiler::CalibrateDelay()
{
Use constexpr instead of enum.
2020-07-30 22:58:59 +00:00
constexpr int Iterations = 50000;
Don't calculate queue delay if delayed init is used. Queue calibration requires queue access during profiler construction. This in turn requires construction of profiler data block, *which at this point is underway*, because the profiler is being constructed.
2019-06-19 15:29:04 +00:00
auto mindiff = std::numeric_limits<int64_t>::max();
for( int i=0; i<Iterations * 10; i++ )
{
const auto t0i = GetTime();
const auto t1i = GetTime();
const auto dti = t1i - t0i;
if( dti > 0 && dti < mindiff ) mindiff = dti;
}
m_resolution = mindiff;
#ifdef TRACY_DELAYED_INIT
m_delay = m_resolution;
#else
Use constexpr instead of enum.
2020-07-30 22:58:59 +00:00
constexpr int Events = Iterations * 2; // start + end
Simplify delay calibration.
2019-10-20 20:13:29 +00:00
static_assert( Events < QueuePrealloc, "Delay calibration loop will allocate memory in queue" );
Simplify access to queue producer token. Note that calibration loop needs separate token, as the thread_local instance is created after the profiler (and its calibration loop).
2017-09-26 23:03:29 +00:00
Move fake source location out of loop.
2019-10-20 20:18:05 +00:00
static const tracy::SourceLocationData __tracy_source_location { nullptr, __FUNCTION__, __FILE__, (uint32_t)__LINE__, 0 };
Add no-cpu GetTime() variant. In this version the address of cpu output variable is const, so there's no stack address calculation involved.
2017-10-29 15:12:16 +00:00
const auto t0 = GetTime();
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
for( int i=0; i<Iterations; i++ )
{
Construct queue items directly in queue memory.
2017-10-01 15:49:45 +00:00
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::ZoneBegin );
Drop support for CPU id queries.
2019-08-12 17:18:17 +00:00
MemWrite( &item->zoneBegin.time, Profiler::GetTime() );
Harden client code against unaligned memory access. There shouldn't be any changes in generated code on modern architectures, as the memcpy will be reduced to a store/load operation identical to the one generated with plain struct member access. GetTime( cpu ) needs special handling, as the MSVC intrinsic for rdtscp can't store cpu identifier in a register. Using intermediate variable would cause store to stack, read from stack, store to the destination address. Since rdtscp is only available on x86, which handles unaligned stores without any problems, we can have one place with direct struct member access.
2018-03-31 12:03:55 +00:00
MemWrite( &item->zoneBegin.srcloc, (uint64_t)&__tracy_source_location );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Construct queue items directly in queue memory.
2017-10-01 15:49:45 +00:00
}
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::ZoneEnd );
Drop support for CPU id queries.
2019-08-12 17:18:17 +00:00
MemWrite( &item->zoneEnd.time, GetTime() );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Construct queue items directly in queue memory.
2017-10-01 15:49:45 +00:00
}
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
}
Add no-cpu GetTime() variant. In this version the address of cpu output variable is const, so there's no stack address calculation involved.
2017-10-29 15:12:16 +00:00
const auto t1 = GetTime();
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
const auto dt = t1 - t0;
Simplify delay calibration.
2019-10-20 20:13:29 +00:00
m_delay = dt / Events;
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
Hide rest of statics.
2019-02-19 18:33:37 +00:00
moodycamel::ConsumerToken token( GetQueue() );
Simplify delay calibration.
2019-10-20 20:13:29 +00:00
int left = Events;
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
while( left != 0 )
{
Restrict client to C++11.
2020-05-13 16:15:12 +00:00
const auto sz = GetQueue().try_dequeue_bulk_single( token, [](const uint64_t&){}, [](QueueItem* item, size_t sz){} );
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
assert( sz > 0 );
Silence some type mismatch warnings.
2017-10-16 18:42:53 +00:00
left -= (int)sz;
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
}
Simplify delay calibration.
2019-10-20 20:13:29 +00:00
assert( GetQueue().size_approx() == 0 );
Don't calculate queue delay if delayed init is used. Queue calibration requires queue access during profiler construction. This in turn requires construction of profiler data block, *which at this point is underway*, because the profiler is being constructed.
2019-06-19 15:29:04 +00:00
#endif
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
}
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
void Profiler::ReportTopology()
{
Don't report CPU topology if delayed init is active. Reporting topology requires producer to be available, which creates a deadlock during delayed init data structures construction. Calling GetProducer() results in a call to GetProfilerThreadData(), which in turn calls GetProfilerData() to construct its thread local variable. However, at this point we already are calling GetProfilerData() (to construct the profiler itself). This would result in an incorrect double construction of data, but the code already prevents this by allowing init code to be entered only once. Hence the deadlock. Currently this is a non-issue, as no platform which can report CPU topology needs to use delayed init.
2020-01-02 21:39:05 +00:00
#ifndef TRACY_DELAYED_INIT
Transfer, display, save CPU topology data.
2019-11-29 21:41:41 +00:00
struct CpuData
{
uint32_t package;
uint32_t core;
uint32_t thread;
};
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32
Fix typo.
2020-04-23 22:55:57 +00:00
t_GetLogicalProcessorInformationEx _GetLogicalProcessorInformationEx = (t_GetLogicalProcessorInformationEx)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "GetLogicalProcessorInformationEx" );
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
if( !_GetLogicalProcessorInformationEx ) return;
DWORD psz = 0;
_GetLogicalProcessorInformationEx( RelationProcessorPackage, nullptr, &psz );
auto packageInfo = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)tracy_malloc( psz );
auto res = _GetLogicalProcessorInformationEx( RelationProcessorPackage, packageInfo, &psz );
assert( res );
DWORD csz = 0;
_GetLogicalProcessorInformationEx( RelationProcessorCore, nullptr, &csz );
auto coreInfo = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)tracy_malloc( csz );
res = _GetLogicalProcessorInformationEx( RelationProcessorCore, coreInfo, &csz );
assert( res );
SYSTEM_INFO sysinfo;
GetSystemInfo( &sysinfo );
const uint32_t numcpus = sysinfo.dwNumberOfProcessors;
auto cpuData = (CpuData*)tracy_malloc( sizeof( CpuData ) * numcpus );
for( uint32_t i=0; i<numcpus; i++ ) cpuData[i].thread = i;
int idx = 0;
auto ptr = packageInfo;
while( (char*)ptr < ((char*)packageInfo) + psz )
{
assert( ptr->Relationship == RelationProcessorPackage );
// FIXME account for GroupCount
auto mask = ptr->Processor.GroupMask[0].Mask;
int core = 0;
while( mask != 0 )
{
if( mask & 1 ) cpuData[core].package = idx;
core++;
mask >>= 1;
}
ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size);
idx++;
}
idx = 0;
ptr = coreInfo;
while( (char*)ptr < ((char*)coreInfo) + csz )
{
assert( ptr->Relationship == RelationProcessorCore );
// FIXME account for GroupCount
auto mask = ptr->Processor.GroupMask[0].Mask;
int core = 0;
while( mask != 0 )
{
if( mask & 1 ) cpuData[core].core = idx;
core++;
mask >>= 1;
}
ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size);
idx++;
}
Transfer, display, save CPU topology data.
2019-11-29 21:41:41 +00:00
for( uint32_t i=0; i<numcpus; i++ )
{
auto& data = cpuData[i];
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::CpuTopology );
Transfer, display, save CPU topology data.
2019-11-29 21:41:41 +00:00
MemWrite( &item->cpuTopology.package, data.package );
MemWrite( &item->cpuTopology.core, data.core );
MemWrite( &item->cpuTopology.thread, data.thread );
#ifdef TRACY_ON_DEMAND
DeferItem( *item );
#endif
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Transfer, display, save CPU topology data.
2019-11-29 21:41:41 +00:00
}
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
tracy_free( cpuData );
tracy_free( coreInfo );
tracy_free( packageInfo );
Report CPU topology on Linux.
2019-11-30 00:51:29 +00:00
#elif defined __linux__
const int numcpus = std::thread::hardware_concurrency();
auto cpuData = (CpuData*)tracy_malloc( sizeof( CpuData ) * numcpus );
memset( cpuData, 0, sizeof( CpuData ) * numcpus );
const char* basePath = "/sys/devices/system/cpu/cpu";
for( int i=0; i<numcpus; i++ )
{
char path[1024];
sprintf( path, "%s%i/topology/physical_package_id", basePath, i );
char buf[1024];
FILE* f = fopen( path, "rb" );
Cosmetics.
2020-06-23 23:14:55 +00:00
if( !f )
{
tracy_free( cpuData );
Check for null FILE handles in ReportTopology On Linux `/sys` is not guaranteed to exist. When it doesn't, tracy would crash with a SIGSEGV due to a nullptr dereference. Not actually sure how well tracy clients will handle the case where this information is missing, though.
2020-06-21 15:46:53 +00:00
return;
}
Report CPU topology on Linux.
2019-11-30 00:51:29 +00:00
auto read = fread( buf, 1, 1024, f );
buf[read] = '\0';
fclose( f );
cpuData[i].package = uint32_t( atoi( buf ) );
cpuData[i].thread = i;
sprintf( path, "%s%i/topology/core_id", basePath, i );
f = fopen( path, "rb" );
read = fread( buf, 1, 1024, f );
buf[read] = '\0';
fclose( f );
cpuData[i].core = uint32_t( atoi( buf ) );
}
Boring warning fixes.
2020-03-01 00:48:20 +00:00
for( int i=0; i<numcpus; i++ )
Report CPU topology on Linux.
2019-11-30 00:51:29 +00:00
{
auto& data = cpuData[i];
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::CpuTopology );
Report CPU topology on Linux.
2019-11-30 00:51:29 +00:00
MemWrite( &item->cpuTopology.package, data.package );
MemWrite( &item->cpuTopology.core, data.core );
MemWrite( &item->cpuTopology.thread, data.thread );
#ifdef TRACY_ON_DEMAND
DeferItem( *item );
#endif
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Report CPU topology on Linux.
2019-11-30 00:51:29 +00:00
}
tracy_free( cpuData );
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
#endif
Don't report CPU topology if delayed init is active. Reporting topology requires producer to be available, which creates a deadlock during delayed init data structures construction. Calling GetProducer() results in a call to GetProfilerThreadData(), which in turn calls GetProfilerData() to construct its thread local variable. However, at this point we already are calling GetProfilerData() (to construct the profiler itself). This would result in an incorrect double construction of data, but the code already prevents this by allowing init code to be entered only once. Hence the deadlock. Currently this is a non-issue, as no platform which can report CPU topology needs to use delayed init.
2020-01-02 21:39:05 +00:00
#endif
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
}
Fill in thread id during dequeue, not during enqueue.
2019-07-29 22:42:31 +00:00
void Profiler::SendCallstack( int depth, const char* skipBefore )
Allow skipping functions on top of call stack. Note that this is on-client performance intensive and shouldn't be used, except in special situations, like processing crashes.
2018-08-20 20:20:44 +00:00
{
#ifdef TRACY_HAS_CALLSTACK
auto ptr = Callstack( depth );
Move callstack cutting to a separate function.
2019-03-05 01:15:13 +00:00
CutCallstack( ptr, skipBefore );
Implement callstack serialization.
2021-10-10 14:14:17 +00:00
TracyQueuePrepare( QueueType::Callstack );
No need for lean callstack, callstack memory messages.
2020-07-26 12:15:16 +00:00
MemWrite( &item->callstackFat.ptr, (uint64_t)ptr );
Implement callstack serialization.
2021-10-10 14:14:17 +00:00
TracyQueueCommit( callstackFatThread );
Move callstack cutting to a separate function.
2019-03-05 01:15:13 +00:00
#endif
}
void Profiler::CutCallstack( void* callstack, const char* skipBefore )
{
#ifdef TRACY_HAS_CALLSTACK
auto data = (uintptr_t*)callstack;
Allow skipping functions on top of call stack. Note that this is on-client performance intensive and shouldn't be used, except in special situations, like processing crashes.
2018-08-20 20:20:44 +00:00
const auto sz = *data++;
Use proper type.
2018-08-20 23:24:00 +00:00
uintptr_t i;
Allow skipping functions on top of call stack. Note that this is on-client performance intensive and shouldn't be used, except in special situations, like processing crashes.
2018-08-20 20:20:44 +00:00
for( i=0; i<sz; i++ )
{
Use fast callstack frame decoding to cut callstack.
2019-03-05 01:39:23 +00:00
auto name = DecodeCallstackPtrFast( uint64_t( data[i] ) );
const bool found = strcmp( name, skipBefore ) == 0;
Allow skipping functions on top of call stack. Note that this is on-client performance intensive and shouldn't be used, except in special situations, like processing crashes.
2018-08-20 20:20:44 +00:00
if( found )
{
i++;
break;
}
}
if( i != sz )
{
memmove( data, data + i, ( sz - i ) * sizeof( uintptr_t* ) );
*--data = sz - i;
}
#endif
}
CPU usage retrieval.
2019-02-21 20:59:02 +00:00
#ifdef TRACY_HAS_SYSTIME
void Profiler::ProcessSysTime()
{
Don't collect sys time after application has exited.
2019-10-29 22:05:14 +00:00
if( m_shutdown.load( std::memory_order_relaxed ) ) return;
CPU usage retrieval.
2019-02-21 20:59:02 +00:00
auto t = std::chrono::high_resolution_clock::now().time_since_epoch().count();
if( t - m_sysTimeLast > 100000000 ) // 100 ms
{
Don't send CPU usage data when there's no readings.
2019-02-25 14:11:35 +00:00
auto sysTime = m_sysTime.Get();
if( sysTime >= 0 )
{
m_sysTimeLast = t;
CPU usage retrieval.
2019-02-21 20:59:02 +00:00
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::SysTimeReport );
Don't send CPU usage data when there's no readings.
2019-02-25 14:11:35 +00:00
MemWrite( &item->sysTime.time, GetTime() );
MemWrite( &item->sysTime.sysTime, sysTime );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Don't send CPU usage data when there's no readings.
2019-02-25 14:11:35 +00:00
}
CPU usage retrieval.
2019-02-21 20:59:02 +00:00
}
}
#endif
Implement setting client parameters from server.
2019-11-25 22:59:48 +00:00
void Profiler::HandleParameter( uint64_t payload )
{
assert( m_paramCallback );
const auto idx = uint32_t( payload >> 32 );
const auto val = int32_t( payload & 0xFFFFFFFF );
m_paramCallback( idx, val );
Move server query acknowledgement to a separate function.
2021-02-03 21:32:31 +00:00
AckServerQuery();
Implement setting client parameters from server.
2019-11-25 22:59:48 +00:00
}
Add code transfer from client to server.
2020-03-25 19:04:55 +00:00
void Profiler::HandleSymbolCodeQuery( uint64_t symbol, uint32_t size )
{
Ensure that mappings have read permission before decoding symbols and reading code. (#129)
2020-11-21 20:05:39 +00:00
#ifdef __ANDROID__
// On Android it's common for code to be in mappings that are only executable
// but not readable.
if( !EnsureReadable( symbol ) )
{
One more query to acknowledge.
2021-06-12 23:08:04 +00:00
AckServerQuery();
Ensure that mappings have read permission before decoding symbols and reading code. (#129)
2020-11-21 20:05:39 +00:00
return;
}
#endif
Add code transfer from client to server.
2020-03-25 19:04:55 +00:00
SendLongString( symbol, (const char*)symbol, size, QueueType::SymbolCode );
}
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
void Profiler::HandleSourceCodeQuery()
{
assert( m_exectime != 0 );
assert( m_queryData );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
InitRpmalloc();
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
struct stat st;
if( stat( m_queryData, &st ) == 0 && (uint64_t)st.st_mtime < m_exectime && st.st_size < ( TargetFrameSize - 16 ) )
{
FILE* f = fopen( m_queryData, "rb" );
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( m_queryData );
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
if( f )
{
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
auto ptr = (char*)tracy_malloc_fast( st.st_size );
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
auto rd = fread( ptr, 1, st.st_size, f );
fclose( f );
Fix type in comparison.
2021-02-07 20:08:24 +00:00
if( rd == (size_t)st.st_size )
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
{
SendLongString( (uint64_t)ptr, ptr, rd, QueueType::SourceCode );
}
else
{
AckSourceCodeNotAvailable();
}
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( ptr );
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
}
else
{
AckSourceCodeNotAvailable();
}
}
else
{
Don't init rpmalloc, if we know it has been done already.
2021-06-09 23:48:11 +00:00
tracy_free_fast( m_queryData );
Last-resort source code transfer from client to server.
2021-02-03 23:03:25 +00:00
AckSourceCodeNotAvailable();
}
m_queryData = nullptr;
}
Drop support for Cygwin.
2021-10-07 21:28:40 +00:00
#if defined _WIN32 && defined TRACY_TIMER_QPC
Add support for QPC timer.
2020-04-07 20:01:31 +00:00
int64_t Profiler::GetTimeQpc()
{
LARGE_INTEGER t;
QueryPerformanceCounter( &t );
return t.QuadPart;
}
#endif
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
}
Change TRACY_DISABLE to TRACY_ENABLE. By default tracy is now disabled.
2017-10-16 19:34:39 +00:00
C API prototype.
2019-01-14 19:55:37 +00:00
#ifdef __cplusplus
extern "C" {
#endif
Make C API symbols visible across dlls.
2019-10-03 20:39:26 +00:00
TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin( const struct ___tracy_source_location_data* srcloc, int active )
C API prototype.
2019-01-14 19:55:37 +00:00
{
___tracy_c_zone_context ctx;
#ifdef TRACY_ON_DEMAND
Prevent direct access to s_profiler.
2019-02-19 17:38:08 +00:00
ctx.active = active && tracy::GetProfiler().IsConnected();
C API prototype.
2019-01-14 19:55:37 +00:00
#else
ctx.active = active;
#endif
if( !ctx.active ) return ctx;
Prevent direct access to s_profiler.
2019-02-19 17:38:08 +00:00
const auto id = tracy::GetProfiler().GetNextZoneId();
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
ctx.id = id;
Allow disabling zone verification.
2019-01-15 17:59:05 +00:00
#ifndef TRACY_NO_VERIFY
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
tracy::MemWrite( &item->zoneValidation.id, id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
}
Allow disabling zone verification.
2019-01-15 17:59:05 +00:00
#endif
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneBegin );
Drop support for CPU id queries.
2019-08-12 17:18:17 +00:00
tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
tracy::MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneBeginThread );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
}
C API prototype.
2019-01-14 19:55:37 +00:00
return ctx;
}
Make C API symbols visible across dlls.
2019-10-03 20:39:26 +00:00
TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_callstack( const struct ___tracy_source_location_data* srcloc, int depth, int active )
C API prototype.
2019-01-14 19:55:37 +00:00
{
___tracy_c_zone_context ctx;
#ifdef TRACY_ON_DEMAND
Prevent direct access to s_profiler.
2019-02-19 17:38:08 +00:00
ctx.active = active && tracy::GetProfiler().IsConnected();
C API prototype.
2019-01-14 19:55:37 +00:00
#else
ctx.active = active;
#endif
if( !ctx.active ) return ctx;
Prevent direct access to s_profiler.
2019-02-19 17:38:08 +00:00
const auto id = tracy::GetProfiler().GetNextZoneId();
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
ctx.id = id;
Allow disabling zone verification.
2019-01-15 17:59:05 +00:00
#ifndef TRACY_NO_VERIFY
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
tracy::MemWrite( &item->zoneValidation.id, id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
}
Allow disabling zone verification.
2019-01-15 17:59:05 +00:00
#endif
Send callstacks before sending events they belong to.
2020-09-29 14:39:56 +00:00
tracy::GetProfiler().SendCallstack( depth );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneBeginCallstack );
Drop support for CPU id queries.
2019-08-12 17:18:17 +00:00
tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
tracy::MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneBeginThread );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
}
C API prototype.
2019-01-14 19:55:37 +00:00
return ctx;
}
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_alloc( uint64_t srcloc, int active )
{
___tracy_c_zone_context ctx;
#ifdef TRACY_ON_DEMAND
ctx.active = active && tracy::GetProfiler().IsConnected();
#else
ctx.active = active;
#endif
Free source location, if zone is not active.
2019-12-05 23:42:42 +00:00
if( !ctx.active )
{
tracy::tracy_free( (void*)srcloc );
return ctx;
}
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
const auto id = tracy::GetProfiler().GetNextZoneId();
ctx.id = id;
#ifndef TRACY_NO_VERIFY
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
tracy::MemWrite( &item->zoneValidation.id, id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
}
#endif
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneBeginAllocSrcLoc );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
tracy::MemWrite( &item->zoneBegin.srcloc, srcloc );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneBeginThread );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
}
return ctx;
}
TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_alloc_callstack( uint64_t srcloc, int depth, int active )
{
___tracy_c_zone_context ctx;
#ifdef TRACY_ON_DEMAND
ctx.active = active && tracy::GetProfiler().IsConnected();
#else
ctx.active = active;
#endif
Free source location, if zone is not active.
2019-12-05 23:42:42 +00:00
if( !ctx.active )
{
tracy::tracy_free( (void*)srcloc );
return ctx;
}
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
const auto id = tracy::GetProfiler().GetNextZoneId();
ctx.id = id;
#ifndef TRACY_NO_VERIFY
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
tracy::MemWrite( &item->zoneValidation.id, id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
}
#endif
Send callstacks before sending events they belong to.
2020-09-29 14:39:56 +00:00
tracy::GetProfiler().SendCallstack( depth );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneBeginAllocSrcLocCallstack );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
tracy::MemWrite( &item->zoneBegin.srcloc, srcloc );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneBeginThread );
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
}
return ctx;
}
Make C API symbols visible across dlls.
2019-10-03 20:39:26 +00:00
TRACY_API void ___tracy_emit_zone_end( TracyCZoneCtx ctx )
C API prototype.
2019-01-14 19:55:37 +00:00
{
if( !ctx.active ) return;
Allow disabling zone verification.
2019-01-15 17:59:05 +00:00
#ifndef TRACY_NO_VERIFY
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
tracy::MemWrite( &item->zoneValidation.id, ctx.id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
}
Allow disabling zone verification.
2019-01-15 17:59:05 +00:00
#endif
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneEnd );
Drop support for CPU id queries.
2019-08-12 17:18:17 +00:00
tracy::MemWrite( &item->zoneEnd.time, tracy::Profiler::GetTime() );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneEndThread );
Send zone validation messages. This is only performed for C API, as C++ scoped zones are always properly ordered, due to RAII. With manual submission of zone begin and end events there's no such guarantee.
2019-01-14 21:28:58 +00:00
}
C API prototype.
2019-01-14 19:55:37 +00:00
}
Make C API symbols visible across dlls.
2019-10-03 20:39:26 +00:00
TRACY_API void ___tracy_emit_zone_text( TracyCZoneCtx ctx, const char* txt, size_t size )
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
{
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
assert( size < std::numeric_limits<uint16_t>::max() );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
if( !ctx.active ) return;
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
auto ptr = (char*)tracy::tracy_malloc( size );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
memcpy( ptr, txt, size );
#ifndef TRACY_NO_VERIFY
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
tracy::MemWrite( &item->zoneValidation.id, ctx.id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
}
#endif
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneText );
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
tracy::MemWrite( &item->zoneTextFat.text, (uint64_t)ptr );
tracy::MemWrite( &item->zoneTextFat.size, (uint16_t)size );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneTextFatThread );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
}
}
Make C API symbols visible across dlls.
2019-10-03 20:39:26 +00:00
TRACY_API void ___tracy_emit_zone_name( TracyCZoneCtx ctx, const char* txt, size_t size )
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
{
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
assert( size < std::numeric_limits<uint16_t>::max() );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
if( !ctx.active ) return;
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
auto ptr = (char*)tracy::tracy_malloc( size );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
memcpy( ptr, txt, size );
#ifndef TRACY_NO_VERIFY
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
tracy::MemWrite( &item->zoneValidation.id, ctx.id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
}
#endif
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneName );
Preserve zone text, zone name string length.
2020-07-21 18:09:25 +00:00
tracy::MemWrite( &item->zoneTextFat.text, (uint64_t)ptr );
tracy::MemWrite( &item->zoneTextFat.size, (uint16_t)size );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneTextFatThread );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
}
}
Adding ZoneColor to set a dynamic color override to an existing zone.
2020-11-27 11:37:35 +00:00
TRACY_API void ___tracy_emit_zone_color( TracyCZoneCtx ctx, uint32_t color ) {
if( !ctx.active ) return;
#ifndef TRACY_NO_VERIFY
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Adding ZoneColor to set a dynamic color override to an existing zone.
2020-11-27 11:37:35 +00:00
tracy::MemWrite( &item->zoneValidation.id, ctx.id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Adding ZoneColor to set a dynamic color override to an existing zone.
2020-11-27 11:37:35 +00:00
}
#endif
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneColor );
Adding ZoneColor to set a dynamic color override to an existing zone.
2020-11-27 11:37:35 +00:00
tracy::MemWrite( &item->zoneColor.r, uint8_t( ( color ) & 0xFF ) );
tracy::MemWrite( &item->zoneColor.g, uint8_t( ( color >> 8 ) & 0xFF ) );
tracy::MemWrite( &item->zoneColor.b, uint8_t( ( color >> 16 ) & 0xFF ) );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneColorThread );
Adding ZoneColor to set a dynamic color override to an existing zone.
2020-11-27 11:37:35 +00:00
}
}
Implement transfer of integral values for zones.
2020-05-24 14:13:09 +00:00
TRACY_API void ___tracy_emit_zone_value( TracyCZoneCtx ctx, uint64_t value )
{
if( !ctx.active ) return;
#ifndef TRACY_NO_VERIFY
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValidation );
Implement transfer of integral values for zones.
2020-05-24 14:13:09 +00:00
tracy::MemWrite( &item->zoneValidation.id, ctx.id );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValidationThread );
Implement transfer of integral values for zones.
2020-05-24 14:13:09 +00:00
}
#endif
{
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueuePrepareC( tracy::QueueType::ZoneValue );
Implement transfer of integral values for zones.
2020-05-24 14:13:09 +00:00
tracy::MemWrite( &item->zoneValue.value, value );
Use possibly-synchronous macros for C API zones.
2021-10-09 13:51:29 +00:00
TracyQueueCommitC( zoneValueThread );
Implement transfer of integral values for zones.
2020-05-24 14:13:09 +00:00
}
}
Add secure alloc/free macros.
2020-06-23 23:33:26 +00:00
TRACY_API void ___tracy_emit_memory_alloc( const void* ptr, size_t size, int secure ) { tracy::Profiler::MemAlloc( ptr, size, secure != 0 ); }
TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int depth, int secure ) { tracy::Profiler::MemAllocCallstack( ptr, size, depth, secure != 0 ); }
TRACY_API void ___tracy_emit_memory_free( const void* ptr, int secure ) { tracy::Profiler::MemFree( ptr, secure != 0 ); }
TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int depth, int secure ) { tracy::Profiler::MemFreeCallstack( ptr, depth, secure != 0 ); }
Support memory pools in the C API.
2020-11-15 14:23:22 +00:00
TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, int secure, const char* name ) { tracy::Profiler::MemAllocNamed( ptr, size, secure != 0, name ); }
TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int depth, int secure, const char* name ) { tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, secure != 0, name ); }
TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, int secure, const char* name ) { tracy::Profiler::MemFreeNamed( ptr, secure != 0, name ); }
TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int depth, int secure, const char* name ) { tracy::Profiler::MemFreeCallstackNamed( ptr, depth, secure != 0, name ); }
Make C API symbols visible across dlls.
2019-10-03 20:39:26 +00:00
TRACY_API void ___tracy_emit_frame_mark( const char* name ) { tracy::Profiler::SendFrameMark( name ); }
TRACY_API void ___tracy_emit_frame_mark_start( const char* name ) { tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgStart ); }
TRACY_API void ___tracy_emit_frame_mark_end( const char* name ) { tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgEnd ); }
TRACY_API void ___tracy_emit_frame_image( const void* image, uint16_t w, uint16_t h, uint8_t offset, int flip ) { tracy::Profiler::SendFrameImage( image, w, h, offset, flip ); }
TRACY_API void ___tracy_emit_plot( const char* name, double val ) { tracy::Profiler::PlotData( name, val ); }
Plumbing for message call stacks.
2019-11-14 22:40:41 +00:00
TRACY_API void ___tracy_emit_message( const char* txt, size_t size, int callstack ) { tracy::Profiler::Message( txt, size, callstack ); }
TRACY_API void ___tracy_emit_messageL( const char* txt, int callstack ) { tracy::Profiler::Message( txt, callstack ); }
TRACY_API void ___tracy_emit_messageC( const char* txt, size_t size, uint32_t color, int callstack ) { tracy::Profiler::MessageColor( txt, size, color, callstack ); }
TRACY_API void ___tracy_emit_messageLC( const char* txt, uint32_t color, int callstack ) { tracy::Profiler::MessageColor( txt, color, callstack ); }
Make C API symbols visible across dlls.
2019-10-03 20:39:26 +00:00
TRACY_API void ___tracy_emit_message_appinfo( const char* txt, size_t size ) { tracy::Profiler::MessageAppInfo( txt, size ); }
`___tracy_alloc_*` take pointer-size pairs This enables better bindings in languages that do not have 0-terminated strings for source/function name. It does not introduce any additional overhead in languages that do use 0-terminated strings, either, but it _is_ a breaking API change. Fixes https://github.com/wolfpld/tracy/issues/53
2020-06-20 14:31:12 +00:00
TRACY_API uint64_t ___tracy_alloc_srcloc( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz ) {
return tracy::Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz );
}
TRACY_API uint64_t ___tracy_alloc_srcloc_name( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz ) {
return tracy::Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz );
}
Add C API for plots and messages.
2019-06-24 18:54:43 +00:00
Expose TRACY_MANUAL_LIFETIME APIs to C API clients These are extremely useful for ecosystems such as Rust. There are a couple of reasons why: 1. Rust strongly advises against relying on life before/after main, as it is difficult to reason about. Most users working in Rust will generally be quite surprised when encountering this concept. 2. Rust and its package manager makes it easy to use packages (crates) and somewhat less straightforward to consider the implications of including a dependency. In case of the `rust_tracy_client` set of packages, I currently have to warn throughout the documentation of the package that simply adding a dependency on the bindings package is sufficient to potentially accidentally broadcast a lot of information about the instrumented binary to the broader world. This seems like a major footgun given how easy is it to forget about having added this dependency. Ability to manually manage the lifetime of the profiler would be a great solution to these problems.
2021-09-18 11:25:03 +00:00
# ifdef TRACY_MANUAL_LIFETIME
TRACY_API void ___tracy_startup_profiler( void )
{
tracy::StartupProfiler();
}
TRACY_API void ___tracy_shutdown_profiler( void )
{
tracy::ShutdownProfiler();
}
# endif
C API prototype.
2019-01-14 19:55:37 +00:00
#ifdef __cplusplus
}
#endif
Change TRACY_DISABLE to TRACY_ENABLE. By default tracy is now disabled.
2017-10-16 19:34:39 +00:00
#endif
Reference in New Issue Copy Permalink