Merge pull request #108 from RaphaelIT7/patch-6

dimhotepus · web-flow · commit ee09a8e4a377 · 2024-12-07T17:31:11.000+03:00
[tier0] Fix a linux 64x vprof bug
diff --git a/engine/host_saverestore.cpp b/engine/host_saverestore.cpp
@@ -125,7 +125,7 @@ static bool HaveExactMap( const char *pszMapName )
 static void FinishAsyncSave()
 {
 	LOCAL_THREAD_LOCK();
-	SaveMsg( "FinishAsyncSave() (%d/%d)\n", ThreadInMainThread(), ThreadGetCurrentId() );
+	SaveMsg( "FinishAsyncSave() (%d/%lu)\n", ThreadInMainThread(), ThreadGetCurrentId() );
 	if ( g_AsyncSaveCallQueue.Count() )
 	{
 		g_AsyncSaveCallQueue.CallQueued();
@@ -628,7 +628,7 @@ int CSaveRestore::SaveGameSlot( const char *pSaveName, const char *pSaveComment,
 		Sys_Sleep( clamp( save_asyncdelay.GetInt(), 0, 3000 ) );
 	}
 
-	SaveMsg( "Start save... (%d/%d)\n", ThreadInMainThread(), ThreadGetCurrentId() );
+	SaveMsg( "Start save... (%d/%lu)\n", ThreadInMainThread(), ThreadGetCurrentId() );
 	VPROF_BUDGET( "SaveGameSlot", "Save" );
 	char			hlPath[256], name[256], *pTokenData;
 	int				tag, i, tokenSize;
diff --git a/filesystem/QueuedLoader.cpp b/filesystem/QueuedLoader.cpp
@@ -99,7 +99,7 @@ struct FileJob_t
 	int						m_SubmitTag;
 	int						m_nActualBytesRead;
 	LoaderError_t			m_LoaderError;
-	unsigned int			m_ThreadId;
+	ThreadId_t				m_ThreadId;
 
 	unsigned int			m_bFinished : 1;
 	unsigned int			m_bFreeTargetAfterIO : 1;
diff --git a/game/shared/collisionproperty.cpp b/game/shared/collisionproperty.cpp
@@ -73,7 +73,7 @@ class CDirtySpatialPartitionEntityList : public CAutoGameSystem, public IPartiti
 private:
 	CTSListWithFreeList<CBaseHandle> m_DirtyEntities;
 	CThreadSpinRWLock	 m_partitionMutex;
-	uint32			 m_partitionWriteId;
+	ThreadId_t			 m_partitionWriteId;
 	CThreadLocalInt<>	 m_readLockCount;
 };
 
diff --git a/gcsdk/jobmgr.cpp b/gcsdk/jobmgr.cpp
@@ -1265,7 +1265,7 @@ int CJobMgr::CountJobs() const
 //-----------------------------------------------------------------------------
 void CJobMgr::CheckThreadID()
 {
-	uint unCurrentThread = ThreadGetCurrentId();
+	ThreadId_t unCurrentThread = ThreadGetCurrentId();
 
 	if ( m_unFrameFuncThreadID == 0 )
 	{
diff --git a/materialsystem/cmaterialsystem.cpp b/materialsystem/cmaterialsystem.cpp
@@ -349,7 +349,7 @@ void CMaterialSystem::CleanUpErrorMaterial()
 //-----------------------------------------------------------------------------
 CMaterialSystem::CMaterialSystem()
 {
-	m_nRenderThreadID = 0xFFFFFFFF;
+	m_nRenderThreadID = -1;
 	m_hAsyncLoadFileCache = NULL;
 	m_ShaderHInst = NULL;
 	m_ShaderAPIFactory = NULL;
@@ -3364,7 +3364,7 @@ void CMaterialSystem::ThreadExecuteQueuedContext( CMatQueuedRenderContext *pCont
 	m_pRenderContext.Set( &m_HardwareRenderContext );
 	pContext->EndQueue( true );
 	m_pRenderContext.Set( pSavedRenderContext );
-	m_nRenderThreadID = 0xFFFFFFFF; 
+	m_nRenderThreadID = -1; 
 }
 
 IThreadPool *CMaterialSystem::CreateMatQueueThreadPool()
diff --git a/materialsystem/cmaterialsystem.h b/materialsystem/cmaterialsystem.h
@@ -574,7 +574,7 @@ class CMaterialSystem : public CTier2AppSystem< IMaterialSystemInternal >, publi
 	MaterialLock_t							Lock();
 	void									Unlock( MaterialLock_t );
 	CMatCallQueue *							GetRenderCallQueue();
-	uint									GetRenderThreadId() const { return m_nRenderThreadID; }
+	ThreadId_t								GetRenderThreadId() const { return m_nRenderThreadID; }
 	void									UnbindMaterial( IMaterial *pMaterial );
 
 	IMaterialProxy							*DetermineProxyReplacements( IMaterial *pMaterial, KeyValues *pFallbackKeyValues );
@@ -700,15 +700,15 @@ class CMaterialSystem : public CTier2AppSystem< IMaterialSystemInternal >, publi
 
 	const char *							m_pForcedTextureLoadPathID;
 	FileCacheHandle_t						m_hAsyncLoadFileCache;
-	uint									m_nRenderThreadID;
+	ThreadId_t								m_nRenderThreadID;
 	bool									m_bAllocatingRenderTargets;
 	bool									m_bInStubMode;
 	bool									m_bGeneratedConfig;
 	bool									m_bInFrame;
 	bool									m_bForcedSingleThreaded;
 	bool									m_bAllowQueuedRendering;
 	std::atomic_bool						m_bThreadHasOwnership;
-	uint									m_ThreadOwnershipID;
+	ThreadId_t								m_ThreadOwnershipID;
 
 	//---------------------------------
 
diff --git a/materialsystem/ctexture.cpp b/materialsystem/ctexture.cpp
@@ -3980,7 +3980,7 @@ void CTexture::DeleteIfUnreferenced()
 	if ( ThreadInMainThread() )
 	{
 		// Render thread better not be active or bad things can happen.
-		Assert( MaterialSystem()->GetRenderThreadId() == 0xFFFFFFFF );
+		Assert( MaterialSystem()->GetRenderThreadId() == -1 );
 		TextureManager()->RemoveTexture( this );
 		return;
 	}
diff --git a/materialsystem/imaterialsysteminternal.h b/materialsystem/imaterialsysteminternal.h
@@ -223,7 +223,7 @@ abstract_class IMaterialSystemInternal : public IMaterialSystem
 	virtual CMatCallQueue *GetRenderCallQueue() = 0;
 
 	virtual void UnbindMaterial( IMaterial *pMaterial ) = 0;
-	virtual uint GetRenderThreadId() const = 0 ;
+	virtual ThreadId_t GetRenderThreadId() const = 0 ;
 
 	virtual IMaterialProxy	*DetermineProxyReplacements( IMaterial *pMaterial, KeyValues *pFallbackKeyValues ) = 0;
 };
diff --git a/materialsystem/shaderapidx9/shaderdevicebase.cpp b/materialsystem/shaderapidx9/shaderdevicebase.cpp
@@ -902,7 +902,7 @@ void CShaderDeviceBase::SetCurrentThreadAsOwner()
 
 void CShaderDeviceBase::RemoveThreadOwner()
 {
-	m_dwThreadId = 0xFFFFFFFF;
+	m_dwThreadId = -1;
 }
 
 bool CShaderDeviceBase::ThreadOwnsDevice()
diff --git a/materialsystem/shaderapidx9/shaderdevicebase.h b/materialsystem/shaderapidx9/shaderdevicebase.h
@@ -184,7 +184,7 @@ class CShaderDeviceBase : public IShaderDevice
 
 	int	m_nWindowWidth;
 	int m_nWindowHeight;
-	uint32 m_dwThreadId;
+	ThreadId_t m_dwThreadId;
 };
 
 
diff --git a/materialsystem/texturemanager.cpp b/materialsystem/texturemanager.cpp
@@ -748,8 +748,8 @@ class CTextureManager : public ITextureManager
 	friend class AsyncReader;
 	AsyncReader* m_pAsyncReader;
 
-	uint m_nAsyncLoadThread;
-	uint m_nAsyncReadThread;
+	ThreadId_t m_nAsyncLoadThread;
+	ThreadId_t m_nAsyncReadThread;
 
 	int m_iSuspendTextureStreaming;
 };
@@ -1097,7 +1097,7 @@ class TSLIST_HEAD_ALIGN AsyncLoader : public CAlignedNewDelete<TSLIST_HEAD_ALIGN
 
 		s_TextureManager.m_nAsyncLoadThread = ThreadGetCurrentId();
 		( ( AsyncLoader* )_this )->ThreadLoader_Main();
-		s_TextureManager.m_nAsyncLoadThread = 0xFFFFFFFF;
+		s_TextureManager.m_nAsyncLoadThread = -1;
 		return 0;
 	}
 
