mirror/tracy
1
0
Fork 0
mirror of https://github.com/wolfpld/tracy.git synced 2024-11-23 14:54:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
02aae23a98
tracy/client/TracyProfiler.cpp

3167 lines
98 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
Host info discovery.
2018-08-19 16:15:14 +00:00
#ifdef __CYGWIN__
# include <windows.h>
Use windows thread ids on cygwin.
2019-08-13 14:20:24 +00:00
# include <unistd.h>
Enable crash handler on cygwin. Crash is properly recorded, but the profiler hangs while waiting for shutdown finish.
2019-11-07 18:08:43 +00:00
# include <tlhelp32.h>
Host info discovery.
2018-08-19 16:15:14 +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"
#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>
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"
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
Use mach_absolute_time() to get time on iOS.
2019-02-21 13:45:13 +00:00
#if defined TRACY_HW_TIMER && __ARM_ARCH >= 6 && !defined TARGET_OS_IOS
Test if HW timer can be used on arm.
2018-04-27 14:58:45 +00:00
# include <signal.h>
# include <setjmp.h>
#endif
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
#if defined _WIN32 || defined __CYGWIN__
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
Add include for built-in __get_cpuid() on gcc/clang.
2019-07-10 00:09:19 +00:00
#if !defined _WIN32 && !defined __CYGWIN__ && ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 )
# include <cpuid.h>
#endif
Include <mutex> for std::once.
2019-11-05 20:40:35 +00:00
#if !( ( ( defined _WIN32 || defined __CYGWIN__ ) && _WIN32_WINNT >= _WIN32_WINNT_VISTA ) || defined __linux__ )
# include <mutex>
#endif
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
namespace tracy
{
Fix for using Tracy with multithreaded NT loader in Windows 10 RS5 (Issue #26).
2018-10-28 01:13:59 +00:00
namespace
{
Use generic std::call_once() on other platforms.
2019-07-25 21:30:47 +00:00
# if ( defined _WIN32 || defined __CYGWIN__ ) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
BOOL CALLBACK InitOnceCallback( PINIT_ONCE /*initOnce*/, PVOID /*Parameter*/, PVOID* /*Context*/)
Fix for using Tracy with multithreaded NT loader in Windows 10 RS5 (Issue #26).
2018-10-28 01:13:59 +00:00
{
rpmalloc_initialize();
return TRUE;
}
Fix for using Tracy with multithreaded NT loader in Windows 10 RS5 (Issue #26) [Take 2].
2018-10-29 01:55:55 +00:00
INIT_ONCE InitOnce = INIT_ONCE_STATIC_INIT;
Use generic std::call_once() on other platforms.
2019-07-25 21:30:47 +00:00
# elif defined __linux__
Use pthread_once() to initialize rpmalloc on linux.
2019-07-19 18:15:56 +00:00
void InitOnceCallback()
{
rpmalloc_initialize();
}
pthread_once_t once_control = PTHREAD_ONCE_INIT;
Use generic std::call_once() on other platforms.
2019-07-25 21:30:47 +00:00
# else
void InitOnceCallback()
{
rpmalloc_initialize();
}
std::once_flag once_flag;
# endif
Use pthread_once() to initialize rpmalloc on linux.
2019-07-19 18:15:56 +00:00
}
Fix for using Tracy with multithreaded NT loader in Windows 10 RS5 (Issue #26).
2018-10-28 01:13:59 +00:00
Fix for using Tracy with multithreaded NT loader in Windows 10 RS5 (Issue #26) [Take 2].
2018-10-29 01:55:55 +00:00
struct RPMallocInit
{
RPMallocInit()
{
Use generic std::call_once() on other platforms.
2019-07-25 21:30:47 +00:00
# if ( defined _WIN32 || defined __CYGWIN__ ) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
Use pthread_once() to initialize rpmalloc on linux.
2019-07-19 18:15:56 +00:00
InitOnceExecuteOnce( &InitOnce, InitOnceCallback, nullptr, nullptr );
Use generic std::call_once() on other platforms.
2019-07-25 21:30:47 +00:00
# elif defined __linux__
Use pthread_once() to initialize rpmalloc on linux.
2019-07-19 18:15:56 +00:00
pthread_once( &once_control, InitOnceCallback );
Use generic std::call_once() on other platforms.
2019-07-25 21:30:47 +00:00
# else
std::call_once( once_flag, InitOnceCallback );
# endif
Fix for using Tracy with multithreaded NT loader in Windows 10 RS5 (Issue #26).
2018-10-28 01:13:59 +00:00
rpmalloc_thread_initialize();
}
Initialize rpmalloc.
2017-10-14 14:59:43 +00:00
};
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
{
uint64_t val;
};
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
#endif
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);
Fix multiple build errors when compiling with MinGW.
2019-08-04 09:00:38 +00:00
#if defined _WIN32 || defined __CYGWIN__
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 )
{
#if defined _WIN32 || defined __CYGWIN__
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
exit( 0 );
}
static int64_t SetupHwTimer()
{
Add support for QPC timer.
2020-04-07 20:01:31 +00:00
#ifndef TRACY_TIMER_QPC
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 ) ) )
{
const char* noCheck = getenv( "TRACY_NO_INVARIANT_CHECK" );
if( !noCheck || noCheck[0] != '1' )
{
Add support for QPC timer.
2020-04-07 20:01:31 +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 define to use lower resolution timer." );
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
Restore process name retrieval on cygwin.
2017-11-10 18:46:31 +00:00
#elif defined _GNU_SOURCE || defined __CYGWIN__
Fixed __ANDROID_API__ < 21 build and FD_SET usage.
2018-08-01 17:18:40 +00:00
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
}
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;
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
#if defined _WIN32 || defined __CYGWIN__
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 )
{
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
# ifdef __CYGWIN__
Perform windows version discovery.
2018-08-19 16:43:26 +00:00
ptr += sprintf( ptr, "OS: Windows (Cygwin)\n" );
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
# elif defined __MINGW32__
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 );
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
# ifdef __CYGWIN__
Perform windows version discovery.
2018-08-19 16:43:26 +00:00
ptr += sprintf( ptr, "OS: Windows %i.%i.%i (Cygwin)\n", ver.dwMajorVersion, ver.dwMinorVersion, ver.dwBuildNumber );
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
# elif defined __MINGW32__
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
Fix mistakes from MingW support commit.
2019-01-19 13:03:43 +00:00
#if defined _WIN32 || defined __CYGWIN__
Host info discovery.
2018-08-19 16:15:14 +00:00
# ifndef __CYGWIN__
InitWinSock();
# endif
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
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() );
Fix builds with MingW.
2019-01-19 11:03:30 +00:00
#if defined _WIN32 || defined __CYGWIN__
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()
{
#if defined _WIN32 || defined __CYGWIN__
return uint64_t( GetCurrentProcessId() );
#else
return uint64_t( getpid() );
#endif
}
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
}
Enable crash handler on cygwin. Crash is properly recorded, but the profiler hangs while waiting for shutdown finish.
2019-11-07 18:08:43 +00:00
#if defined _WIN32 || defined __CYGWIN__
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 )
{
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( 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;
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Send crash report.
2018-08-20 00:07:31 +00:00
Fill in thread id during dequeue, not during enqueue.
2019-07-29 22:42:31 +00:00
GetProfiler().SendCallstack( 60, "KiUserExceptionDispatcher" );
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 );
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;
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';
}
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( 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;
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
Fill in thread id during dequeue, not during enqueue.
2019-07-29 22:42:31 +00:00
GetProfiler().SendCallstack( 60, "__kernel_rt_sigreturn" );
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;
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
static Thread* s_compressThread;
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
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()
{
#if defined _WIN32 || defined __CYGWIN__
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();
Fix typo.
2020-02-11 14:12:06 +00:00
TRACY_API void InitRPMallocThread();
Always use init once to initialize rpmalloc.
2020-01-30 18:38:05 +00:00
void InitRPMallocThread()
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
{
Always use init once to initialize rpmalloc.
2020-01-30 18:38:05 +00:00
RPMallocInit rpinit;
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
rpmalloc_thread_initialize();
}
struct ProfilerData
{
int64_t initTime = SetupHwTimer();
RPMallocInit rpmalloc_init;
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 } ) {}
RPMallocInit rpmalloc_init;
ProducerWrapper token;
GpuCtxWrapper gpuCtx;
# ifdef TRACY_ON_DEMAND
LuaZoneState luaZoneState;
# endif
};
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;
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
{
s_profilerData = new ProfilerData;
s_profilerData->profiler.SpawnWorkerThreads();
}
static ProfilerData& GetProfilerData()
{
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
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
{
Fixed rogue TAB indentation
2020-07-08 10:52:00 +00:00
delete 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();
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;
while( !profilerDataLock.compare_exchange_strong( expected, 1, std::memory_order_release, std::memory_order_relaxed ) ) { expected = 0; }
ptr = profilerData.load( std::memory_order_acquire );
if( !ptr )
{
ptr = (ProfilerData*)malloc( sizeof( ProfilerData ) );
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
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;
}
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; }
Proper init order of thread local thread handle.
2019-06-26 17:32:52 +00:00
TRACY_API uint64_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
Replace rpmalloc_thread_initialize with InitRPMallocThread().
2020-01-25 15:56:54 +00:00
TRACY_API void InitRPMallocThread()
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
{
rpmalloc_thread_initialize();
}
// 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;
RPMallocInit and RPMallocThreadInit are identical.
2019-07-29 23:14:40 +00:00
thread_local RPMallocInit init_order(106) s_rpmalloc_thread_init;
Initialize tracy before anything else.
2017-10-16 22:36:15 +00:00
// 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() };
Measure time of initialization start.
2017-10-16 23:07:34 +00:00
static RPMallocInit init_order(102) s_rpmalloc_init;
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; }
Fix cygwin.
2019-07-25 22:02:57 +00:00
# ifdef __CYGWIN__
// Hackfix for cygwin reporting memory frees without matching allocations. WTF?
TRACY_API uint64_t GetThreadHandle() { return detail::GetThreadHandleImpl(); }
# else
Proper init order of thread local thread handle.
2019-06-26 17:32:52 +00:00
TRACY_API uint64_t GetThreadHandle() { return s_threadHandle.val; }
Fix cygwin.
2019-07-25 22:02:57 +00:00
# endif
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 )
Store frame images in queue.
2019-06-26 20:50:56 +00:00
, m_fiQueue( 16 )
, m_fiDequeue( 16 )
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 )
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
const char* noExitEnv = getenv( "TRACY_NO_EXIT" );
if( noExitEnv && noExitEnv[0] == '1' )
{
m_noExit = true;
}
#endif
Allow specification of port through env variable.
2020-03-08 15:14:36 +00:00
const char* userPort = getenv( "TRACY_PORT" );
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()
{
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_malloc( sizeof( Thread ) );
new(s_thread) Thread( LaunchWorker, this );
More precise profiler init end time measurement.
2017-10-16 23:07:54 +00:00
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
s_compressThread = (Thread*)tracy_malloc( sizeof( Thread ) );
new(s_compressThread) Thread( LaunchCompressWorker, this );
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
Enable crash handler on cygwin. Crash is properly recorded, but the profiler hangs while waiting for shutdown finish.
2019-11-07 18:08:43 +00:00
#if defined _WIN32 || defined __CYGWIN__
Native threads are used on mingw.
2019-11-07 18:01:42 +00:00
s_profilerThreadId = GetThreadId( s_thread->Handle() );
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
AddVectoredExceptionHandler( 1, CrashFilter );
#endif
Implement crash handler on Linux.
2018-08-20 12:30:56 +00:00
#ifdef __linux__
struct sigaction threadFreezer = {};
threadFreezer.sa_handler = ThreadFreezer;
sigaction( SIGPWR, &threadFreezer, nullptr );
struct sigaction crashHandler = {};
crashHandler.sa_sigaction = CrashHandler;
crashHandler.sa_flags = SA_SIGINFO;
sigaction( SIGILL, &crashHandler, nullptr );
sigaction( SIGFPE, &crashHandler, nullptr );
sigaction( SIGSEGV, &crashHandler, nullptr );
sigaction( SIGPIPE, &crashHandler, nullptr );
sigaction( SIGBUS, &crashHandler, nullptr );
#endif
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
#ifdef TRACY_HAS_SYSTEM_TRACING
if( s_sysTraceThread )
{
SysTraceStop();
s_sysTraceThread->~Thread();
tracy_free( s_sysTraceThread );
}
#endif
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
s_compressThread->~Thread();
tracy_free( s_compressThread );
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();
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();
Send on-demand status in welcome message.
2018-07-10 19:44:23 +00:00
#ifdef TRACY_ON_DEMAND
uint8_t onDemand = 1;
#else
uint8_t onDemand = 0;
#endif
Indicate whether client is running on apple shitware.
2019-06-13 12:05:15 +00:00
#ifdef __APPLE__
uint8_t isApple = 1;
#else
uint8_t isApple = 0;
#endif
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 );
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 );
Send on-demand status in welcome message.
2018-07-10 19:44:23 +00:00
MemWrite( &welcome.onDemand, onDemand );
Indicate whether client is running on apple shitware.
2019-06-13 12:05:15 +00:00
MemWrite( &welcome.isApple, isApple );
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();
Separate config for data and broadcast port.
2020-03-08 13:34:09 +00:00
if( !m_broadcast->Open( "255.255.255.255", 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() )
{
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();
Cast to proper types.
2019-06-26 17:33:37 +00:00
broadcastMsg.activeTime = uint32_t( ts - m_epoch );
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
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;
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;
}
else
{
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;
while( m_sock->HasData() && connActive )
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();
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
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
}
}
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;
}
}
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 ) );
}
}
}
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();
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
for(;;)
{
const auto shouldExit = ShouldExit();
{
bool lockHeld = true;
while( !m_fiLock.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_fiQueue.empty() ) m_fiQueue.swap( m_fiDequeue );
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
if( lockHeld )
{
m_fiLock.unlock();
}
}
Add ETC1 compression thread.
2019-06-26 20:57:24 +00:00
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
const auto sz = m_fiDequeue.size();
if( sz > 0 )
{
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 );
Experimental DXT1 compressor.
2019-06-27 15:09:47 +00:00
CompressImageDxt1( (const char*)fi->image, etc1buf, w, h );
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
tracy_free( fi->image );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( QueueType::FrameImage );
No need for lean frame image message.
2020-07-26 12:18:48 +00:00
MemWrite( &item->frameImageFat.image, (uint64_t)etc1buf );
MemWrite( &item->frameImageFat.frame, fi->frame );
MemWrite( &item->frameImageFat.w, w );
MemWrite( &item->frameImageFat.h, h );
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
uint8_t flip = fi->flip;
No need for lean frame image message.
2020-07-26 12:18:48 +00:00
MemWrite( &item->frameImageFat.flip, flip );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
fi++;
}
m_fiDequeue.clear();
}
else
{
std::this_thread::sleep_for( std::chrono::milliseconds( 20 ) );
}
if( shouldExit )
{
return;
}
}
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;
case QueueType::Message:
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::MessageCallstack:
case QueueType::MessageColorCallstack:
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;
case QueueType::CallstackMemory:
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;
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;
#endif
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
#ifdef TRACY_ON_DEMAND
case QueueType::MessageAppInfo:
// Don't free memory associated with deferred messages.
break;
#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,
[this, &connectionLost] ( const uint64_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
{
Process queue data in-place.
2020-02-23 13:50:50 +00:00
if( threadId != m_threadCtx )
{
QueueItem item;
MemWrite( &item.hdr.type, QueueType::ThreadContext );
MemWrite( &item.threadCtx.thread, threadId );
if( !AppendData( &item, QueueDataSize[(int)QueueType::ThreadContext] ) ) connectionLost = true;
m_threadCtx = threadId;
m_refTimeThread = 0;
}
},
[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;
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 );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
tracy_free( (void*)ptr );
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 );
Preserve messages size.
2020-07-21 18:22:59 +00:00
tracy_free( (void*)ptr );
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 );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
tracy_free( (void*)ptr );
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
Process queue data in-place.
2020-02-23 13:50:50 +00:00
tracy_free( (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 );
tracy_free( (void*)ptr );
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 );
tracy_free( (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 );
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 );
Process queue data in-place.
2020-02-23 13:50:50 +00:00
SendCallstackAlloc( ptr );
tracy_free( (void*)ptr );
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 );
tracy_free( (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 );
tracy_free( (void*)ptr );
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;
}
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;
}
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;
}
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
}
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 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;
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 )
{
case QueueType::CallstackMemory:
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 );
tracy_free( (void*)ptr );
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
tracy_free( (void*)ptr );
#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:
case QueueType::MemAllocCallstack:
{
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:
case QueueType::MemFreeCallstack:
{
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;
}
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;
}
Issue predictive callback payload transfer.
2018-06-19 17:09:57 +00:00
default:
assert( false );
break;
}
}
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;
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
}
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 ||
type == QueueType::ExternalThreadName );
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 ||
type == QueueType::SymbolCode );
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
}
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
void Profiler::SendCallstackFrame( uint64_t ptr )
{
#ifdef TRACY_HAS_CALLSTACK
Make it possible to store multiple frames at single frame address.
2019-01-20 18:11:48 +00:00
const auto frameData = DecodeCallstackPtr( ptr );
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
Make it possible to store multiple frames at single frame address.
2019-01-20 18:11:48 +00:00
{
Send single string for callstack frame size.
2020-07-25 22:38:59 +00:00
SendSingleString( frameData.imageName );
Send module name.
2020-02-25 23:33:09 +00:00
Make it possible to store multiple frames at single frame address.
2019-01-20 18:11:48 +00:00
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CallstackFrameSize );
MemWrite( &item.callstackFrameSize.ptr, ptr );
MemWrite( &item.callstackFrameSize.size, frameData.size );
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
Make it possible to store multiple frames at single frame address.
2019-01-20 18:11:48 +00:00
AppendData( &item, QueueDataSize[(int)QueueType::CallstackFrameSize] );
}
for( uint8_t i=0; i<frameData.size; i++ )
{
const auto& frame = frameData.data[i];
Send single string for callstack frame.
2020-07-25 22:41:49 +00:00
SendSingleString( frame.name );
Add second single string transfer.
2020-07-25 23:32:49 +00:00
SendSecondString( frame.file );
Make it possible to store multiple frames at single frame address.
2019-01-20 18:11:48 +00:00
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CallstackFrame );
MemWrite( &item.callstackFrame.line, frame.line );
Send symbol base address.
2020-02-25 22:03:40 +00:00
MemWrite( &item.callstackFrame.symAddr, frame.symAddr );
Symbol length no longer has to be packed.
2020-07-25 22:43:24 +00:00
MemWrite( &item.callstackFrame.symLen, frame.symLen );
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
Make it possible to store multiple frames at single frame address.
2019-01-20 18:11:48 +00:00
AppendData( &item, QueueDataSize[(int)QueueType::CallstackFrame] );
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
Make it possible to store multiple frames at single frame address.
2019-01-20 18:11:48 +00:00
tracy_free( (void*)frame.name );
tracy_free( (void*)frame.file );
}
Callstack frame transfer.
2018-06-19 23:06:31 +00:00
#endif
}
Callstack payload transfer.
2018-06-19 17:09:43 +00:00
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:
SendCallstackFrame( ptr );
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:
SysTraceSendExternalName( ptr );
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:
HandleSymbolQuery( ptr );
break;
Add code transfer from client to server.
2020-03-25 19:04:55 +00:00
case ServerQuerySymbolCode:
HandleSymbolCodeQuery( ptr, extra );
break;
Query source location of each assembly instruction.
2020-04-01 19:43:03 +00:00
case ServerQueryCodeLocation:
SendCodeLocation( ptr );
break;
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
Degrade ARM timer to monotonic raw clock. The monotonic raw clock has the same accuracy as reading cntvct registers, but using clock_gettime() has a measurable impact on queueing time (135 us vs 83 us). This change is needed to enable ftrace time readings on ARM linux, which doesn't provide any way to get raw cntvct readings, like x86-tsc on x86.
2019-08-14 14:19:02 +00:00
# if !defined TARGET_OS_IOS && __ARM_ARCH >= 6
m_timerMul = 1.;
# else
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 );
Degrade ARM timer to monotonic raw clock. The monotonic raw clock has the same accuracy as reading cntvct registers, but using clock_gettime() has a measurable impact on queueing time (135 us vs 83 us). This change is needed to enable ftrace time readings on ARM linux, which doesn't provide any way to get raw cntvct readings, like x86-tsc on x86.
2019-08-14 14:19:02 +00:00
# endif
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;
};
Obtain CPU topology on windows.
2019-11-29 17:29:09 +00:00
#if defined _WIN32 || defined __CYGWIN__
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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepare( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommit;
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 );
Notify server that parameter was handled.
2020-03-25 19:37:26 +00:00
TracyLfqPrepare( QueueType::ParamPingback );
TracyLfqCommit;
Implement setting client parameters from server.
2019-11-25 22:59:48 +00:00
}
Perform symbol information queries.
2020-02-26 21:35:15 +00:00
void Profiler::HandleSymbolQuery( uint64_t symbol )
{
#ifdef TRACY_HAS_CALLSTACK
const auto sym = DecodeSymbolAddress( symbol );
Send single string for symbol information.
2020-07-25 22:31:54 +00:00
SendSingleString( sym.file );
Perform symbol information queries.
2020-02-26 21:35:15 +00:00
QueueItem item;
MemWrite( &item.hdr.type, QueueType::SymbolInformation );
Don't send symbol name.
2020-02-27 11:49:48 +00:00
MemWrite( &item.symbolInformation.line, sym.line );
MemWrite( &item.symbolInformation.symAddr, symbol );
Perform symbol information queries.
2020-02-26 21:35:15 +00:00
AppendData( &item, QueueDataSize[(int)QueueType::SymbolInformation] );
Only copy symbol strings, if needed.
2020-02-27 12:17:26 +00:00
if( sym.needFree ) tracy_free( (void*)sym.file );
Perform symbol information queries.
2020-02-26 21:35:15 +00:00
#endif
}
Add code transfer from client to server.
2020-03-25 19:04:55 +00:00
void Profiler::HandleSymbolCodeQuery( uint64_t symbol, uint32_t size )
{
SendLongString( symbol, (const char*)symbol, size, QueueType::SymbolCode );
}
Query source location of each assembly instruction.
2020-04-01 19:43:03 +00:00
void Profiler::SendCodeLocation( uint64_t ptr )
{
#ifdef TRACY_HAS_CALLSTACK
const auto sym = DecodeCodeAddress( ptr );
Send single string for code information.
2020-07-25 22:28:52 +00:00
SendSingleString( sym.file );
Query source location of each assembly instruction.
2020-04-01 19:43:03 +00:00
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CodeInformation );
MemWrite( &item.codeInformation.ptr, ptr );
MemWrite( &item.codeInformation.line, sym.line );
AppendData( &item, QueueDataSize[(int)QueueType::CodeInformation] );
if( sym.needFree ) tracy_free( (void*)sym.file );
#endif
}
Add support for QPC timer.
2020-04-07 20:01:31 +00:00
#if ( defined _WIN32 || defined __CYGWIN__ ) && defined TRACY_TIMER_QPC
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
Fill in thread id during dequeue, not during enqueue.
2019-07-29 22:42:31 +00:00
tracy::GetProfiler().SendCallstack( depth );
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
}
#endif
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
}
#endif
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
Add allocated srcloc zone begin emit functions to C API.
2019-12-05 23:22:49 +00:00
}
tracy::GetProfiler().SendCallstack( depth );
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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() );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
}
#endif
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
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
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
}
#endif
{
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqPrepareC( 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 );
Hide async queue setup/commit behind macros.
2020-01-19 14:06:11 +00:00
TracyLfqCommitC;
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +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
{
TracyLfqPrepareC( tracy::QueueType::ZoneValidation );
tracy::MemWrite( &item->zoneValidation.id, ctx.id );
TracyLfqCommitC;
}
#endif
{
TracyLfqPrepareC( tracy::QueueType::ZoneValue );
tracy::MemWrite( &item->zoneValue.value, value );
TracyLfqCommitC;
}
}
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 ); }
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
Add ___tracy_init_thread function This function needs to be called for each non-main thread before calling the `___tracy_alloc_` functions. Alternative way to achieve this could be initializing the allocator transparently in the `___tracy_alloc_*` calls.
2020-06-20 01:17:31 +00:00
// thread_locals are not initialized on thread creation. At least on GNU/Linux. Instead they are
// initialized on their first ODR-use. This means that the allocator is not automagically
// initialized every time a thread is created. As thus, expose to the C API users a simple API to
// call every time they create a thread. Here we can then put all sorts of per-thread
// initialization.
Fix build on macos It was broken by a110b420111ce02825fffaec29d08b5cc7b2168a. In addition, adjust the CI definition to test builds on macOS.
2020-06-20 17:04:15 +00:00
TRACY_API void ___tracy_init_thread(void) {
#ifdef TRACY_DELAYED_INIT
(void)tracy::GetProfilerThreadData();
#else
(void)tracy::s_rpmalloc_thread_init;
#endif
}
Add ___tracy_init_thread function This function needs to be called for each non-main thread before calling the `___tracy_alloc_` functions. Alternative way to achieve this could be initializing the allocator transparently in the `___tracy_alloc_*` calls.
2020-06-20 01:17:31 +00:00
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