From 782231b04840303644c10621dcf469818f1a2bcb Mon Sep 17 00:00:00 2001 From: Bartosz Taudul Date: Sun, 10 Dec 2017 21:49:45 +0100 Subject: [PATCH] Shared lockable skeleton. --- Tracy.hpp | 6 +++ client/TracyLock.hpp | 122 ++++++++++++++++++++++++++++++++++++++++++ common/TracyQueue.hpp | 3 +- server/TracyView.cpp | 3 ++ 4 files changed, 133 insertions(+), 1 deletion(-) diff --git a/Tracy.hpp b/Tracy.hpp index 20e9d73a..d8ed519b 100644 --- a/Tracy.hpp +++ b/Tracy.hpp @@ -18,7 +18,10 @@ #define TracyLockable( type, varname ) type varname; #define TracyLockableN( type, varname, desc ) type varname; +#define TracySharedLockable( type, varname ) type varname; +#define TracySharedLockableN( type, varname, desc ) type varname; #define LockableBase( type ) type +#define SharedLockableBase( type ) type #define LockMark(x) (void)x; #define TracyPlot(x,y) @@ -43,7 +46,10 @@ #define TracyLockable( type, varname ) tracy::Lockable varname { [] () -> const tracy::SourceLocation* { static const tracy::SourceLocation srcloc { nullptr, #type " " #varname, __FILE__, __LINE__, 0 }; return &srcloc; }() }; #define TracyLockableN( type, varname, desc ) tracy::Lockable varname { [] () -> const tracy::SourceLocation* { static const tracy::SourceLocation srcloc { nullptr, desc, __FILE__, __LINE__, 0 }; return &srcloc; }() }; +#define TracySharedLockable( type, varname ) tracy::SharedLockable varname { [] () -> const tracy::SourceLocation* { static const tracy::SourceLocation srcloc { nullptr, #type " " #varname, __FILE__, __LINE__, 0 }; return &srcloc; }() }; +#define TracySharedLockableN( type, varname, desc ) tracy::SharedLockable varname { [] () -> const tracy::SourceLocation* { static const tracy::SourceLocation srcloc { nullptr, desc, __FILE__, __LINE__, 0 }; return &srcloc; }() }; #define LockableBase( type ) tracy::Lockable +#define SharedLockableBase( type ) tracy::SharedLockable #define LockMark( varname ) static const tracy::SourceLocation __tracy_lock_location_##varname { nullptr, __FUNCTION__, __FILE__, (uint32_t)__LINE__, 0 }; varname.Mark( &__tracy_lock_location_##varname ); #define TracyPlot( name, val ) tracy::Profiler::PlotData( name, val ); diff --git a/client/TracyLock.hpp b/client/TracyLock.hpp index e9345941..cc304861 100644 --- a/client/TracyLock.hpp +++ b/client/TracyLock.hpp @@ -116,6 +116,128 @@ private: uint32_t m_id; }; + +template +class SharedLockable +{ +public: + tracy_force_inline SharedLockable( const SourceLocation* srcloc ) + : m_id( s_lockCounter.fetch_add( 1, std::memory_order_relaxed ) ) + { + assert( m_id != std::numeric_limits::max() ); + + Magic magic; + auto& token = s_token.ptr; + auto& tail = token->get_tail_index(); + auto item = token->enqueue_begin( magic ); + item->hdr.type = QueueType::LockAnnounce; + item->lockAnnounce.id = m_id; + item->lockAnnounce.lckloc = (uint64_t)srcloc; + item->lockAnnounce.type = LockType::SharedLockable; + tail.store( magic + 1, std::memory_order_release ); + } + + SharedLockable( const SharedLockable& ) = delete; + SharedLockable& operator=( const SharedLockable& ) = delete; + + tracy_force_inline void lock() + { + const auto thread = GetThreadHandle(); + { + Magic magic; + auto& token = s_token.ptr; + auto& tail = token->get_tail_index(); + auto item = token->enqueue_begin( magic ); + item->hdr.type = QueueType::LockWait; + item->lockWait.id = m_id; + item->lockWait.thread = thread; + item->lockWait.time = Profiler::GetTime(); + tail.store( magic + 1, std::memory_order_release ); + } + + m_lockable.lock(); + + { + Magic magic; + auto& token = s_token.ptr; + auto& tail = token->get_tail_index(); + auto item = token->enqueue_begin( magic ); + item->hdr.type = QueueType::LockObtain; + item->lockObtain.id = m_id; + item->lockObtain.thread = thread; + item->lockObtain.time = Profiler::GetTime(); + tail.store( magic + 1, std::memory_order_release ); + } + } + + tracy_force_inline void unlock() + { + m_lockable.unlock(); + + Magic magic; + auto& token = s_token.ptr; + auto& tail = token->get_tail_index(); + auto item = token->enqueue_begin( magic ); + item->hdr.type = QueueType::LockRelease; + item->lockRelease.id = m_id; + item->lockRelease.thread = GetThreadHandle(); + item->lockRelease.time = Profiler::GetTime(); + tail.store( magic + 1, std::memory_order_release ); + } + + tracy_force_inline bool try_lock() + { + const auto ret = m_lockable.try_lock(); + if( ret ) + { + Magic magic; + auto& token = s_token.ptr; + auto& tail = token->get_tail_index(); + auto item = token->enqueue_begin( magic ); + item->hdr.type = QueueType::LockObtain; + item->lockObtain.id = (uint64_t)&m_lockable; + item->lockObtain.thread = GetThreadHandle(); + item->lockObtain.time = Profiler::GetTime(); + tail.store( magic + 1, std::memory_order_release ); + } + return ret; + } + + tracy_force_inline void lock_shared() + { + m_lockable.lock_shared(); + } + + tracy_force_inline void unlock_shared() + { + m_lockable.unlock_shared(); + } + + tracy_force_inline bool try_lock_shared() + { + const auto ret = m_lockable.try_lock_shared(); + return ret; + } + + tracy_force_inline void Mark( const SourceLocation* srcloc ) const + { + Magic magic; + auto& token = s_token.ptr; + auto& tail = token->get_tail_index(); + auto item = token->enqueue_begin( magic ); + item->hdr.type = QueueType::LockMark; + item->lockMark.id = m_id; + item->lockMark.thread = GetThreadHandle(); + item->lockMark.srcloc = (uint64_t)srcloc; + tail.store( magic + 1, std::memory_order_release ); + } + +private: + T m_lockable; + uint32_t m_id; +}; + + }; #endif diff --git a/common/TracyQueue.hpp b/common/TracyQueue.hpp index 31c39c3c..f861ff1d 100644 --- a/common/TracyQueue.hpp +++ b/common/TracyQueue.hpp @@ -82,7 +82,8 @@ struct QueueZoneText enum class LockType : uint8_t { - Lockable + Lockable, + SharedLockable }; struct QueueLockAnnounce diff --git a/server/TracyView.cpp b/server/TracyView.cpp index de80034b..ecb1a7b6 100644 --- a/server/TracyView.cpp +++ b/server/TracyView.cpp @@ -3156,6 +3156,9 @@ int View::DrawLocks( uint64_t tid, bool hover, double pxns, const ImVec2& wpos, case LockType::Lockable: ImGui::Text( "Type: lockable" ); break; + case LockType::SharedLockable: + ImGui::Text( "Type: shared lockable" ); + break; default: assert( false ); break;