From b14dad2c42a7765d78a35d2ede4862816b6174da Mon Sep 17 00:00:00 2001 From: Bartosz Taudul Date: Sun, 20 Sep 2026 13:26:39 +0200 Subject: [PATCH] Lock release event must happen before the actual release. With unlock -> notify order the thread can be preempted by other thread, for example one that wants to lock the very same lock. This would produce incorrect ordering of lock release and acquire events. --- manual/tracy.tex | 10 +++++----- public/client/TracyLock.hpp | 12 ++++++------ public/client/TracyProfiler.cpp | 8 ++++---- public/common/TracyProtocol.hpp | 2 +- public/tracy/TracyC.h | 18 +++++++++--------- 5 files changed, 25 insertions(+), 25 deletions(-) diff --git a/manual/tracy.tex b/manual/tracy.tex index 6e4b21dd..905bce24 100644 --- a/manual/tracy.tex +++ b/manual/tracy.tex @@ -2377,7 +2377,7 @@ Marking locks in the C API is done with the following macros: \item \texttt{TracyCLockTerminate(lock\_ctx)} \item \texttt{TracyCLockBeforeLock(lock\_ctx)} \item \texttt{TracyCLockAfterLock(lock\_ctx)} -\item \texttt{TracyCLockAfterUnlock(lock\_ctx)} +\item \texttt{TracyCLockBeforeUnlock(lock\_ctx)} \item \texttt{TracyCLockAfterTryLock(lock\_ctx, acquired)} \item \texttt{TracyCLockMark(lock\_ctx)} \item \texttt{TracyCLockCustomName(lock\_ctx, name, size)} @@ -2408,11 +2408,11 @@ int acquired = WaitForSingleObject(lock, 200) == WAIT_OBJECT_0; TracyCLockAfterTryLock(tracy_lock_ctx, acquired); \end{lstlisting} -After you release the lock use the \texttt{TracyCLockAfterUnlock} macro: +Before you release the lock use the \texttt{TracyCLockBeforeUnlock} macro: \begin{lstlisting} +TracyCLockBeforeUnlock(tracy_lock_ctx); ReleaseMutex(lock); -TracyCLockAfterUnlock(tracy_lock_ctx); \end{lstlisting} You can optionally mark the location of where the lock is held by using the \texttt{TracyCLockMark} macro, this should be done after acquiring the lock. @@ -2423,11 +2423,11 @@ Similarly, you can use the following macros to mark a shared lock using the C AP \item \texttt{TracyCSharedLockTerminate(lock\_ctx)} \item \texttt{TracyCSharedLockBeforeLock(lock\_ctx)} \item \texttt{TracyCSharedLockAfterLock(lock\_ctx)} -\item \texttt{TracyCSharedLockAfterUnlock(lock\_ctx)} +\item \texttt{TracyCSharedLockBeforeUnlock(lock\_ctx)} \item \texttt{TracyCSharedLockAfterTryLock(lock\_ctx, acquired)} \item \texttt{TracyCSharedLockBeforeSharedLock(lock\_ctx)} \item \texttt{TracyCSharedLockAfterSharedLock(lock\_ctx)} -\item \texttt{TracyCSharedLockAfterSharedUnlock(lock\_ctx)} +\item \texttt{TracyCSharedLockBeforeSharedUnlock(lock\_ctx)} \item \texttt{TracyCSharedLockAfterTrySharedLock(lock\_ctx, acquired)} \item \texttt{TracyCSharedLockMark(lock\_ctx)} \item \texttt{TracyCSharedLockCustomName(lock\_ctx, name, size)} diff --git a/public/client/TracyLock.hpp b/public/client/TracyLock.hpp index 2ddbf342..7725db2c 100644 --- a/public/client/TracyLock.hpp +++ b/public/client/TracyLock.hpp @@ -85,7 +85,7 @@ public: Profiler::QueueSerialFinish(); } - tracy_force_inline void AfterUnlock() + tracy_force_inline void BeforeUnlock() { #ifdef TRACY_ON_DEMAND m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); @@ -199,8 +199,8 @@ public: tracy_force_inline void unlock() { + m_ctx.BeforeUnlock(); m_lockable.unlock(); - m_ctx.AfterUnlock(); } tracy_force_inline bool try_lock() @@ -300,7 +300,7 @@ public: Profiler::QueueSerialFinish(); } - tracy_force_inline void AfterUnlock() + tracy_force_inline void BeforeUnlock() { #ifdef TRACY_ON_DEMAND m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); @@ -381,7 +381,7 @@ public: Profiler::QueueSerialFinish(); } - tracy_force_inline void AfterUnlockShared() + tracy_force_inline void BeforeUnlockShared() { #ifdef TRACY_ON_DEMAND m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); @@ -496,8 +496,8 @@ public: tracy_force_inline void unlock() { + m_ctx.BeforeUnlock(); m_lockable.unlock(); - m_ctx.AfterUnlock(); } tracy_force_inline bool try_lock() @@ -516,8 +516,8 @@ public: tracy_force_inline void unlock_shared() { + m_ctx.BeforeUnlockShared(); m_lockable.unlock_shared(); - m_ctx.AfterUnlockShared(); } tracy_force_inline bool try_lock_shared() diff --git a/public/client/TracyProfiler.cpp b/public/client/TracyProfiler.cpp index 8fcd9991..fe241ad4 100644 --- a/public/client/TracyProfiler.cpp +++ b/public/client/TracyProfiler.cpp @@ -5424,7 +5424,7 @@ TRACY_API void ___tracy_after_lock_lockable_ctx( struct __tracy_lockable_context tracy::Profiler::QueueSerialFinish(); } -TRACY_API void ___tracy_after_unlock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ) +TRACY_API void ___tracy_before_unlock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ) { #ifdef TRACY_ON_DEMAND lockdata->m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); @@ -5564,9 +5564,9 @@ TRACY_API void ___tracy_after_lock_shared_lockable_ctx( struct __tracy_shared_lo ___tracy_after_lock_lockable_ctx( &lockdata->m_base ); } -TRACY_API void ___tracy_after_unlock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ) +TRACY_API void ___tracy_before_unlock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ) { - ___tracy_after_unlock_lockable_ctx( &lockdata->m_base ); + ___tracy_before_unlock_lockable_ctx( &lockdata->m_base ); } TRACY_API void ___tracy_after_try_lock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata, int32_t acquired ) @@ -5608,7 +5608,7 @@ TRACY_API void ___tracy_after_lock_shared_shared_lockable_ctx( struct __tracy_sh tracy::Profiler::QueueSerialFinish(); } -TRACY_API void ___tracy_after_unlock_shared_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ) +TRACY_API void ___tracy_before_unlock_shared_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ) { #ifdef TRACY_ON_DEMAND lockdata->m_base.m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); diff --git a/public/common/TracyProtocol.hpp b/public/common/TracyProtocol.hpp index f50d5ce1..d75c5fe7 100644 --- a/public/common/TracyProtocol.hpp +++ b/public/common/TracyProtocol.hpp @@ -10,7 +10,7 @@ namespace tracy constexpr unsigned Lz4CompressBound( unsigned isize ) { return isize + ( isize / 255 ) + 16; } -constexpr uint32_t ProtocolVersion = 82; +constexpr uint32_t ProtocolVersion = 83; constexpr uint16_t BroadcastVersion = 3; using lz4sz_t = uint32_t; diff --git a/public/tracy/TracyC.h b/public/tracy/TracyC.h index 6642e547..5a048e87 100644 --- a/public/tracy/TracyC.h +++ b/public/tracy/TracyC.h @@ -110,7 +110,7 @@ typedef const void* TracyCSharedLockCtx; #define TracyCLockTerminate(l) #define TracyCLockBeforeLock(l) #define TracyCLockAfterLock(l) -#define TracyCLockAfterUnlock(l) +#define TracyCLockBeforeUnlock(l) #define TracyCLockAfterTryLock(l,x) #define TracyCLockMark(l) #define TracyCLockCustomName(l,x,y) @@ -120,11 +120,11 @@ typedef const void* TracyCSharedLockCtx; #define TracyCSharedLockTerminate(l) #define TracyCSharedLockBeforeLock(l) #define TracyCSharedLockAfterLock(l) -#define TracyCSharedLockAfterUnlock(l) +#define TracyCSharedLockBeforeUnlock(l) #define TracyCSharedLockAfterTryLock(l,x) #define TracyCSharedLockBeforeSharedLock(l) #define TracyCSharedLockAfterSharedLock(l) -#define TracyCSharedLockAfterSharedUnlock(l) +#define TracyCSharedLockBeforeSharedUnlock(l) #define TracyCSharedLockAfterTrySharedLock(l,x) #define TracyCSharedLockMark(l) #define TracyCSharedLockCustomName(l,x,y) @@ -369,7 +369,7 @@ TRACY_API struct __tracy_lockable_context_data* ___tracy_announce_lockable_ctx( TRACY_API void ___tracy_terminate_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); TRACY_API int32_t ___tracy_before_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); TRACY_API void ___tracy_after_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); -TRACY_API void ___tracy_after_unlock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); +TRACY_API void ___tracy_before_unlock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); TRACY_API void ___tracy_after_try_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata, int32_t acquired ); TRACY_API void ___tracy_mark_lockable_ctx( struct __tracy_lockable_context_data* lockdata, const struct ___tracy_source_location_data* srcloc ); TRACY_API void ___tracy_custom_name_lockable_ctx( struct __tracy_lockable_context_data* lockdata, const char* name, size_t nameSz ); @@ -378,11 +378,11 @@ TRACY_API struct __tracy_shared_lockable_context_data* ___tracy_announce_shared_ TRACY_API void ___tracy_terminate_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); TRACY_API int32_t ___tracy_before_lock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); TRACY_API void ___tracy_after_lock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); -TRACY_API void ___tracy_after_unlock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); +TRACY_API void ___tracy_before_unlock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); TRACY_API void ___tracy_after_try_lock_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata, int32_t acquired ); TRACY_API int32_t ___tracy_before_lock_shared_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); TRACY_API void ___tracy_after_lock_shared_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); -TRACY_API void ___tracy_after_unlock_shared_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); +TRACY_API void ___tracy_before_unlock_shared_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata ); TRACY_API void ___tracy_after_try_lock_shared_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata, int32_t acquired ); TRACY_API void ___tracy_mark_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata, const struct ___tracy_source_location_data* srcloc ); TRACY_API void ___tracy_custom_name_shared_lockable_ctx( struct __tracy_shared_lockable_context_data* lockdata, const char* name, size_t nameSz ); @@ -392,7 +392,7 @@ TRACY_API void ___tracy_custom_name_shared_lockable_ctx( struct __tracy_shared_l #define TracyCLockTerminate( lock ) ___tracy_terminate_lockable_ctx( lock ); #define TracyCLockBeforeLock( lock ) ___tracy_before_lock_lockable_ctx( lock ); #define TracyCLockAfterLock( lock ) ___tracy_after_lock_lockable_ctx( lock ); -#define TracyCLockAfterUnlock( lock ) ___tracy_after_unlock_lockable_ctx( lock ); +#define TracyCLockBeforeUnlock( lock ) ___tracy_before_unlock_lockable_ctx( lock ); #define TracyCLockAfterTryLock( lock, acquired ) ___tracy_after_try_lock_lockable_ctx( lock, acquired ); #define TracyCLockMark( lock ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, 0 }; ___tracy_mark_lockable_ctx( lock, &TracyConcat(__tracy_source_location,TracyLine) ); #define TracyCLockCustomName( lock, name, nameSz ) ___tracy_custom_name_lockable_ctx( lock, name, nameSz ); @@ -401,11 +401,11 @@ TRACY_API void ___tracy_custom_name_shared_lockable_ctx( struct __tracy_shared_l #define TracyCSharedLockTerminate( lock ) ___tracy_terminate_shared_lockable_ctx( lock ); #define TracyCSharedLockBeforeLock( lock ) ___tracy_before_lock_shared_lockable_ctx( lock ); #define TracyCSharedLockAfterLock( lock ) ___tracy_after_lock_shared_lockable_ctx( lock ); -#define TracyCSharedLockAfterUnlock( lock ) ___tracy_after_unlock_shared_lockable_ctx( lock ); +#define TracyCSharedLockBeforeUnlock( lock ) ___tracy_before_unlock_shared_lockable_ctx( lock ); #define TracyCSharedLockAfterTryLock( lock, acquired ) ___tracy_after_try_lock_shared_lockable_ctx( lock, acquired ); #define TracyCSharedLockBeforeSharedLock( lock ) ___tracy_before_lock_shared_shared_lockable_ctx( lock ); #define TracyCSharedLockAfterSharedLock( lock ) ___tracy_after_lock_shared_shared_lockable_ctx( lock ); -#define TracyCSharedLockAfterSharedUnlock( lock ) ___tracy_after_unlock_shared_shared_lockable_ctx( lock ); +#define TracyCSharedLockBeforeSharedUnlock( lock ) ___tracy_before_unlock_shared_shared_lockable_ctx( lock ); #define TracyCSharedLockAfterTrySharedLock( lock, acquired ) ___tracy_after_try_lock_shared_shared_lockable_ctx( lock, acquired ); #define TracyCSharedLockMark( lock ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, 0 }; ___tracy_mark_shared_lockable_ctx( lock, &TracyConcat(__tracy_source_location,TracyLine) ); #define TracyCSharedLockCustomName( lock, name, nameSz ) ___tracy_custom_name_shared_lockable_ctx( lock, name, nameSz );