Merge pull request #99 from Mauler125/aligned_memalloc

Fix aligned memalloc

r5dev/engine/cmodel_bsp.cpp

@@ -338,13 +338,13 @@ void Mod_ProcessPakQueue()
             Mod_PreloadLevelPaks(s_svLevelName.c_str());
             s_bLevelResourceInitialized = true;
         }
-        *(_DWORD*)v15 = g_pakLoadApi->LoadAsync(v17, g_pAlignedMemAlloc, 4, 0);
+        *(_DWORD*)v15 = g_pakLoadApi->LoadAsync(v17, AlignedMemAlloc(), 4, 0);
 
         if (strcmp(v17, "common_mp.rpak") == 0 || strcmp(v17, "common_sp.rpak") == 0 || strcmp(v17, "common_pve.rpak") == 0)
-            g_pakLoadApi->LoadAsync("common_sdk.rpak", g_pAlignedMemAlloc, 4, 0);
+            g_pakLoadApi->LoadAsync("common_sdk.rpak", AlignedMemAlloc(), 4, 0);
 #ifndef DEDICATED
         if (strcmp(v17, "ui_mp.rpak") == 0)
-            g_pakLoadApi->LoadAsync("ui_sdk.rpak", g_pAlignedMemAlloc, 4, 0);
+            g_pakLoadApi->LoadAsync("ui_sdk.rpak", AlignedMemAlloc(), 4, 0);
 #endif // !DEDICATED
 
     LABEL_37:
@@ -429,7 +429,7 @@ void Mod_PreloadLevelPaks(const char* pszLevelName)
             continue;
 
         snprintf(szPathBuffer, sizeof(szPathBuffer), "%s.rpak", pSubKey->GetName());
-        RPakHandle_t nPakId = g_pakLoadApi->LoadAsync(szPathBuffer, g_pAlignedMemAlloc, 4, 0);
+        RPakHandle_t nPakId = g_pakLoadApi->LoadAsync(szPathBuffer, AlignedMemAlloc(), 4, 0);
 
         if (nPakId == INVALID_PAK_HANDLE)
             Error(eDLL_T::ENGINE, NO_ERROR, "%s: unable to load pak '%s' results '%d'\n", __FUNCTION__, szPathBuffer, nPakId);

r5dev/mathlib/color_conversion.cpp

@@ -101,21 +101,20 @@ ALIGN128 float	power2_n[256] = 			// 2**(index - 128) / 255
 // You can use this to double check the exponent table and assert that 
 // the precomputation is correct.
 #ifdef DBGFLAG_ASSERT
-#pragma warning(push)
-#pragma warning( disable : 4189 ) // disable unused local variable warning
-static void CheckExponentTable()
+void CheckExponentTable()
 {
 	for (int i = 0; i < 256; i++)
 	{
 		float testAgainst = float(pow(2.0f, i - 128)) / 255.0f;
 		float diff = testAgainst - power2_n[i];
 		float relativeDiff = diff / testAgainst;
+
+		NOTE_UNUSED(relativeDiff); // This is to suppress the 'unused local variable' warning.
 		Assert(testAgainst == 0 ?
 			power2_n[i] < 1.16E-041 :
 			power2_n[i] == testAgainst);
 	}
 }
-#pragma warning(pop)
 #endif
 
 void BuildGammaTable(float gamma, float texGamma, float brightness, int overbright)

r5dev/public/tier0/tslist.h

@@ -1,14 +1,29 @@
 #ifndef TSLIST_H
 #define TSLIST_H
 
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
 class CAlignedMemAlloc
 {
 public:
-	virtual void* Alloc(size_t nSize) = 0;
-	virtual void Free(void* pMem) = 0;
+	void* Alloc(size_t nSize, size_t nAlignment = 0);
+	void Free(void* pMem);
+
+private:
+	void* m_pAllocCallback;
+	void* m_pFreeCallback;
 };
 
