Fixed a couple of instances where custom memory allocators were not used in main code and FrameRecorder, as well as separating playback helper code from recording.

Author: fstrugar

CullingThreadpool.cpp

@@ -432,7 +432,7 @@ void CullingThreadpool::ClearBuffer()
 
 void CullingThreadpool::RenderTriangles(const float *inVtx, const unsigned int *inTris, int nTris, BackfaceWinding bfWinding, ClipPlanes clipPlaneMask)
 {
-#if ENABLE_RECORDER != 0
+#if MOC_RECORDER_ENABLE != 0
     mMOC->RecordRenderTriangles( inVtx, inTris, nTris, mCurrentMatrix, clipPlaneMask, bfWinding, *mVertexLayouts.GetData( ) );
 #endif
 

FillrateTest/FillrateTest.cpp

@@ -378,7 +378,7 @@ int main(int argc, char* argv[])
 
     };
 
-#if 0 && ENABLE_RECORDER
+#if 0 && MOC_RECORDER_ENABLE
     moc->RecorderStart( "..\\FrameRecorderPlayer\\FillrateTest.mocrec" );
 #endif
 
@@ -393,7 +393,7 @@ int main(int argc, char* argv[])
 		printf("Tri: %3dx%3d - Time: %7.2f ms, MTris/s: %6.2f GPixels/s: %5.2f \n", size, size, t * 1000.0f, MTrisPerSecond, GPixelsPerSecond);
 	}
 
-#if 0 && ENABLE_RECORDER
+#if 0 && MOC_RECORDER_ENABLE
     moc->RecorderStop( );
 #endif
 

FillrateTest/FillrateTest.vcxproj

@@ -86,7 +86,7 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>ENABLE_RECORDER=0;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>MOC_RECORDER_ENABLE=0;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <OpenMPSupport>false</OpenMPSupport>
     </ClCompile>
     <Link>

FrameRecorder.cpp

@@ -15,7 +15,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 #include "FrameRecorder.h"
 
-#if ENABLE_RECORDER
+#if MOC_RECORDER_ENABLE
 #include <assert.h>
 #include <algorithm>
 
@@ -35,21 +35,27 @@ bool MaskedOcclusionCulling::RecorderStart( const char * outputFilePath ) const
     FILE * f;
     if( fopen_s( &f, outputFilePath, "wb" ) != 0 )
         return false;
-    mRecorder = new FrameRecorder( f, *this );
 #else
     std::ofstream outStream( outputFilePath, std::ios::out | std::ios::trunc | std::ios::binary );
     if( !outStream.is_open( ) )
         return false;
-    mRecorder = new FrameRecorder( std::move( outStream ), *this );
 #endif
+    mRecorder = (FrameRecorder *)mAlignedAllocCallback( 64, sizeof( FrameRecorder ) );
+#if MOC_RECORDER_USE_STDIO_FILE
+    new (mRecorder) FrameRecorder( f, *this );
+#else
+    new (mRecorder) FrameRecorder( std::move( outStream ), *this );
+#endif
+
     return true;
 }
 
 void MaskedOcclusionCulling::RecorderStop( ) const
 {
     std::lock_guard<std::mutex> lock( mRecorderMutex );
 
-    delete mRecorder;
+    mRecorder->~FrameRecorder();
+    mAlignedFreeCallback( mRecorder );
     mRecorder = nullptr;
 }
 
@@ -204,6 +210,47 @@ namespace
     };
 }
 
