[MetalMathEngine] Fix compilation

favorart · favorart · commit bf1258f3cb29 · 2024-07-24T21:12:09.000+02:00
Signed-off-by: Kirill Golikov &lt;kirill.golikov@abbyy.com&gt;
diff --git a/NeoMathEngine/CMakeLists.txt b/NeoMathEngine/CMakeLists.txt
@@ -32,7 +32,7 @@ option(NeoMathEngine_BUILD_SHARED "Build NeoMathEngine as shared library." ON)
 option(NeoMathEngine_ENABLE_VULKAN "Enable to build vulkan backend" ON)
 
 # Enable to build metal backend
-option(NeoMathEngine_ENABLE_METAL "Enable to build metal backend" OFF)
+option(NeoMathEngine_ENABLE_METAL "Enable to build metal backend" ON)
 
 # Install NeoMathEngine
 if(DEFINED NeoML_INSTALL)
diff --git a/NeoMathEngine/src/GPU/Metal/MetalMathEngine.h b/NeoMathEngine/src/GPU/Metal/MetalMathEngine.h
diff --git a/NeoMathEngine/src/GPU/Metal/MetalMathEngine.mm b/NeoMathEngine/src/GPU/Metal/MetalMathEngine.mm
@@ -64,19 +64,12 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )
 
 //----------------------------------------------------------------------------------------------------------------------------
 
-// Not using STL in headers
-class CMutex : public std::mutex {
-};
-
-//----------------------------------------------------------------------------------------------------------------------------
-
 const int MetalMemoryAlignment = 16;
 
 CMetalMathEngine::CMetalMathEngine( size_t memoryLimit ) :
 	queue( new CMetalCommandQueue() ),
 	memoryPool( new CMemoryPool( MIN( memoryLimit == 0 ? SIZE_MAX : memoryLimit, defineMemoryLimit() ), this, false ) ),
-	deviceStackAllocator( new CDeviceStackAllocator( *memoryPool, MetalMemoryAlignment ) ),
-	mutex( new CMutex() )
+	deviceStackAllocator( new CDeviceStackAllocator( *memoryPool, MetalMemoryAlignment ) )
 {
 	ASSERT_EXPR( queue->Create() );
 }
@@ -87,31 +80,31 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )
 
 void CMetalMathEngine::SetReuseMemoryMode( bool enable )
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	memoryPool->SetReuseMemoryMode( enable );
 }
 
 bool CMetalMathEngine::GetReuseMemoryMode() const
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	return memoryPool->GetReuseMemoryMode();
 }
 
 void CMetalMathEngine::SetThreadBufferMemoryThreshold( size_t threshold )
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	memoryPool->SetThreadBufferMemoryThreshold( threshold );
 }
 
 size_t CMetalMathEngine::GetThreadBufferMemoryThreshold() const
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	return memoryPool->GetThreadBufferMemoryThreshold();
 }
 
 CMemoryHandle CMetalMathEngine::HeapAlloc( size_t size )
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	CMemoryHandle result = memoryPool->Alloc( size );
 	if( result.IsNull() ) {
 		THROW_MEMORY_EXCEPTION;
@@ -124,13 +117,13 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )
 {
 	ASSERT_EXPR( handle.GetMathEngine() == this );
 
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	return memoryPool->Free( handle );
 }
 
 CMemoryHandle CMetalMathEngine::StackAlloc( size_t size )
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	CMemoryHandle result = deviceStackAllocator->Alloc( size );
 	if( result.IsNull() ) {
 		THROW_MEMORY_EXCEPTION;
@@ -140,43 +133,43 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )
 
 void CMetalMathEngine::StackFree( const CMemoryHandle& ptr )
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	deviceStackAllocator->Free( ptr );
 }
 
 size_t CMetalMathEngine::GetFreeMemorySize() const
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	return memoryPool->GetFreeMemorySize();
 }
 
 size_t CMetalMathEngine::GetPeakMemoryUsage() const
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	return memoryPool->GetPeakMemoryUsage();
 }
 
 void CMetalMathEngine::ResetPeakMemoryUsage()
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	memoryPool->ResetPeakMemoryUsage();
 }
 
 size_t CMetalMathEngine::GetCurrentMemoryUsage() const
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	return memoryPool->GetCurrentMemoryUsage();
 }
 
 size_t CMetalMathEngine::GetMemoryInPools() const
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	return memoryPool->GetMemoryInPools();
 }
 
 void CMetalMathEngine::CleanUp()
 {
-	std::lock_guard<CMutex> lock( *mutex );
+	std::lock_guard<std::mutex> lock( mutex );
 	deviceStackAllocator->CleanUp();
 	memoryPool->CleanUp();
 }
