tracy/public/common/TracySystem.cpp

307 lines
7.6 KiB
C++
Raw Normal View History

2020-01-20 21:49:03 +00:00
#ifdef _MSC_VER
# pragma warning(disable:4996)
#endif
2021-10-07 21:28:40 +00:00
#if defined _WIN32
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
# endif
# ifndef NOMINMAX
# define NOMINMAX
# endif
2017-09-10 15:46:20 +00:00
# include <windows.h>
2021-04-09 22:33:01 +00:00
# include <malloc.h>
2022-02-10 19:26:45 +00:00
# include "TracyUwp.hpp"
2017-09-10 15:46:20 +00:00
#else
# include <pthread.h>
2017-09-22 19:48:21 +00:00
# include <string.h>
2017-09-10 15:46:20 +00:00
# include <unistd.h>
#endif
#ifdef __linux__
# ifdef __ANDROID__
# include <sys/types.h>
# else
# include <sys/syscall.h>
2019-08-13 23:12:23 +00:00
# endif
# include <fcntl.h>
#elif defined __FreeBSD__
# include <sys/thr.h>
#elif defined __NetBSD__ || defined __DragonFly__
# include <sys/lwp.h>
#endif
2019-01-19 11:03:30 +00:00
#ifdef __MINGW32__
# define __STDC_FORMAT_MACROS
#endif
#include <inttypes.h>
2017-10-30 20:51:24 +00:00
#include <stdio.h>
#include <stdlib.h>
2017-09-10 15:46:20 +00:00
#include "TracySystem.hpp"
2021-10-07 21:28:40 +00:00
#if defined _WIN32
extern "C" typedef HRESULT (WINAPI *t_SetThreadDescription)( HANDLE, PCWSTR );
extern "C" typedef HRESULT (WINAPI *t_GetThreadDescription)( HANDLE, PWSTR* );
#endif
#ifdef TRACY_ENABLE
# include <atomic>
2017-11-02 11:57:02 +00:00
# include "TracyAlloc.hpp"
#endif
2017-09-10 15:46:20 +00:00
namespace tracy
{
namespace detail
{
TRACY_API uint32_t GetThreadHandleImpl()
{
2021-10-07 21:28:40 +00:00
#if defined _WIN32
static_assert( sizeof( decltype( GetCurrentThreadId() ) ) <= sizeof( uint32_t ), "Thread handle too big to fit in protocol" );
return uint32_t( GetCurrentThreadId() );
#elif defined __APPLE__
uint64_t id;
pthread_threadid_np( pthread_self(), &id );
return uint32_t( id );
#elif defined __ANDROID__
return (uint32_t)gettid();
#elif defined __linux__
return (uint32_t)syscall( SYS_gettid );
#elif defined __FreeBSD__
long id;
thr_self( &id );
return id;
#elif defined __NetBSD__
return _lwp_self();
#elif defined __DragonFly__
return lwp_gettid();
#elif defined __OpenBSD__
return getthrid();
2022-07-19 13:49:29 +00:00
#elif defined __EMSCRIPTEN__
// Not supported, but let it compile.
return 0;
#else
// To add support for a platform, retrieve and return the kernel thread identifier here.
//
// Note that pthread_t (as for example returned by pthread_self()) is *not* a kernel
// thread identifier. It is a pointer to a library-allocated data structure instead.
// Such pointers will be reused heavily, making the pthread_t non-unique. Additionally
// a 64-bit pointer cannot be reliably truncated to 32 bits.
#error "Unsupported platform!"
#endif
}
}
#ifdef TRACY_ENABLE
struct ThreadNameData
{
uint32_t id;
const char* name;
ThreadNameData* next;
};
2020-01-25 15:17:03 +00:00
std::atomic<ThreadNameData*>& GetThreadNameData();
#endif
#ifdef _MSC_VER
# pragma pack( push, 8 )
struct THREADNAME_INFO
{
DWORD dwType;
LPCSTR szName;
DWORD dwThreadID;
DWORD dwFlags;
};
# pragma pack( pop )
void ThreadNameMsvcMagic( const THREADNAME_INFO& info )
{
__try
{
RaiseException( 0x406D1388, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info );
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
}
}
#endif
2020-01-25 15:17:03 +00:00
TRACY_API void SetThreadName( const char* name )
2017-09-10 15:46:20 +00:00
{
2021-10-07 21:28:40 +00:00
#if defined _WIN32
2022-02-10 19:26:45 +00:00
# ifdef TRACY_UWP
static auto _SetThreadDescription = &::SetThreadDescription;
# else
static auto _SetThreadDescription = (t_SetThreadDescription)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "SetThreadDescription" );
# endif
if( _SetThreadDescription )
{
wchar_t buf[256];
mbstowcs( buf, name, 256 );
_SetThreadDescription( GetCurrentThread(), buf );
}
else
2017-09-21 22:37:28 +00:00
{
# if defined _MSC_VER
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = name;
info.dwThreadID = GetCurrentThreadId();
info.dwFlags = 0;
ThreadNameMsvcMagic( info );
2017-09-21 22:37:28 +00:00
# endif
}
2021-10-07 21:28:40 +00:00
#elif defined _GNU_SOURCE && !defined __EMSCRIPTEN__
{
const auto sz = strlen( name );
if( sz <= 15 )
{
#if defined __APPLE__
pthread_setname_np( name );
#else
pthread_setname_np( pthread_self(), name );
#endif
}
else
{
char buf[16];
memcpy( buf, name, 15 );
buf[15] = '\0';
#if defined __APPLE__
pthread_setname_np( buf );
#else
pthread_setname_np( pthread_self(), buf );
#endif
}
}
2017-09-10 15:46:20 +00:00
#endif
#ifdef TRACY_ENABLE
{
const auto sz = strlen( name );
char* buf = (char*)tracy_malloc( sz+1 );
memcpy( buf, name, sz );
buf[sz] = '\0';
auto data = (ThreadNameData*)tracy_malloc_fast( sizeof( ThreadNameData ) );
data->id = detail::GetThreadHandleImpl();
data->name = buf;
2019-02-19 18:33:37 +00:00
data->next = GetThreadNameData().load( std::memory_order_relaxed );
while( !GetThreadNameData().compare_exchange_weak( data->next, data, std::memory_order_release, std::memory_order_relaxed ) ) {}
}
#endif
2017-09-10 15:46:20 +00:00
}
TRACY_API const char* GetThreadName( uint32_t id )
{
static char buf[256];
#ifdef TRACY_ENABLE
2019-02-19 18:33:37 +00:00
auto ptr = GetThreadNameData().load( std::memory_order_relaxed );
while( ptr )
{
if( ptr->id == id )
{
2018-03-30 23:38:57 +00:00
return ptr->name;
}
ptr = ptr->next;
}
#endif
#if defined _WIN32
# ifdef TRACY_UWP
static auto _GetThreadDescription = &::GetThreadDescription;
# else
static auto _GetThreadDescription = (t_GetThreadDescription)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "GetThreadDescription" );
# endif
if( _GetThreadDescription )
{
auto hnd = OpenThread( THREAD_QUERY_LIMITED_INFORMATION, FALSE, (DWORD)id );
if( hnd != 0 )
{
PWSTR tmp;
if( SUCCEEDED( _GetThreadDescription( hnd, &tmp ) ) )
{
auto ret = wcstombs( buf, tmp, 256 );
CloseHandle( hnd );
LocalFree( tmp );
2023-09-11 09:33:40 +00:00
if( ret != static_cast<size_t>( -1 ) )
{
return buf;
}
}
}
}
#elif defined __linux__
int cs, fd;
char path[32];
snprintf( path, sizeof( path ), "/proc/self/task/%d/comm", id );
sprintf( buf, "%" PRIu32, id );
# ifndef __ANDROID__
pthread_setcancelstate( PTHREAD_CANCEL_DISABLE, &cs );
# endif
if ( ( fd = open( path, O_RDONLY ) ) > 0) {
int len = read( fd, buf, 255 );
if( len > 0 )
{
buf[len] = 0;
if( len > 1 && buf[len-1] == '\n' )
{
buf[len-1] = 0;
}
}
close( fd );
}
# ifndef __ANDROID__
pthread_setcancelstate( cs, 0 );
# endif
return buf;
#endif
sprintf( buf, "%" PRIu32, id );
return buf;
}
2021-04-09 22:33:01 +00:00
TRACY_API const char* GetEnvVar( const char* name )
{
2021-06-15 22:52:12 +00:00
#if defined _WIN32
2021-04-09 22:33:01 +00:00
// unfortunately getenv() on Windows is just fundamentally broken. It caches the entire
// environment block once on startup, then never refreshes it again. If any environment
// strings are added or modified after startup of the CRT, those changes will not be
// seen by getenv(). This removes the possibility of an app using this SDK from
// programmatically setting any of the behaviour controlling envvars here.
//
// To work around this, we'll instead go directly to the Win32 environment strings APIs
// to get the current value.
static char buffer[1024];
DWORD const kBufferSize = DWORD(sizeof(buffer) / sizeof(buffer[0]));
DWORD count = GetEnvironmentVariableA(name, buffer, kBufferSize);
if( count == 0 )
return nullptr;
if( count >= kBufferSize )
{
char* buf = reinterpret_cast<char*>(_alloca(count + 1));
count = GetEnvironmentVariableA(name, buf, count + 1);
memcpy(buffer, buf, kBufferSize);
buffer[kBufferSize - 1] = 0;
}
return buffer;
#else
return getenv(name);
#endif
}
2017-09-22 19:48:21 +00:00
}
2020-08-03 15:31:00 +00:00
#ifdef __cplusplus
extern "C" {
#endif
TRACY_API void ___tracy_set_thread_name( const char* name ) { tracy::SetThreadName( name ); }
#ifdef __cplusplus
}
#endif