Add ATTR_NO_SANITIZE_THREAD and use it to silence a tsan warning

Author: zpostfacto

src/public/minbase/minbase_decls.h

@@ -156,6 +156,17 @@
     #endif
 #endif
 
+// Suppress ThreadSanitizer instrumentation for a function.
+// Use this for functions that intentionally access shared data without holding a lock,
+// where the access is known to be safe (e.g. a lockless hint-read with a locked slow path).
+// Prefer this over making the variable std::atomic<>, which would suppress TSan on ALL
+// accesses to the variable and could mask unintentional races elsewhere.
+#ifdef __SANITIZE_THREAD__
+	#define ATTR_NO_SANITIZE_THREAD __attribute__(( no_sanitize_thread ))
+#else
+	#define ATTR_NO_SANITIZE_THREAD
+#endif
+
 // We have some template functions declared in header files that
 // only need static scope. Older MSVC version lets you use 'static' qualifiers
 // but GCC and new MSVC does not, where we need to use 'inline' to avoid multiple definitions.

src/steamnetworkingsockets/steamnetworkingsockets_thinker.cpp

@@ -76,8 +76,18 @@ void IThinker::InternalEnsureMinThinkTime( SteamNetworkingMicroseconds usecTarge
 	s_mutexThinkerTable.unlock();
 }
 
-void IThinker::SetNextThinkTime( SteamNetworkingMicroseconds usecTargetThinkTime )
+ATTR_NO_SANITIZE_THREAD void IThinker::SetNextThinkTime( SteamNetworkingMicroseconds usecTargetThinkTime )
 {
+	// Fast-path: check whether the schedule is already set to the requested time before acquiring
+	// the thinker mutex.  This read of m_usecNextThinkTime is intentionally lockless -- the service
+	// thread may write it concurrently.  The race is safe because:
+	//   1. The read is a hint only.  A stale or torn value just causes a spurious fall-through to
+	//      InternalSetNextThinkTime, which re-checks under the lock.  There is no state corruption.
+	//   2. On all supported 64-bit platforms the aligned 64-bit load is atomic at the hardware level,
+	//      so a torn read is not possible in practice.
+	// We use ATTR_NO_SANITIZE_THREAD rather than making m_usecNextThinkTime std::atomic<> because
+	// std::atomic would suppress TSan on every access to the variable, masking any future
+	// unintentional races.  The attribute suppresses only this one known-safe lockless access.
 	if ( usecTargetThinkTime == m_usecNextThinkTime )
 		return;
 	s_mutexThinkerTable.lock();

src/steamnetworkingsockets/steamnetworkingsockets_thinker.h

@@ -31,8 +31,9 @@ class IThinker
 
 	/// Adjust schedule time to the earlier of the current schedule time,
 	/// or the given time.
-	inline void EnsureMinThinkTime( SteamNetworkingMicroseconds usecTargetThinkTime )
+	ATTR_NO_SANITIZE_THREAD inline void EnsureMinThinkTime( SteamNetworkingMicroseconds usecTargetThinkTime )
 	{
+		// Lockless fast-path read -- see SetNextThinkTime for explanation of the intentional race.
 		if ( usecTargetThinkTime < m_usecNextThinkTime )
 			InternalEnsureMinThinkTime( usecTargetThinkTime );
 	}