@@ -1397,7 +1397,7 @@ class TSLIST_HEAD_ALIGN AsyncReader : public CAlignedNewDelete<TSLIST_HEAD_ALIGN
 
 		s_TextureManager.m_nAsyncReadThread = ThreadGetCurrentId();
 		( ( AsyncReader* ) _this )->ThreadReader_Main();
-		s_TextureManager.m_nAsyncReadThread = 0xFFFFFFFF;
+		s_TextureManager.m_nAsyncReadThread = -1;
 		return 0;
 	}
 
@@ -1422,8 +1422,8 @@ CTextureManager::CTextureManager( void )
 , m_TextureExcludes( true )
 , m_PendingAsyncLoads( true ) 
 , m_textureStreamingRequests( DefLessFunc( ITextureInternal* ) )
-, m_nAsyncLoadThread( 0xFFFFFFFF )
-, m_nAsyncReadThread( 0xFFFFFFFF )
+, m_nAsyncLoadThread( -1 )
+, m_nAsyncReadThread( -1 )
 {
 	m_iNextTexID = 0;
 	m_nFlags = 0;
diff --git a/public/gcsdk/jobmgr.h b/public/gcsdk/jobmgr.h
@@ -301,7 +301,7 @@ class CJobMgr
 	friend void Job_RegisterJobType( const JobType_t *pJobType );
 
 	JobID_t m_unNextJobID;
-	uint m_unFrameFuncThreadID; // the thread is JobMgr is working in
+	ThreadId_t m_unFrameFuncThreadID; // the thread is JobMgr is working in
 	bool m_bProfiling;
 	bool m_bIsShuttingDown;
 	int m_cErrorsToReport;
diff --git a/public/tier0/threadtools.h b/public/tier0/threadtools.h
@@ -109,7 +109,7 @@ PLATFORM_INTERFACE bool ReleaseThreadHandle( ThreadHandle_t );
 //-----------------------------------------------------------------------------
 
 PLATFORM_INTERFACE void ThreadSleep(unsigned duration = 0);
-PLATFORM_INTERFACE uint ThreadGetCurrentId();
+PLATFORM_INTERFACE ThreadId_t ThreadGetCurrentId();
 PLATFORM_INTERFACE ThreadHandle_t ThreadGetCurrentHandle();
 PLATFORM_INTERFACE int ThreadGetPriority( ThreadHandle_t hThread = nullptr );
 PLATFORM_INTERFACE bool ThreadSetPriority( ThreadHandle_t hThread, int priority );
@@ -733,7 +733,7 @@ class PLATFORM_CLASS CThreadMutex
 
 #ifdef THREAD_MUTEX_TRACING_SUPPORTED
 	// Debugging (always here to allow mixed debug/release builds w/o changing size)
-	uint	m_currentOwnerID;
+	ThreadId_t	m_currentOwnerID;
 	uint16	m_lockCount;
 	bool	m_bTrace;
 #endif
@@ -761,7 +761,7 @@ class CThreadFastMutex
 	}
 
 private:
