mirror/tracy
1
0
Fork 0
mirror of https://github.com/wolfpld/tracy.git synced 2024-11-14 04:01:48 +00:00
Code Issues Packages Projects Releases Wiki Activity
3aa427fdd6
tracy/client/TracyProfiler.cpp

2840 lines
88 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
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"
Move protocol specific sizes to common header.
2017-09-13 20:56:55 +00:00
#include "../common/TracyProtocol.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
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
#if defined __APPLE__
# include "TargetConditionals.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
{
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
#ifndef TRACY_DELAYED_INIT
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
};
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
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 TRACY_HW_TIMER && ( 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 )
{
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()
{
uint32_t regs[4];
CpuId( regs, 0x80000001 );
if( !( regs[3] & ( 1 << 27 ) ) ) InitFailure( "CPU doesn't support RDTSCP instruction." );
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' )
{
InitFailure( "CPU doesn't support invariant TSC.\nDefine TRACY_NO_INVARIANT_CHECK=1 to ignore this error, *if you know what you are doing*." );
}
}
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
}
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;
}
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__
Perform windows version discovery.
2018-08-19 16:43:26 +00:00
# ifdef UNICODE
t_RtlGetVersion RtlGetVersion = (t_RtlGetVersion)GetProcAddress( GetModuleHandle( L"ntdll.dll" ), "RtlGetVersion" );
# else
t_RtlGetVersion RtlGetVersion = (t_RtlGetVersion)GetProcAddress( GetModuleHandle( "ntdll.dll" ), "RtlGetVersion" );
# endif
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
{
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
__cpuidex( (int*)regs, i, 0 );
# else
int zero = 0;
asm volatile ( "cpuid" : "=a" (regs[0]), "=b" (regs[1]), "=c" (regs[2]), "=d" (regs[3]) : "a" (i), "c" (zero) );
# endif
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
}
Define broadcast message, add versioning.
2019-06-18 18:26:40 +00:00
static BroadcastMessage& GetBroadcastMessage( const char* procname, size_t pnsz, int& len )
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;
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;
case BUS_MCEERR_AR:
strcpy( msgPtr, "Hardware memory error consumed on a machine check; action required.\n" );
break;
case BUS_MCEERR_AO:
strcpy( msgPtr, "Hardware memory error detected in process but not consumed; action optional.\n" );
break;
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 };
static Profiler* s_instance;
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
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
#ifdef TRACY_DELAYED_INIT
struct ThreadNameData;
Clean up imported functions in multi-dll projects.
2019-06-07 13:56:46 +00:00
TRACY_API moodycamel::ConcurrentQueue<QueueItem>& GetQueue();
Implement delayed initialization of the profiler. Enabled on osx, ios.
2019-02-19 19:43:14 +00:00
struct RPMallocInit { RPMallocInit() { rpmalloc_initialize(); } };
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_initialize();
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
};
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
}
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
#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
Don't create big buffers on stack.
2017-11-02 11:56:13 +00:00
enum { BulkSize = TargetFrameSize / QueueItemSize };
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 )
Track zone id for verification purposes.
2019-01-14 21:23:24 +00:00
, m_zoneId( 1 )
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 )
Don't create big buffers on stack.
2017-11-02 11:56:13 +00:00
, m_itemBuf( (QueueItem*)tracy_malloc( sizeof( QueueItem ) * BulkSize ) )
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
#ifdef TRACY_ON_DEMAND
, m_isConnected( false )
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
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
if( SysTraceStart() )
{
s_sysTraceThread = (Thread*)tracy_malloc( sizeof( Thread ) );
new(s_sysTraceThread) Thread( SysTraceWorker, nullptr );
}
#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 );
Don't create big buffers on stack.
2017-11-02 11:56:13 +00:00
tracy_free( m_itemBuf );
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
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" );
Allow changing tracy port in client.
2019-09-21 13:11:15 +00:00
#ifdef TRACY_PORT
const auto port = TRACY_PORT;
#else
const auto port = 8086;
#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
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 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 );
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;
Allow changing tracy port in client.
2019-09-21 13:11:15 +00:00
if( !listen.Listen( port, 8 ) )
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 );
}
}
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();
Allow changing tracy port in client.
2019-09-21 13:11:15 +00:00
if( !m_broadcast->Open( "255.255.255.255", port ) )
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;
auto& broadcastMsg = GetBroadcastMessage( procname, pnsz, broadcastLen );
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 );
Allow changing tracy port in client.
2019-09-21 13:11:15 +00:00
m_broadcast->Send( port, &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 );
More strict memory ordering for on-demand connection status.
2019-06-09 14:48:00 +00:00
m_isConnected.store( true, std::memory_order_release );
Track connection status.
2018-07-10 19:50:00 +00:00
#endif
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 )
{
const auto idx = MemRead<uint8_t>( &item.hdr.idx );
Allow sending application information messages.
2019-07-12 16:14:42 +00:00
if( (QueueType)idx == QueueType::MessageAppInfo )
{
uint64_t ptr = MemRead<uint64_t>( &item.message.text );
SendString( ptr, (const char*)ptr, QueueType::CustomStringData );
}
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
#ifdef TRACY_ON_DEMAND
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 );
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()
{
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 );
Compress frame images in a separate thread.
2019-06-26 21:18:30 +00:00
MemWrite( &item->frameImage.image, (uint64_t)etc1buf );
MemWrite( &item->frameImage.frame, fi->frame );
MemWrite( &item->frameImage.w, w );
MemWrite( &item->frameImage.h, h );
uint8_t flip = fi->flip;
MemWrite( &item->frameImage.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:
ptr = MemRead<uint64_t>( &item.zoneText.text );
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
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
ptr = MemRead<uint64_t>( &item.message.text );
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:
ptr = MemRead<uint64_t>( &item.callstackMemory.ptr );
tracy_free( (void*)ptr );
break;
case QueueType::Callstack:
ptr = MemRead<uint64_t>( &item.callstack.ptr );
tracy_free( (void*)ptr );
break;
Send native callstack along with allocated callstack.
2019-03-05 01:00:31 +00:00
case QueueType::CallstackAlloc:
ptr = MemRead<uint64_t>( &item.callstackAlloc.nativePtr );
tracy_free( (void*)ptr );
Send native callstack before allocated one.
2019-03-05 18:18:43 +00:00
ptr = MemRead<uint64_t>( &item.callstackAlloc.ptr );
tracy_free( (void*)ptr );
Send native callstack along with allocated callstack.
2019-03-05 01:00:31 +00:00
break;
Frame image transfer prototype.
2019-06-06 19:39:54 +00:00
case QueueType::FrameImage:
ptr = MemRead<uint64_t>( &item.frameImage.image );
tracy_free( (void*)ptr );
break;
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(;;)
{
Hide rest of statics.
2019-02-19 18:33:37 +00:00
const auto sz = GetQueue().try_dequeue_bulk( token, m_itemBuf, BulkSize );
Free memory associated with cleared queue items.
2018-07-10 23:34:48 +00:00
if( sz == 0 ) break;
for( size_t i=0; i<sz; i++ ) FreeAssociatedMemory( m_itemBuf[i] );
}
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 )
{
Dequeue items from a single thread.
2019-07-29 21:44:08 +00:00
uint64_t threadId;
const auto sz = GetQueue().try_dequeue_bulk_single( token, m_itemBuf, BulkSize, threadId );
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
if( sz > 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
if( threadId != m_threadCtx )
{
QueueItem item;
MemWrite( &item.hdr.type, QueueType::ThreadContext );
MemWrite( &item.threadCtx.thread, threadId );
if( !AppendData( &item, QueueDataSize[(int)QueueType::ThreadContext] ) ) return DequeueStatus::ConnectionLost;
m_threadCtx = threadId;
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_refTimeThread = 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
}
Leaner iteration in Profiler::Dequeue().
2017-11-22 01:07:23 +00:00
auto end = m_itemBuf + sz;
auto item = m_itemBuf;
while( item != end )
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
{
Preemptive message text delivery.
2017-11-11 14:41:21 +00:00
uint64_t ptr;
Fix UB, lose type safety.
2018-04-03 14:45:55 +00:00
const auto idx = MemRead<uint8_t>( &item->hdr.idx );
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
if( idx < (int)QueueType::Terminate )
Preemptive sending of custom strings.
2017-11-11 14:22:55 +00:00
{
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
switch( (QueueType)idx )
{
case QueueType::ZoneText:
case QueueType::ZoneName:
ptr = MemRead<uint64_t>( &item->zoneText.text );
SendString( ptr, (const char*)ptr, QueueType::CustomStringData );
tracy_free( (void*)ptr );
break;
case QueueType::Message:
case QueueType::MessageColor:
Plumbing for message call stacks.
2019-11-14 22:40:41 +00:00
case QueueType::MessageCallstack:
case QueueType::MessageColorCallstack:
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
ptr = MemRead<uint64_t>( &item->message.text );
SendString( ptr, (const char*)ptr, QueueType::CustomStringData );
tracy_free( (void*)ptr );
break;
case QueueType::MessageAppInfo:
ptr = MemRead<uint64_t>( &item->message.text );
SendString( ptr, (const char*)ptr, QueueType::CustomStringData );
Cosmetics.
2019-08-14 21:05:58 +00:00
#ifndef TRACY_ON_DEMAND
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
tracy_free( (void*)ptr );
Cosmetics.
2019-08-14 21:05:58 +00:00
#endif
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
break;
case QueueType::ZoneBeginAllocSrcLoc:
case QueueType::ZoneBeginAllocSrcLocCallstack:
Transfer time deltas, not absolute times. This change significantly reduces network bandwidth requirements. Implemented for: - CPU zones, - GPU zones, - locks, - plots, - memory events.
2019-10-23 22:04:31 +00:00
{
int64_t t = MemRead<int64_t>( &item->zoneBegin.time );
int64_t dt = t - m_refTimeThread;
m_refTimeThread = t;
MemWrite( &item->zoneBegin.time, dt );
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
ptr = MemRead<uint64_t>( &item->zoneBegin.srcloc );
SendSourceLocationPayload( 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
}
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
case QueueType::Callstack:
ptr = MemRead<uint64_t>( &item->callstack.ptr );
SendCallstackPayload( ptr );
tracy_free( (void*)ptr );
break;
case QueueType::CallstackAlloc:
ptr = MemRead<uint64_t>( &item->callstackAlloc.nativePtr );
Native callstacks are now optional in allocated callstack messages.
2019-11-25 21:54:10 +00:00
if( ptr != 0 )
{
CutCallstack( (void*)ptr, "lua_pcall" );
SendCallstackPayload( ptr );
tracy_free( (void*)ptr );
}
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
ptr = MemRead<uint64_t>( &item->callstackAlloc.ptr );
SendCallstackAlloc( ptr );
tracy_free( (void*)ptr );
break;
case QueueType::FrameImage:
{
ptr = MemRead<uint64_t>( &item->frameImage.image );
const auto w = MemRead<uint16_t>( &item->frameImage.w );
const auto h = MemRead<uint16_t>( &item->frameImage.h );
const auto csz = size_t( w * h / 2 );
SendLongString( ptr, (const char*)ptr, csz, QueueType::FrameImageData );
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::ZoneBegin:
case QueueType::ZoneBeginCallstack:
{
int64_t t = MemRead<int64_t>( &item->zoneBegin.time );
int64_t dt = t - m_refTimeThread;
m_refTimeThread = t;
MemWrite( &item->zoneBegin.time, dt );
break;
}
case QueueType::ZoneEnd:
{
int64_t t = MemRead<int64_t>( &item->zoneEnd.time );
int64_t dt = t - m_refTimeThread;
m_refTimeThread = 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 - m_refTimeThread;
m_refTimeThread = t;
MemWrite( &item->gpuZoneBegin.cpuTime, dt );
break;
}
case QueueType::GpuZoneEnd:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneEnd.cpuTime );
int64_t dt = t - m_refTimeThread;
m_refTimeThread = t;
MemWrite( &item->gpuZoneEnd.cpuTime, dt );
break;
}
case QueueType::PlotData:
{
int64_t t = MemRead<int64_t>( &item->plotData.time );
int64_t dt = t - m_refTimeThread;
m_refTimeThread = t;
MemWrite( &item->plotData.time, dt );
break;
}
Send delta times for context switches.
2019-10-25 17:13:11 +00:00
case QueueType::ContextSwitch:
{
int64_t t = MemRead<int64_t>( &item->contextSwitch.time );
int64_t dt = t - m_refTimeCtx;
m_refTimeCtx = t;
MemWrite( &item->contextSwitch.time, dt );
break;
}
case QueueType::ThreadWakeup:
{
int64_t t = MemRead<int64_t>( &item->threadWakeup.time );
int64_t dt = t - m_refTimeCtx;
m_refTimeCtx = t;
MemWrite( &item->threadWakeup.time, 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 );
int64_t dt = t - m_refTimeGpu;
m_refTimeGpu = t;
MemWrite( &item->gpuTime.gpuTime, dt );
break;
}
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
default:
assert( false );
break;
}
Preemptive sending of custom strings.
2017-11-11 14:22:55 +00:00
}
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
if( !AppendData( item, QueueDataSize[idx] ) ) return DequeueStatus::ConnectionLost;
Leaner iteration in Profiler::Dequeue().
2017-11-22 01:07:23 +00:00
item++;
Terminate connection handshake.
2017-10-18 16:48:51 +00:00
}
}
else
{
Make DequeueStatus enum class.
2019-06-09 14:14:30 +00:00
return DequeueStatus::QueueEmpty;
Profiler worker thread skeleton.
2017-09-10 15:43:56 +00:00
}
Fix conflicts with X.h.
2019-11-14 17:24:29 +00:00
return DequeueStatus::DataDequeued;
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 )
{
const auto sz = GetQueue().try_dequeue_bulk( token, m_itemBuf, BulkSize );
if( sz > 0 )
{
auto end = m_itemBuf + sz;
auto item = m_itemBuf;
while( item != end )
{
FreeAssociatedMemory( *item );
const auto idx = MemRead<uint8_t>( &item->hdr.idx );
if( idx == (uint8_t)QueueType::ContextSwitch )
{
const auto csTime = MemRead<int64_t>( &item->contextSwitch.time );
if( csTime > timeStop )
{
timeStop = -1;
Fix conflicts with X.h.
2019-11-14 17:24:29 +00:00
return DequeueStatus::DataDequeued;
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
}
Send delta times for context switches.
2019-10-25 17:13:11 +00:00
int64_t dt = csTime - m_refTimeCtx;
m_refTimeCtx = csTime;
MemWrite( &item->contextSwitch.time, dt );
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
if( !AppendData( item, QueueDataSize[(int)QueueType::ContextSwitch] ) ) return DequeueStatus::ConnectionLost;
Send thread wakeups when handling disconnect request.
2019-10-25 16:22:42 +00:00
}
else if( idx == (uint8_t)QueueType::ThreadWakeup )
{
const auto csTime = MemRead<int64_t>( &item->threadWakeup.time );
if( csTime > timeStop )
{
timeStop = -1;
Fix conflicts with X.h.
2019-11-14 17:24:29 +00:00
return DequeueStatus::DataDequeued;
Send thread wakeups when handling disconnect request.
2019-10-25 16:22:42 +00:00
}
Send delta times for context switches.
2019-10-25 17:13:11 +00:00
int64_t dt = csTime - m_refTimeCtx;
m_refTimeCtx = csTime;
MemWrite( &item->threadWakeup.time, dt );
Send thread wakeups when handling disconnect request.
2019-10-25 16:22:42 +00:00
if( !AppendData( item, QueueDataSize[(int)QueueType::ThreadWakeup] ) ) return DequeueStatus::ConnectionLost;
Finish sending context switches during disconnect.
2019-08-14 21:06:13 +00:00
}
item++;
}
}
else
{
return DequeueStatus::QueueEmpty;
}
Fix conflicts with X.h.
2019-11-14 17:24:29 +00:00
return DequeueStatus::DataDequeued;
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 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;
Fix MemRead() call.
2018-04-03 15:57:12 +00:00
const 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:
ptr = MemRead<uint64_t>( &item->callstackMemory.ptr );
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 );
int64_t dt = t - m_refTimeSerial;
m_refTimeSerial = t;
MemWrite( &item->lockWait.time, dt );
break;
}
case QueueType::LockObtain:
case QueueType::LockSharedObtain:
{
int64_t t = MemRead<int64_t>( &item->lockObtain.time );
int64_t dt = t - m_refTimeSerial;
m_refTimeSerial = t;
MemWrite( &item->lockObtain.time, dt );
break;
}
case QueueType::LockRelease:
case QueueType::LockSharedRelease:
{
int64_t t = MemRead<int64_t>( &item->lockRelease.time );
int64_t dt = t - m_refTimeSerial;
m_refTimeSerial = t;
MemWrite( &item->lockRelease.time, dt );
break;
}
case QueueType::MemAlloc:
case QueueType::MemAllocCallstack:
{
int64_t t = MemRead<int64_t>( &item->memAlloc.time );
int64_t dt = t - m_refTimeSerial;
m_refTimeSerial = t;
MemWrite( &item->memAlloc.time, dt );
break;
}
case QueueType::MemFree:
case QueueType::MemFreeCallstack:
{
int64_t t = MemRead<int64_t>( &item->memFree.time );
int64_t dt = t - m_refTimeSerial;
m_refTimeSerial = t;
MemWrite( &item->memFree.time, dt );
break;
}
case QueueType::GpuZoneBeginSerial:
case QueueType::GpuZoneBeginCallstackSerial:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneBegin.cpuTime );
int64_t dt = t - m_refTimeSerial;
m_refTimeSerial = t;
MemWrite( &item->gpuZoneBegin.cpuTime, dt );
break;
}
case QueueType::GpuZoneEndSerial:
{
int64_t t = MemRead<int64_t>( &item->gpuZoneEnd.cpuTime );
int64_t dt = t - m_refTimeSerial;
m_refTimeSerial = t;
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 );
int64_t dt = t - m_refTimeGpu;
m_refTimeGpu = t;
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 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::AppendData( const void* data, size_t len )
{
Assign return value only once.
2019-01-29 21:21:01 +00:00
const auto ret = NeedDataSize( len );
Unsafe version of AppendData.
2018-06-23 00:16:58 +00:00
AppendDataUnsafe( data, len );
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
return ret;
}
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;
}
Data packets can't cross data buffer boundary.
2017-11-11 14:08:03 +00:00
bool Profiler::NeedDataSize( size_t len )
{
Check if requested data size doesn't overflow buffer.
2019-10-24 19:22:22 +00:00
assert( len <= TargetFrameSize );
Data packets can't cross data buffer boundary.
2017-11-11 14:08:03 +00:00
bool ret = true;
if( m_bufferOffset - m_bufferStart + len > TargetFrameSize )
{
ret = CommitData();
}
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
}
No return status is needed here.
2018-06-19 17:00:57 +00:00
void Profiler::SendString( uint64_t str, const char* ptr, 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::CustomStringData ||
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
auto len = strlen( ptr );
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
}
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
{
assert( type == QueueType::FrameImageData );
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
const auto len = *((uint32_t*)ptr);
assert( len <= std::numeric_limits<uint16_t>::max() );
assert( len > 4 );
Wait for send buffer to be full before sending data.
2017-11-11 13:16:37 +00:00
const auto l16 = uint16_t( len - 4 );
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)QueueType::SourceLocationPayload] + 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)QueueType::SourceLocationPayload] );
AppendDataUnsafe( &l16, sizeof( l16 ) );
AppendDataUnsafe( ptr + 4, l16 );
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
}
}
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 );
const auto len = *((uint32_t*)ptr);
assert( len <= std::numeric_limits<uint16_t>::max() );
const auto l16 = uint16_t( len );
NeedDataSize( QueueDataSize[(int)QueueType::CallstackAllocPayload] + sizeof( l16 ) + l16 );
AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::CallstackAllocPayload] );
AppendDataUnsafe( &l16, sizeof( l16 ) );
AppendDataUnsafe( ptr + 4, l16 );
}
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
{
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];
SendString( uint64_t( frame.name ), frame.name, QueueType::CustomStringData );
SendString( uint64_t( frame.file ), frame.file, QueueType::CustomStringData );
QueueItem item;
MemWrite( &item.hdr.type, QueueType::CallstackFrame );
MemWrite( &item.callstackFrame.name, (uint64_t)frame.name );
MemWrite( &item.callstackFrame.file, (uint64_t)frame.file );
MemWrite( &item.callstackFrame.line, frame.line );
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
Don't exit until all data is sent.
2017-10-17 20:02:47 +00:00
static bool DontExit() { return false; }
Rework client handling of server requests.
2017-09-21 23:54:04 +00:00
bool Profiler::HandleServerQuery()
{
uint8_t type;
Replace select() with poll().
2019-02-10 14:45:23 +00:00
if( !m_sock->Read( &type, sizeof( type ), 10, DontExit ) ) return false;
Rework client handling of server requests.
2017-09-21 23:54:04 +00:00
uint64_t ptr;
Replace select() with poll().
2019-02-10 14:45:23 +00:00
if( !m_sock->Read( &ptr, sizeof( ptr ), 10, DontExit ) ) return false;
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 )
{
SendString( ptr, "Main thread", QueueType::ThreadName );
}
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;
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()
{
enum { 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
Profiling delay calibration.
2017-09-24 14:02:09 +00:00
enum { 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
Hide rest of statics.
2019-02-19 18:33:37 +00:00
moodycamel::ProducerToken ptoken_detail( GetQueue() );
moodycamel::ConcurrentQueue<QueueItem>::ExplicitProducer* ptoken = GetQueue().get_explicit_producer( ptoken_detail );
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
enum { Bulk = 1000 };
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
QueueItem item[Bulk];
while( left != 0 )
{
Hide rest of statics.
2019-02-19 18:33:37 +00:00
const auto sz = GetQueue().try_dequeue_bulk( token, item, std::min( left, (int)Bulk ) );
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__
# ifdef UNICODE
t_GetLogicalProcessorInformationEx _GetLogicalProcessorInformationEx = (t_GetLogicalProcessorInformationEx)GetProcAddress( GetModuleHandle( L"kernel32" ), "GetLogicalProcessorInformationEx" );
# else
t_GetLogicalProcessorInformationEx _GetLogicalProcessorInformationEx = (t_GetLogicalProcessorInformationEx)GetProcAddress( GetModuleHandle( "kernel32" ), "GetLogicalProcessorInformationEx" );
# endif
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" );
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 ) );
}
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 );
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 );
Move callstack cutting to a separate function.
2019-03-05 01:15:13 +00:00
MemWrite( &item->callstack.ptr, 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 );
}
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
{
if( !ctx.active ) return;
auto ptr = (char*)tracy::tracy_malloc( size+1 );
memcpy( ptr, txt, size );
ptr[size] = '\0';
#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 );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
tracy::MemWrite( &item->zoneText.text, (uint64_t)ptr );
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
{
if( !ctx.active ) return;
auto ptr = (char*)tracy::tracy_malloc( size+1 );
memcpy( ptr, txt, size );
ptr[size] = '\0';
#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 );
Add ZoneText and ZoneName to the C API.
2019-01-16 00:17:01 +00:00
tracy::MemWrite( &item->zoneText.text, (uint64_t)ptr );
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_memory_alloc( const void* ptr, size_t size ) { tracy::Profiler::MemAlloc( ptr, size ); }
TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int depth ) { tracy::Profiler::MemAllocCallstack( ptr, size, depth ); }
TRACY_API void ___tracy_emit_memory_free( const void* ptr ) { tracy::Profiler::MemFree( ptr ); }
TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int depth ) { tracy::Profiler::MemFreeCallstack( ptr, depth ); }
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 ); }
Expose srcloc allocation in C API.
2019-12-05 23:25:52 +00:00
TRACY_API uint64_t ___tracy_alloc_srcloc( uint32_t line, const char* source, const char* function ) { return tracy::Profiler::AllocSourceLocation( line, source, function ); }
TRACY_API uint64_t ___tracy_alloc_srcloc_name( uint32_t line, const char* source, const char* function, const char* name, size_t nameSz ) { return tracy::Profiler::AllocSourceLocation( line, source, function, name, nameSz ); }
Add C API for plots and messages.
2019-06-24 18:54:43 +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