+void FrameRecorder::RecordClearBuffer( )
+{
+    char header = 3;
+    Write( &header, 1 );
+}
+
+void FrameRecorder::RecordRenderTriangles( MaskedOcclusionCulling::CullingResult cullingResult, const float *inVtx, const unsigned int *inTris, int nTris, const float *modelToClipMatrix, MaskedOcclusionCulling::ClipPlanes clipPlaneMask, MaskedOcclusionCulling::BackfaceWinding bfWinding, const MaskedOcclusionCulling::VertexLayout & vtxLayout )
+{
+    char header = 0;
+    Write( &header, 1 );
+    WriteTriangleRecording( cullingResult, inVtx, inTris, nTris, modelToClipMatrix, clipPlaneMask, bfWinding, vtxLayout );
+}
+
+void FrameRecorder::RecordTestRect( MaskedOcclusionCulling::CullingResult cullingResult, float xmin, float ymin, float xmax, float ymax, float wmin )
+{
+    char header = 1;
+    Write( &header, 1 );
+
+    Write( &cullingResult, sizeof( cullingResult ) );
+    Write( &xmin, sizeof( xmin ) );
+    Write( &ymin, sizeof( ymin ) );
+    Write( &xmax, sizeof( xmax ) );
+    Write( &ymax, sizeof( ymax ) );
+    Write( &wmin, sizeof( wmin ) );
+}
+
+void FrameRecorder::RecordTestTriangles( MaskedOcclusionCulling::CullingResult cullingResult, const float *inVtx, const unsigned int *inTris, int nTris, const float *modelToClipMatrix, MaskedOcclusionCulling::ClipPlanes clipPlaneMask, MaskedOcclusionCulling::BackfaceWinding bfWinding, const MaskedOcclusionCulling::VertexLayout & vtxLayout )
+{
+    char header = 2;
+    Write( &header, 1 );
+    WriteTriangleRecording( cullingResult, inVtx, inTris, nTris, modelToClipMatrix, clipPlaneMask, bfWinding, vtxLayout );
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Masked occlusion culling recording
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+#if MOC_RECORDER_ENABLE_PLAYBACK
+
 static bool ReadTriangleRecording( FrameRecording::TrianglesEntry & outEntry, InStreamWrapper & inStream )
 {
     // read culling result
@@ -240,7 +287,7 @@ static bool ReadTriangleRecording( FrameRecording::TrianglesEntry & outEntry, In
 
     // read vertices
     outEntry.mVertices.resize( vertexSize / 4 * vertexCount );  // pre-allocate data
-    if( inStream.Read( (char*) outEntry.mVertices.data(), vertexSize * vertexCount ) != (vertexSize * vertexCount) )
+    if( inStream.Read( (char*)outEntry.mVertices.data( ), vertexSize * vertexCount ) != ( vertexSize * vertexCount ) )
     {
         assert( false );
         return false;
@@ -269,7 +316,7 @@ static bool ReadTriangleRecording( FrameRecording::TrianglesEntry & outEntry, In
         return false;
     }
 
-    if( (outEntry.mHasModelToClipMatrix = (hasMatrix != 0)) )
+    if( ( outEntry.mHasModelToClipMatrix = ( hasMatrix != 0 ) ) )
     {
         if( inStream.Read( (char*)outEntry.mModelToClipMatrix, 16 * sizeof( float ) ) != 16 * sizeof( float ) )
         {
@@ -309,44 +356,6 @@ static bool ReadTriangleRecording( FrameRecording::TrianglesEntry & outEntry, In
     return true;
 }
 
-void FrameRecorder::RecordClearBuffer( )
-{
-    char header = 3;
-    Write( &header, 1 );
-}
-
-void FrameRecorder::RecordRenderTriangles( MaskedOcclusionCulling::CullingResult cullingResult, const float *inVtx, const unsigned int *inTris, int nTris, const float *modelToClipMatrix, MaskedOcclusionCulling::ClipPlanes clipPlaneMask, MaskedOcclusionCulling::BackfaceWinding bfWinding, const MaskedOcclusionCulling::VertexLayout & vtxLayout )
-{
-    char header = 0;
-    Write( &header, 1 );
-    WriteTriangleRecording( cullingResult, inVtx, inTris, nTris, modelToClipMatrix, clipPlaneMask, bfWinding, vtxLayout );
-}
-
-void FrameRecorder::RecordTestRect( MaskedOcclusionCulling::CullingResult cullingResult, float xmin, float ymin, float xmax, float ymax, float wmin )
-{
-    char header = 1;
-    Write( &header, 1 );
-
-    Write( &cullingResult, sizeof( cullingResult ) );
-    Write( &xmin, sizeof( xmin ) );
-    Write( &ymin, sizeof( ymin ) );
-    Write( &xmax, sizeof( xmax ) );
-    Write( &ymax, sizeof( ymax ) );
-    Write( &wmin, sizeof( wmin ) );
-}
-
-void FrameRecorder::RecordTestTriangles( MaskedOcclusionCulling::CullingResult cullingResult, const float *inVtx, const unsigned int *inTris, int nTris, const float *modelToClipMatrix, MaskedOcclusionCulling::ClipPlanes clipPlaneMask, MaskedOcclusionCulling::BackfaceWinding bfWinding, const MaskedOcclusionCulling::VertexLayout & vtxLayout )
-{
-    char header = 2;
-    Write( &header, 1 );
-    WriteTriangleRecording( cullingResult, inVtx, inTris, nTris, modelToClipMatrix, clipPlaneMask, bfWinding, vtxLayout );
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Masked occlusion culling recording
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 bool FrameRecording::Load( const char * inputFilePath, FrameRecording & outRecording )
 {
     outRecording.Reset();
@@ -438,4 +447,6 @@ bool FrameRecording::Load( const char * inputFilePath, FrameRecording & outRecor
     return true;
 }
 
-#endif // #if ENABLE_RECORDER
+#endif // #if MOC_RECORDER_ENABLE_PLAYBACK
+
+#endif // #if MOC_RECORDER_ENABLE

FrameRecorder.h

@@ -17,9 +17,9 @@
 
  /*!
   * \file FrameRecorder.h
-  * \brief Masked occlusion culling recorder class (set ENABLE_RECORDER to 1 to enable)
+  * \brief Masked occlusion culling recorder class (set MOC_RECORDER_ENABLE to 1 to enable)
   *
-  * Masked occlusion culling recorder class (To enable, set ENABLE_RECORDER to 1 in MaskedOcclusionCulling.h)
+  * Masked occlusion culling recorder class (To enable, set MOC_RECORDER_ENABLE to 1 in MaskedOcclusionCulling.h)
   *
   * Enables gathering and storing all triangle rendering and all testing calls and their results to a file, for
   * later playback and performance testing.
@@ -42,10 +42,17 @@
 /*!
  * Whether to use FILE or std::ofstream/istream for file access (to avoid compatibility issues in some environments)
  */
-#define MOC_RECORDER_USE_STDIO_FILE          0
+#define MOC_RECORDER_USE_STDIO_FILE         1
 #endif
 
-#if ENABLE_RECORDER
+#if MOC_RECORDER_ENABLE
+
+#ifndef MOC_RECORDER_ENABLE_PLAYBACK
+/*!
+ * Whether to enable compilation of the playback code (not needed for recording only)
+ */
+#define MOC_RECORDER_ENABLE_PLAYBACK        0
+#endif
 
 #if MOC_RECORDER_USE_STDIO_FILE
 #include <stdio.h>
@@ -54,7 +61,6 @@
 #endif
 
 #include <mutex>
-#include <vector>
 
 class FrameRecorder
 {
@@ -86,6 +92,36 @@ class FrameRecorder
 	void RecordTestTriangles( MaskedOcclusionCulling::CullingResult cullingResult, const float *inVtx, const unsigned int *inTris, int nTris, const float *modelToClipMatrix, MaskedOcclusionCulling::ClipPlanes clipPlaneMask, MaskedOcclusionCulling::BackfaceWinding bfWinding, const MaskedOcclusionCulling::VertexLayout &vtxLayout );
 };
 
+#if MOC_RECORDER_ENABLE_PLAYBACK
+#include <vector>
+
+#if 0 // For future use - in case all vector uses below need conversion to custom allocator
+template <class T>
+struct MOCVectorAllocator
+{
+    const MaskedOcclusionCulling::pfnAlignedAlloc   m_alloc;
+    const MaskedOcclusionCulling::pfnAlignedFree    m_free;
+    typedef T value_type;
+    MOCVectorAllocator( ) = delete;
+    MOCVectorAllocator( MaskedOcclusionCulling::pfnAlignedAlloc alloc, MaskedOcclusionCulling::pfnAlignedFree free ) noexcept : m_alloc( alloc ), m_free( free ) { }
+    template <class U> constexpr MOCVectorAllocator( const MOCVectorAllocator<U>& c ) noexcept : m_alloc( c.m_alloc ), m_free( c.m_free ) {}
+    T* allocate( std::size_t n )
+    {
+        if( n > std::size_t( -1 ) / sizeof( T ) ) throw std::bad_alloc( );
+        if( auto p = static_cast<T*>( m_alloc( 64, n * sizeof( T ) ) ) ) return p;
+        throw std::bad_alloc( );
+    }
+    void deallocate( T* p, std::size_t ) noexcept
+    {
+        m_free( p );
+    }
+};
+template <class T, class U>
+inline bool operator==( const MOCVectorAllocator<T>&, const MOCVectorAllocator<U>& ) { return true; }
+template <class T, class U>
+inline bool operator!=( const MOCVectorAllocator<T>&, const MOCVectorAllocator<U>& ) { return false; }
+#endif
+
 struct FrameRecording
 {
 	struct TrianglesEntry
@@ -146,4 +182,6 @@ struct FrameRecording
 	static bool Load( const char * inputFilePath, FrameRecording & outRecording );
 };
 
-#endif // #if ENABLE_RECORDER
+#endif // #if MOC_RECORDER_ENABLE_PLAYBACK
+
+#endif // #if MOC_RECORDER_ENABLE

FrameRecorderPlayer/FrameRecorderPlayer.cpp

@@ -30,8 +30,12 @@
 #include "../MaskedOcclusionCulling.h"
 #include "../FrameRecorder.h"
 
-#if !ENABLE_RECORDER
-#error This project needs to be compiled with ENABLE_RECORDER set to 1
+#if !MOC_RECORDER_ENABLE
+#error This project needs to be compiled with MOC_RECORDER_ENABLE set to 1
+#endif
+
+#if !MOC_RECORDER_ENABLE_PLAYBACK
+#error This project needs to be compiled with MOC_RECORDER_ENABLE_PLAYBACK set to 1
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////////////

FrameRecorderPlayer/FrameRecorderPlayer.vcxproj

@@ -86,7 +86,7 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>ENABLE_RECORDER=1;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>MOC_RECORDER_ENABLE=1;MOC_RECORDER_ENABLE_PLAYBACK=1;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -99,7 +99,7 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>ENABLE_RECORDER=1;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>MOC_RECORDER_ENABLE=1;MOC_RECORDER_ENABLE_PLAYBACK=1;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalOptions>-msse4.1 %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
@@ -115,7 +115,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>ENABLE_RECORDER=1;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>MOC_RECORDER_ENABLE=1;MOC_RECORDER_ENABLE_PLAYBACK=1;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -132,7 +132,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>ENABLE_RECORDER=1;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>MOC_RECORDER_ENABLE=1;MOC_RECORDER_ENABLE_PLAYBACK=1;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalOptions>-msse4.1 %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>