-	FORCEINLINE bool TryLockInline( const uint32 threadId )
+	FORCEINLINE bool TryLockInline( const ThreadId_t threadId )
 	{
 		if ( threadId != m_ownerID.GetRaw() && !m_ownerID.AssignIf( 0, threadId ) )
 			return false;
@@ -771,17 +771,17 @@ class CThreadFastMutex
 		return true;
 	}
 
-	bool TryLock( const uint32 threadId )
+	bool TryLock( const ThreadId_t threadId )
 	{
 		return TryLockInline( threadId );
 	}
 	
 	// dimhotepus: This one is for old vphysics dll to work. 
 	PLATFORM_CLASS void Lock( const uint32 threadId, unsigned nSpinSleepTime ) volatile
 	{
-		const_cast<CThreadFastMutex *>(this)->Lock(threadId, nSpinSleepTime);
+		const_cast<CThreadFastMutex *>(this)->Lock( (ThreadId_t)threadId, nSpinSleepTime);
 	}
-	PLATFORM_CLASS void Lock( const uint32 threadId, unsigned nSpinSleepTime );
+	PLATFORM_CLASS void Lock( const ThreadId_t threadId, unsigned nSpinSleepTime );
 
 public:
 	bool TryLock()
@@ -801,7 +801,7 @@ class CThreadFastMutex
 #endif
 	void Lock( unsigned int nSpinSleepTime = 0 )
 	{
-		const uint32 threadId = ThreadGetCurrentId();
+		const ThreadId_t threadId = ThreadGetCurrentId();
 
 		if ( !TryLockInline( threadId ) )
 		{
@@ -1257,13 +1257,13 @@ class ALIGN8 PLATFORM_CLASS CThreadSpinRWLock : public CAlignedNewDelete<8>
 private:
 	struct LockInfo_t
 		{
-			uint32	m_writerId;
+			ThreadId_t	m_writerId;
 			int		m_nReaders;
 		};
 
 	bool AssignIf( const LockInfo_t &newValue, const LockInfo_t &comperand );
-	bool TryLockForWrite( const uint32 threadId );
-	void SpinLockForWrite( const uint32 threadId );
+	bool TryLockForWrite( const ThreadId_t threadId );
+	void SpinLockForWrite( const ThreadId_t threadId );
 
 	volatile LockInfo_t m_lockInfo;
 
@@ -1652,9 +1652,9 @@ extern "C"
 inline void CThreadMutex::Lock()
 {
 #ifdef THREAD_MUTEX_TRACING_ENABLED
-		uint thisThreadID = ThreadGetCurrentId();
+		ThreadId_t thisThreadID = ThreadGetCurrentId();
 		if ( m_bTrace && m_currentOwnerID && ( m_currentOwnerID != thisThreadID ) )
-		Msg( "Thread %u about to wait for lock %p owned by %u\n", ThreadGetCurrentId(), (CRITICAL_SECTION *)&m_CriticalSection, m_currentOwnerID );
+		Msg( "Thread %lu about to wait for lock %p owned by %lu\n", ThreadGetCurrentId(), (CRITICAL_SECTION *)&m_CriticalSection, m_currentOwnerID );
 	#endif
 
 	VCRHook_EnterCriticalSection((CRITICAL_SECTION *)&m_CriticalSection);
@@ -1665,7 +1665,7 @@ inline void CThreadMutex::Lock()
 			// we now own it for the first time.  Set owner information
 			m_currentOwnerID = thisThreadID;
 			if ( m_bTrace )
-			Msg( "Thread %u now owns lock %p\n", m_currentOwnerID, (CRITICAL_SECTION *)&m_CriticalSection );
+			Msg( "Thread %lu now owns lock %p\n", m_currentOwnerID, (CRITICAL_SECTION *)&m_CriticalSection );
 		}
 		m_lockCount++;
 	#endif
@@ -1681,7 +1681,7 @@ inline void CThreadMutex::Unlock()
 		if (m_lockCount == 0)
 		{
 			if ( m_bTrace )
-			Msg( "Thread %u releasing lock %p\n", m_currentOwnerID, (CRITICAL_SECTION *)&m_CriticalSection );
+			Msg( "Thread %lu releasing lock %p\n", m_currentOwnerID, (CRITICAL_SECTION *)&m_CriticalSection );
 			m_currentOwnerID = 0;
 		}
 	#endif
@@ -1695,7 +1695,7 @@ inline bool CThreadMutex::AssertOwnedByCurrentThread() const
 #ifdef THREAD_MUTEX_TRACING_ENABLED
 	if (ThreadGetCurrentId() == m_currentOwnerID)
 		return true;
-	AssertMsg3( 0, "Expected thread %u as owner of lock %p, but %u owns", ThreadGetCurrentId(), (const CRITICAL_SECTION *)&m_CriticalSection, m_currentOwnerID );
+	AssertMsg3( 0, "Expected thread %lu as owner of lock %p, but %lu owns", ThreadGetCurrentId(), (const CRITICAL_SECTION *)&m_CriticalSection, m_currentOwnerID );
 	return false;
 #else
 	return true;
@@ -1807,7 +1807,7 @@ inline bool CThreadSpinRWLock::AssignIf( const LockInfo_t &newValue, const LockI
 	return ThreadInterlockedAssignIf64( (volatile int64 *)&m_lockInfo, *((const int64 *)&newValue), *((const int64 *)&comperand) );
 }
 
-inline bool CThreadSpinRWLock::TryLockForWrite( const uint32 threadId )
+inline bool CThreadSpinRWLock::TryLockForWrite( const ThreadId_t threadId )
 {
 	// In order to grab a write lock, there can be no readers and no owners of the write lock
 	if ( m_lockInfo.m_nReaders > 0 || ( m_lockInfo.m_writerId && m_lockInfo.m_writerId != threadId ) )
@@ -1860,7 +1860,7 @@ inline bool CThreadSpinRWLock::TryLockForRead()
 
 inline void CThreadSpinRWLock::LockForWrite()
 {
-	const uint32 threadId = ThreadGetCurrentId();
+	const ThreadId_t threadId = ThreadGetCurrentId();
 
 	++m_nWriters;
 
diff --git a/public/tier0/vprof.h b/public/tier0/vprof.h
@@ -400,8 +400,8 @@ class DBG_CLASS CVProfile
 	void Start();
 	void Stop();
 
-	void SetTargetThreadId( unsigned id ) { m_TargetThreadId = id; }
-	unsigned GetTargetThreadId() const { return m_TargetThreadId; }
+	void SetTargetThreadId( ThreadId_t id ) { m_TargetThreadId = id; }
+	ThreadId_t GetTargetThreadId() const { return m_TargetThreadId; }
 	bool InTargetThread() const { return ( m_TargetThreadId == ThreadGetCurrentId() ); }
 
 	void EnterScope( const tchar *pszName, int detailLevel, const tchar *pBudgetGroupName, bool bAssertAccounted );
@@ -545,7 +545,7 @@ class DBG_CLASS CVProfile
 	tchar *m_CounterNames[MAXCOUNTERS];
 	int m_NumCounters;
 
-	unsigned m_TargetThreadId;
+	ThreadId_t m_TargetThreadId;
 
 	StreamOut_t				m_pOutputStream;
 };
diff --git a/tier0/thread.cpp b/tier0/thread.cpp
@@ -15,7 +15,7 @@
 #include "tier0/dbg.h"
 #include "tier0/threadtools.h"
 
-unsigned long Plat_GetCurrentThreadID()
+ThreadId_t Plat_GetCurrentThreadID()
 {
 	return ThreadGetCurrentId();
 }
diff --git a/tier0/threadtools.cpp b/tier0/threadtools.cpp

Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ static bool HaveExactMap( const char *pszMapName )`
`125`	`125`	`static void FinishAsyncSave()`
`126`	`126`	`{`
`127`	`127`	`LOCAL_THREAD_LOCK();`
`128`		`- SaveMsg( "FinishAsyncSave() (%d/%d)\n", ThreadInMainThread(), ThreadGetCurrentId() );`
	`128`	`+ SaveMsg( "FinishAsyncSave() (%d/%lu)\n", ThreadInMainThread(), ThreadGetCurrentId() );`
`129`	`129`	`if ( g_AsyncSaveCallQueue.Count() )`
`130`	`130`	`{`
`131`	`131`	`g_AsyncSaveCallQueue.CallQueued();`
`@@ -628,7 +628,7 @@ int CSaveRestore::SaveGameSlot( const char pSaveName, const char pSaveComment,`
`628`	`628`	`Sys_Sleep( clamp( save_asyncdelay.GetInt(), 0, 3000 ) );`
`629`	`629`	`}`
`630`	`630`
`631`		`- SaveMsg( "Start save... (%d/%d)\n", ThreadInMainThread(), ThreadGetCurrentId() );`
	`631`	`+ SaveMsg( "Start save... (%d/%lu)\n", ThreadInMainThread(), ThreadGetCurrentId() );`
`632`	`632`	`VPROF_BUDGET( "SaveGameSlot", "Save" );`
`633`	`633`	`char hlPath[256], name[256], *pTokenData;`
`634`	`634`	`int tag, i, tokenSize;`
Original file line number	Diff line number	Diff line change
`@@ -1265,7 +1265,7 @@ int CJobMgr::CountJobs() const`
`1265`	`1265`	`//-----------------------------------------------------------------------------`
`1266`	`1266`	`void CJobMgr::CheckThreadID()`
`1267`	`1267`	`{`
`1268`		`- uint unCurrentThread = ThreadGetCurrentId();`
	`1268`	`+ ThreadId_t unCurrentThread = ThreadGetCurrentId();`
`1269`	`1269`
`1270`	`1270`	`if ( m_unFrameFuncThreadID == 0 )`
`1271`	`1271`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3980,7 +3980,7 @@ void CTexture::DeleteIfUnreferenced()`
`3980`	`3980`	`if ( ThreadInMainThread() )`
`3981`	`3981`	`{`
`3982`	`3982`	`// Render thread better not be active or bad things can happen.`
`3983`		`- Assert( MaterialSystem()->GetRenderThreadId() == 0xFFFFFFFF );`
	`3983`	`+ Assert( MaterialSystem()->GetRenderThreadId() == -1 );`
`3984`	`3984`	`TextureManager()->RemoveTexture( this );`
`3985`	`3985`	`return;`
`3986`	`3986`	`}`
Original file line number	Diff line number	Diff line change
`@@ -902,7 +902,7 @@ void CShaderDeviceBase::SetCurrentThreadAsOwner()`
`902`	`902`
`903`	`903`	`void CShaderDeviceBase::RemoveThreadOwner()`
`904`	`904`	`{`
`905`		`- m_dwThreadId = 0xFFFFFFFF;`
	`905`	`+ m_dwThreadId = -1;`
`906`	`906`	`}`
`907`	`907`
`908`	`908`	`bool CShaderDeviceBase::ThreadOwnsDevice()`