-inline CAlignedMemAlloc* g_pAlignedMemAlloc;
+extern CAlignedMemAlloc* g_pAlignedMemAlloc;
+
+//-----------------------------------------------------------------------------
+// Singleton aligned memalloc
+//-----------------------------------------------------------------------------
+inline CAlignedMemAlloc* AlignedMemAlloc()
+{
+	return g_pAlignedMemAlloc;
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 class VTSListBase : public IDetour

r5dev/rtech/rtech_game.h

@@ -39,7 +39,7 @@ inline CMemory p_CPakFile_OpenFileOffset; // Offset to inlined 'CPakFile::LoadPa
 class CPakFile
 {
 public:
-	static RPakHandle_t LoadAsync(const char* szPakFileName, CAlignedMemAlloc* pMalloc = g_pAlignedMemAlloc, int nIdx = NULL, bool bUnk = false);
+	static RPakHandle_t LoadAsync(const char* szPakFileName, CAlignedMemAlloc* pMalloc = AlignedMemAlloc(), int nIdx = NULL, bool bUnk = false);
 	static void UnloadPak(RPakHandle_t handle);
 };
 

r5dev/tier0/tslist.cpp

@@ -0,0 +1,28 @@
+//=============================================================================//
+//
+// Purpose:
+//
+//=============================================================================//
+#include "tier0/tslist.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: alloc aligned memory
+// Input  : nSize - 
+//			nPad -
+// Output : pointer to allocated aligned memory
+//-----------------------------------------------------------------------------
+void* CAlignedMemAlloc::Alloc(size_t nSize, size_t nAlignment)
+{
+	return ((void* (*)(size_t, size_t))m_pAllocCallback)(nSize, nAlignment);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: free aligned memory
+// Input  : pMem - 
+//-----------------------------------------------------------------------------
+void CAlignedMemAlloc::Free(void* pMem)
+{
+	((void (*)(void*))m_pFreeCallback)(pMem);
+}
+
+CAlignedMemAlloc* g_pAlignedMemAlloc;

r5dev/vscript/languages/squirrel_re/vsquirrel.cpp

@@ -191,8 +191,8 @@ void CSquirrelVM::CompileModScripts()
 
 		if (rson)
 		{
-			RSON_Free(rson, g_pAlignedMemAlloc);
-			//g_pAlignedMemAlloc->Free(rson); // TODO: fix g_pAlignedMemAlloc and free this properly
+			RSON_Free(rson, AlignedMemAlloc());
+			AlignedMemAlloc()->Free(rson);
 		}
 	}
 }

r5dev/vstdlib/random.cpp

@@ -81,15 +81,15 @@ CUniformRandomStream::CUniformRandomStream()
 
 void CUniformRandomStream::SetSeed(int iSeed)
 {
-	m_mutex.lock();
+	std::lock_guard<std::mutex> l(m_mutex);
+
 	m_idum = ((iSeed < 0) ? iSeed : -iSeed);
 	m_iy = 0;
-	m_mutex.unlock();
 }
 
 int CUniformRandomStream::GenerateRandomNumber()
 {
-	m_mutex.lock();
+	std::lock_guard<std::mutex> l(m_mutex);
 	int j;
 	int k;
 
@@ -130,7 +130,6 @@ int CUniformRandomStream::GenerateRandomNumber()
 	m_iy = m_iv[j];
 	m_iv[j] = m_idum;
 
-	m_mutex.unlock();
 	return m_iy;
 }
 
@@ -207,10 +206,10 @@ CGaussianRandomStream::CGaussianRandomStream(IUniformRandomStream* pUniformStrea
 //-----------------------------------------------------------------------------
 void CGaussianRandomStream::AttachToStream(IUniformRandomStream* pUniformStream)
 {
-	m_mutex.lock();
+	std::lock_guard<std::mutex> l(m_mutex);
+
 	m_pUniformStream = pUniformStream;
 	m_bHaveValue = false;
-	m_mutex.unlock();
 }
 
 
@@ -219,7 +218,8 @@ void CGaussianRandomStream::AttachToStream(IUniformRandomStream* pUniformStream)
 //-----------------------------------------------------------------------------
 float CGaussianRandomStream::RandomFloat(float flMean, float flStdDev)
 {
-	m_mutex.lock();
+	std::lock_guard<std::mutex> l(m_mutex);
+
 	IUniformRandomStream* pUniformStream = m_pUniformStream ? m_pUniformStream : s_pUniformStream;
 	float fac, rsq, v1, v2;
 
@@ -241,17 +241,13 @@ float CGaussianRandomStream::RandomFloat(float flMean, float flStdDev)
 		m_flRandomValue = v1 * fac;
 		m_bHaveValue = true;
 
-		m_mutex.unlock();
 		return flStdDev * (v2 * fac) + flMean;
 	}
 	else
 	{
 		m_bHaveValue = false;
-
-		m_mutex.unlock();
 		return flStdDev * m_flRandomValue + flMean;
 	}
-	m_mutex.unlock();
 }