diff --git a/NeoMathEngine/src/GPU/Metal/MetalMathEngineBlas.mm b/NeoMathEngine/src/GPU/Metal/MetalMathEngineBlas.mm
@@ -1,4 +1,4 @@
-/* Copyright © 2017-2023 ABBYY
+/* Copyright © 2017-2024 ABBYY
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -198,13 +198,15 @@ C2DKernel kernel( *queue, "matrixKernelBatchVectorChannelCopyFloatIndicesFloatDa
 }
 
 void CMetalMathEngine::VectorMultichannelLookupAndAddToTable(int batchSize, int channelCount, const CConstFloatHandle& inputHandle,
-    const CFloatHandle* lookupHandles, const CLookupDimension* lookupDimensions, int lookupCount, const CConstFloatHandle& multHandle,
+    const CFloatHandle* lookupHandles, const CLookupDimension* lookupDimensions, int lookupCount, CFloatParam mult,
     const CConstFloatHandle& matrixHandle, int outputChannelsCount)
 {
     ASSERT_EXPR( inputHandle.GetMathEngine() == this );
-	ASSERT_EXPR( multHandle.GetMathEngine() == this );
 	ASSERT_EXPR( matrixHandle.GetMathEngine() == this );
 
+    CFloatHandleStackVar multHandle( *this );
+    multHandle.SetValue( mult );
+
     int outputChannel = 0;
     for( int i = 0; i < lookupCount; ++i ) {
         C2DKernel kernel( *queue, "matrixKernelBatchVectorChannelLookupAndAddToTableFloat", 1, 1, lookupDimensions[i].VectorCount, lookupDimensions[i].VectorSize );
@@ -226,13 +228,15 @@ C2DKernel kernel( *queue, "matrixKernelBatchVectorChannelCopyFloatIndicesFloatDa
 }
 
 void CMetalMathEngine::VectorMultichannelLookupAndAddToTable(int batchSize, int channelCount, const CConstIntHandle& inputHandle,
-    const CFloatHandle* lookupHandles, const CLookupDimension* lookupDimensions, int lookupCount, const CConstFloatHandle& multHandle,
+    const CFloatHandle* lookupHandles, const CLookupDimension* lookupDimensions, int lookupCount, CFloatParam mult,
     const CConstFloatHandle& matrixHandle, int outputChannelsCount)
 {
     ASSERT_EXPR( inputHandle.GetMathEngine() == this );
-	ASSERT_EXPR( multHandle.GetMathEngine() == this );
 	ASSERT_EXPR( matrixHandle.GetMathEngine() == this );
 
+    CFloatHandleStackVar multHandle( *this );
+    multHandle.SetValue( mult );
+
     int outputChannel = 0;
     for( int i = 0; i < lookupCount; ++i ) {
         C2DKernel kernel( *queue, "matrixKernelBatchVectorChannelLookupAndAddToTableInt", 1, 1, lookupDimensions[i].VectorCount, lookupDimensions[i].VectorSize );
@@ -369,12 +373,14 @@ C2DKernel kernel( *queue, "matrixKernelBatchVectorChannelCopyFloatIndicesFloatDa
 }
 
 void CMetalMathEngine::VectorMultiplyAndAdd(const CConstFloatHandle& firstHandle, const CConstFloatHandle& secondHandle,
-	const CFloatHandle& resultHandle, int vectorSize, const CConstFloatHandle& multHandle)
+	const CFloatHandle& resultHandle, int vectorSize, CFloatParam mult)
 {
     ASSERT_EXPR( firstHandle.GetMathEngine() == this );
 	ASSERT_EXPR( secondHandle.GetMathEngine() == this );
 	ASSERT_EXPR( resultHandle.GetMathEngine() == this );
-	ASSERT_EXPR( multHandle.GetMathEngine() == this ); 
+
+    CFloatHandleStackVar multHandle( *this );
+    multHandle.SetValue( mult );
 
     C1DKernel kernel( *queue, "vectorKernelVectorMultiplyAndAdd", 1, vectorSize );
     kernel.SetParam( firstHandle, 0 );
@@ -386,12 +392,14 @@ C2DKernel kernel( *queue, "matrixKernelBatchVectorChannelCopyFloatIndicesFloatDa
 }
 
 void CMetalMathEngine::VectorMultiplyAndSub(const CConstFloatHandle& firstHandle, const CConstFloatHandle& secondHandle,
-	const CFloatHandle& resultHandle, int vectorSize, const CConstFloatHandle& multHandle)
+	const CFloatHandle& resultHandle, int vectorSize, CFloatParam mult)
 {
     ASSERT_EXPR( firstHandle.GetMathEngine() == this );
 	ASSERT_EXPR( secondHandle.GetMathEngine() == this );
 	ASSERT_EXPR( resultHandle.GetMathEngine() == this );
-	ASSERT_EXPR( multHandle.GetMathEngine() == this ); 
+
+    CFloatHandleStackVar multHandle( *this );
+    multHandle.SetValue( mult );
 
     C1DKernel kernel( *queue, "vectorKernelVectorMultiplyAndSub", 1, vectorSize );
     kernel.SetParam( firstHandle, 0 );
@@ -950,7 +958,7 @@ C2DKernel kernel( *queue, "matrixKernelMultiplyMatrixByTransposedMatrixThread4x4
 }
 
 void CMetalMathEngine::BatchMultiplyMatrixByDiagMatrix( int batchSize, const CConstFloatHandle& firstHandle, int height,
-	int width, int firstMatrixOffset, const CConstFloatHandle& secondHandle, int secondMatrixOffset,
+	int width, int /*firstMatrixOffset*/, const CConstFloatHandle& secondHandle, int /*secondMatrixOffset*/,
 	const CFloatHandle& resultHandle, int )
 {
     ASSERT_EXPR( firstHandle.GetMathEngine() == this );
diff --git a/NeoMathEngine/src/GPU/Metal/MetalMathEngineDnn.mm b/NeoMathEngine/src/GPU/Metal/MetalMathEngineDnn.mm
@@ -1,4 +1,4 @@
-/* Copyright © 2017-2023 ABBYY
+/* Copyright © 2017-2024 ABBYY
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -690,7 +690,7 @@ C2DKernel kernel( *queue,
 
 void CMetalMathEngine::MobileNetV2Block( const CBlobDesc&, const CBlobDesc&,
 	const CRowwiseOperationDesc&, const CChannelwiseConvolutionDesc&,
-	const CConstFloatHandle&, const CFloatHandle& ) override
+	const CConstFloatHandle&, const CFloatHandle& )
 {
     ASSERT_EXPR( false );
 }
diff --git a/NeoMathEngine/src/GPU/Metal/MetalMathEngineDnnPoolings.mm b/NeoMathEngine/src/GPU/Metal/MetalMathEngineDnnPoolings.mm
@@ -1,4 +1,4 @@
-/* Copyright © 2017-2023 ABBYY
+/* Copyright © 2017-2024 ABBYY
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -39,7 +39,7 @@
 }
 
 void CMetalMathEngine::BlobMaxPooling( const CMaxPoolingDesc& poolingDesc,
-	const CFConstloatHandle& sourceData, const CIntHandle* maxIndicesData, const CFloatHandle& resultData )
+	const CConstFloatHandle& sourceData, const CIntHandle* maxIndicesData, const CFloatHandle& resultData )
 {
 	ASSERT_EXPR( sourceData.GetMathEngine() == this );
 	ASSERT_EXPR( maxIndicesData == 0 );
@@ -219,7 +219,7 @@
 }
 
 void CMetalMathEngine::Blob3dMaxPooling( const C3dMaxPoolingDesc& poolingDesc, const CConstFloatHandle& sourceData,
-	const CConstIntHandle* maxIndicesData, const CFloatHandle& resultData )
+	const CIntHandle* maxIndicesData, const CFloatHandle& resultData )
 {
 	ASSERT_EXPR( sourceData.GetMathEngine() == this );
 	ASSERT_EXPR( maxIndicesData == 0 || maxIndicesData->GetMathEngine() == this );
diff --git a/NeoMathEngine/src/GPU/Metal/MetalMathEngineVectorMath.mm b/NeoMathEngine/src/GPU/Metal/MetalMathEngineVectorMath.mm

Original file line number	Diff line number	Diff line change
`@@ -64,19 +64,12 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )`
`64`	`64`
`65`	`65`	`//----------------------------------------------------------------------------------------------------------------------------`
`66`	`66`
`67`		`-// Not using STL in headers`
`68`		`-class CMutex : public std::mutex {`
`69`		`-};`
`70`		`-`
`71`		`-//----------------------------------------------------------------------------------------------------------------------------`
`72`		`-`
`73`	`67`	`const int MetalMemoryAlignment = 16;`
`74`	`68`
`75`	`69`	`CMetalMathEngine::CMetalMathEngine( size_t memoryLimit ) :`
`76`	`70`	`queue( new CMetalCommandQueue() ),`
`77`	`71`	`memoryPool( new CMemoryPool( MIN( memoryLimit == 0 ? SIZE_MAX : memoryLimit, defineMemoryLimit() ), this, false ) ),`
`78`		`- deviceStackAllocator( new CDeviceStackAllocator( *memoryPool, MetalMemoryAlignment ) ),`
`79`		`- mutex( new CMutex() )`
	`72`	`+ deviceStackAllocator( new CDeviceStackAllocator( *memoryPool, MetalMemoryAlignment ) )`
`80`	`73`	`{`
`81`	`74`	`ASSERT_EXPR( queue->Create() );`
`82`	`75`	`}`
`@@ -87,31 +80,31 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )`
`87`	`80`
`88`	`81`	`void CMetalMathEngine::SetReuseMemoryMode( bool enable )`
`89`	`82`	`{`
`90`		`- std::lock_guard<CMutex> lock( *mutex );`
	`83`	`+ std::lock_guard<std::mutex> lock( mutex );`
`91`	`84`	`memoryPool->SetReuseMemoryMode( enable );`
`92`	`85`	`}`
`93`	`86`
`94`	`87`	`bool CMetalMathEngine::GetReuseMemoryMode() const`
`95`	`88`	`{`
`96`		`- std::lock_guard<CMutex> lock( *mutex );`
	`89`	`+ std::lock_guard<std::mutex> lock( mutex );`
`97`	`90`	`return memoryPool->GetReuseMemoryMode();`
`98`	`91`	`}`
`99`	`92`
`100`	`93`	`void CMetalMathEngine::SetThreadBufferMemoryThreshold( size_t threshold )`
`101`	`94`	`{`
`102`		`- std::lock_guard<CMutex> lock( *mutex );`
	`95`	`+ std::lock_guard<std::mutex> lock( mutex );`
`103`	`96`	`memoryPool->SetThreadBufferMemoryThreshold( threshold );`
`104`	`97`	`}`
`105`	`98`
`106`	`99`	`size_t CMetalMathEngine::GetThreadBufferMemoryThreshold() const`
`107`	`100`	`{`
`108`		`- std::lock_guard<CMutex> lock( *mutex );`
	`101`	`+ std::lock_guard<std::mutex> lock( mutex );`
`109`	`102`	`return memoryPool->GetThreadBufferMemoryThreshold();`
`110`	`103`	`}`
`111`	`104`
`112`	`105`	`CMemoryHandle CMetalMathEngine::HeapAlloc( size_t size )`
`113`	`106`	`{`
`114`		`- std::lock_guard<CMutex> lock( *mutex );`
	`107`	`+ std::lock_guard<std::mutex> lock( mutex );`
`115`	`108`	`CMemoryHandle result = memoryPool->Alloc( size );`
`116`	`109`	`if( result.IsNull() ) {`
`117`	`110`	`THROW_MEMORY_EXCEPTION;`
`@@ -124,13 +117,13 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )`
`124`	`117`	`{`
`125`	`118`	`ASSERT_EXPR( handle.GetMathEngine() == this );`
`126`	`119`
`127`		`- std::lock_guard<CMutex> lock( *mutex );`
	`120`	`+ std::lock_guard<std::mutex> lock( mutex );`
`128`	`121`	`return memoryPool->Free( handle );`
`129`	`122`	`}`
`130`	`123`
`131`	`124`	`CMemoryHandle CMetalMathEngine::StackAlloc( size_t size )`
`132`	`125`	`{`
`133`		`- std::lock_guard<CMutex> lock( *mutex );`
	`126`	`+ std::lock_guard<std::mutex> lock( mutex );`
`134`	`127`	`CMemoryHandle result = deviceStackAllocator->Alloc( size );`
`135`	`128`	`if( result.IsNull() ) {`
`136`	`129`	`THROW_MEMORY_EXCEPTION;`
`@@ -140,43 +133,43 @@ bool LoadMetalEngineInfo( CMathEngineInfo& info )`
`140`	`133`
`141`	`134`	`void CMetalMathEngine::StackFree( const CMemoryHandle& ptr )`
`142`	`135`	`{`
`143`		`- std::lock_guard<CMutex> lock( *mutex );`
	`136`	`+ std::lock_guard<std::mutex> lock( mutex );`
`144`	`137`	`deviceStackAllocator->Free( ptr );`
`145`	`138`	`}`
`146`	`139`
`147`	`140`	`size_t CMetalMathEngine::GetFreeMemorySize() const`
`148`	`141`	`{`
`149`		`- std::lock_guard<CMutex> lock( *mutex );`
	`142`	`+ std::lock_guard<std::mutex> lock( mutex );`
`150`	`143`	`return memoryPool->GetFreeMemorySize();`
`151`	`144`	`}`
`152`	`145`
`153`	`146`	`size_t CMetalMathEngine::GetPeakMemoryUsage() const`
`154`	`147`	`{`
`155`		`- std::lock_guard<CMutex> lock( *mutex );`
	`148`	`+ std::lock_guard<std::mutex> lock( mutex );`
`156`	`149`	`return memoryPool->GetPeakMemoryUsage();`
`157`	`150`	`}`
`158`	`151`
`159`	`152`	`void CMetalMathEngine::ResetPeakMemoryUsage()`
`160`	`153`	`{`
`161`		`- std::lock_guard<CMutex> lock( *mutex );`
	`154`	`+ std::lock_guard<std::mutex> lock( mutex );`
`162`	`155`	`memoryPool->ResetPeakMemoryUsage();`
`163`	`156`	`}`
`164`	`157`
`165`	`158`	`size_t CMetalMathEngine::GetCurrentMemoryUsage() const`
`166`	`159`	`{`
`167`		`- std::lock_guard<CMutex> lock( *mutex );`
	`160`	`+ std::lock_guard<std::mutex> lock( mutex );`
`168`	`161`	`return memoryPool->GetCurrentMemoryUsage();`
`169`	`162`	`}`
`170`	`163`
`171`	`164`	`size_t CMetalMathEngine::GetMemoryInPools() const`
`172`	`165`	`{`
`173`		`- std::lock_guard<CMutex> lock( *mutex );`
	`166`	`+ std::lock_guard<std::mutex> lock( mutex );`
`174`	`167`	`return memoryPool->GetMemoryInPools();`
`175`	`168`	`}`
`176`	`169`
`177`	`170`	`void CMetalMathEngine::CleanUp()`
`178`	`171`	`{`
`179`		`- std::lock_guard<CMutex> lock( *mutex );`
	`172`	`+ std::lock_guard<std::mutex> lock( mutex );`
`180`	`173`	`deviceStackAllocator->CleanUp();`
`181`	`174`	`memoryPool->CleanUp();`
`182`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-/* Copyright © 2017-2023 ABBYY`
	`1`	`+/* Copyright © 2017-2024 ABBYY`
`2`	`2`
`3`	`3`	`Licensed under the Apache License, Version 2.0 (the "License");`
`4`	`4`	`you may not use this file except in compliance with the License.`
`@@ -690,7 +690,7 @@ C2DKernel kernel( *queue,`
`690`	`690`
`691`	`691`	`void CMetalMathEngine::MobileNetV2Block( const CBlobDesc&, const CBlobDesc&,`
`692`	`692`	`const CRowwiseOperationDesc&, const CChannelwiseConvolutionDesc&,`
`693`		`- const CConstFloatHandle&, const CFloatHandle& ) override`
	`693`	`+ const CConstFloatHandle&, const CFloatHandle& )`
`694`	`694`	`{`
`695`	`695`	`ASSERT_EXPR( false );`
`696`	`696`	`}`