diff --git a/src/implementation/core/arrays/CMakeLists.txt b/src/implementation/core/arrays/CMakeLists.txt
index d30452c0f46b8c8dc24fde1d2f3f984ddfeb3f3f..7273c791f3fb155e3eaaa19ff2979efa5282edd0 100755
--- a/src/implementation/core/arrays/CMakeLists.txt
+++ b/src/implementation/core/arrays/CMakeLists.txt
@@ -8,9 +8,7 @@ SET( headers tnlArray_impl.h
tnlSharedArray_impl.h )
SET( CURRENT_DIR ${CMAKE_SOURCE_DIR}/src/implementation/core/arrays )
-set( common_SOURCES
- ${CURRENT_DIR}/tnlArrayOperationsHost_impl.cpp
- ${CURRENT_DIR}/tnlArrayOperationsCuda_impl.cpp
+set( common_SOURCES
${CURRENT_DIR}/tnlSharedArray_impl.cpp
${CURRENT_DIR}/tnlMultiArray_impl.cpp
${CURRENT_DIR}/tnlArray_impl.cpp )
@@ -18,9 +16,14 @@ set( common_SOURCES
IF( BUILD_CUDA )
set( tnl_implementation_core_arrays_CUDA__SOURCES
${common_SOURCES}
+ ${CURRENT_DIR}/tnlArrayOperationsHost_impl.cu
${CURRENT_DIR}/tnlArrayOperationsCuda_impl.cu
${CURRENT_DIR}/tnlArray_impl.cu
PARENT_SCOPE )
+ELSE()
+ set( common_SOURCES
+ ${CURRENT_DIR}/tnlArrayOperationsHost_impl.cpp
+ ${CURRENT_DIR}/tnlArrayOperationsCuda_impl.cpp )
ENDIF()
set( tnl_implementation_core_arrays_SOURCES
diff --git a/src/implementation/core/arrays/tnlArrayOperationsCuda_impl.h b/src/implementation/core/arrays/tnlArrayOperationsCuda_impl.h
index aef5373a423c3787dfee33280eced24e18ae6217..4a89b872177aca5807c9db32780460e57d627edf 100644
--- a/src/implementation/core/arrays/tnlArrayOperationsCuda_impl.h
+++ b/src/implementation/core/arrays/tnlArrayOperationsCuda_impl.h
@@ -18,6 +18,7 @@
#ifndef TNLARRAYOPERATIONSCUDA_IMPL_H_
#define TNLARRAYOPERATIONSCUDA_IMPL_H_
+#include <tnlConfig.h>
#include <core/mfuncs.h>
template< typename Element, typename Index >
diff --git a/src/implementation/core/arrays/tnlArrayOperationsHost_impl.cu b/src/implementation/core/arrays/tnlArrayOperationsHost_impl.cu
new file mode 100644
index 0000000000000000000000000000000000000000..0e5761c85696713786ef1b03deffbd152b1aee6c
--- /dev/null
+++ b/src/implementation/core/arrays/tnlArrayOperationsHost_impl.cu
@@ -0,0 +1,151 @@
+/***************************************************************************
+ tnlArrayOperationsHost_impl.cu - description
+ -------------------
+ begin : Jul 16, 2013
+ copyright : (C) 2013 by Tomas Oberhuber
+ email : tomas.oberhuber@fjfi.cvut.cz
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ ***************************************************************************/
+
+#include <core/arrays/tnlArrayOperations.h>
+
+#ifdef TEMPLATE_EXPLICIT_INSTANTIATION
+
+template bool tnlArrayOperations< tnlHost >::allocateMemory< char, int >( char*& data, const int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< int, int >( int*& data, const int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< long int, int >( long int*& data, const int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< float, int >( float*& data, const int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< double, int >( double*& data, const int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< long double, int >( long double*& data, const int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< char, long int >( char*& data, const long int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< int, long int >( int*& data, const long int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< long int, long int >( long int*& data, const long int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< float, long int >( float*& data, const long int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< double, long int >( double*& data, const long int size );
+template bool tnlArrayOperations< tnlHost >::allocateMemory< long double, long int >( long double*& data, const long int size );
+
+template bool tnlArrayOperations< tnlHost >::freeMemory< char >( char* data );
+template bool tnlArrayOperations< tnlHost >::freeMemory< int >( int* data );
+template bool tnlArrayOperations< tnlHost >::freeMemory< long int >( long int* data );
+template bool tnlArrayOperations< tnlHost >::freeMemory< float >( float* data );
+template bool tnlArrayOperations< tnlHost >::freeMemory< double >( double* data );
+template bool tnlArrayOperations< tnlHost >::freeMemory< long double >( long double* data );
+
+template void tnlArrayOperations< tnlHost >::setMemoryElement< char >( char* data, const char& value );
+template void tnlArrayOperations< tnlHost >::setMemoryElement< int >( int* data, const int& value );
+template void tnlArrayOperations< tnlHost >::setMemoryElement< long int >( long int* data, const long int& value );
+template void tnlArrayOperations< tnlHost >::setMemoryElement< float >( float* data, const float& value );
+template void tnlArrayOperations< tnlHost >::setMemoryElement< double >( double* data, const double& value );
+template void tnlArrayOperations< tnlHost >::setMemoryElement< long double >( long double* data, const long double& value );
+
+template char tnlArrayOperations< tnlHost >::getMemoryElement< char >( char* data );
+template int tnlArrayOperations< tnlHost >::getMemoryElement< int >( int* data );
+template long int tnlArrayOperations< tnlHost >::getMemoryElement< long int >( long int* data );
+template float tnlArrayOperations< tnlHost >::getMemoryElement< float >( float* data );
+template double tnlArrayOperations< tnlHost >::getMemoryElement< double >( double* data );
+template long double tnlArrayOperations< tnlHost >::getMemoryElement< long double >( long double* data );
+
+template char& tnlArrayOperations< tnlHost >::getArrayElementReference< char, int >( char* data, const int i );
+template int& tnlArrayOperations< tnlHost >::getArrayElementReference< int, int >( int* data, const int i );
+template long int& tnlArrayOperations< tnlHost >::getArrayElementReference< long int, int >( long int* data, const int i );
+template float& tnlArrayOperations< tnlHost >::getArrayElementReference< float, int >( float* data, const int i );
+template double& tnlArrayOperations< tnlHost >::getArrayElementReference< double, int >( double* data, const int i );
+template long double& tnlArrayOperations< tnlHost >::getArrayElementReference< long double, int >( long double* data, const int i );
+
+template char& tnlArrayOperations< tnlHost >::getArrayElementReference< char, long int >( char* data, const long int i );
+template int& tnlArrayOperations< tnlHost >::getArrayElementReference< int, long int >( int* data, const long int i );
+template long int& tnlArrayOperations< tnlHost >::getArrayElementReference< long int, long int >( long int* data, const long int i );
+template float& tnlArrayOperations< tnlHost >::getArrayElementReference< float, long int >( float* data, const long int i );
+template double& tnlArrayOperations< tnlHost >::getArrayElementReference< double, long int >( double* data, const long int i );
+template long double& tnlArrayOperations< tnlHost >::getArrayElementReference< long double, long int >( long double* data, const long int i );
+
+template const char& tnlArrayOperations< tnlHost >::getArrayElementReference< char, int >( const char* data, const int i );
+template const int& tnlArrayOperations< tnlHost >::getArrayElementReference< int, int >( const int* data, const int i );
+template const long int& tnlArrayOperations< tnlHost >::getArrayElementReference< long int, int >( const long int* data, const int i );
+template const float& tnlArrayOperations< tnlHost >::getArrayElementReference< float, int >( const float* data, const int i );
+template const double& tnlArrayOperations< tnlHost >::getArrayElementReference< double, int >( const double* data, const int i );
+template const long double& tnlArrayOperations< tnlHost >::getArrayElementReference< long double, int >( const long double* data, const int i );
+
+template const char& tnlArrayOperations< tnlHost >::getArrayElementReference< char, long int >( const char* data, const long int i );
+template const int& tnlArrayOperations< tnlHost >::getArrayElementReference< int, long int >( const int* data, const long int i );
+template const long int& tnlArrayOperations< tnlHost >::getArrayElementReference< long int, long int >( const long int* data, const long int i );
+template const float& tnlArrayOperations< tnlHost >::getArrayElementReference< float, long int >( const float* data, const long int i );
+template const double& tnlArrayOperations< tnlHost >::getArrayElementReference< double, long int >( const double* data, const long int i );
+template const long double& tnlArrayOperations< tnlHost >::getArrayElementReference< long double, long int >( const long double* data, const long int i );
+
+template bool tnlArrayOperations< tnlHost >::copyMemory< char, tnlHost, char, int >( char* destination, const char* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< int, tnlHost, int, int >( int* destination, const int* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long int, tnlHost, long int, int >( long int* destination, const long int* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< float, tnlHost, float, int >( float* destination, const float* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< double, tnlHost, double, int >( double* destination, const double* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long double, tnlHost, long double, int >( long double* destination, const long double* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< char, tnlHost, char, long int >( char* destination, const char* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< int, tnlHost, int, long int >( int* destination, const int* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long int, tnlHost, long int, long int >( long int* destination, const long int* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< float, tnlHost, float, long int >( float* destination, const float* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< double, tnlHost, double, long int >( double* destination, const double* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long double, tnlHost, long double, long int >( long double* destination, const long double* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< char, tnlCuda, char, int >( char* destination, const char* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< int, tnlCuda, int, int >( int* destination, const int* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long int, tnlCuda, long int, int >( long int* destination, const long int* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< float, tnlCuda, float, int >( float* destination, const float* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< double, tnlCuda, double, int >( double* destination, const double* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long double, tnlCuda, long double, int >( long double* destination, const long double* source, const int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< char, tnlCuda, char, long int >( char* destination, const char* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< int, tnlCuda, int, long int >( int* destination, const int* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long int, tnlCuda, long int, long int >( long int* destination, const long int* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< float, tnlCuda, float, long int >( float* destination, const float* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< double, tnlCuda, double, long int >( double* destination, const double* source, const long int size );
+template bool tnlArrayOperations< tnlHost >::copyMemory< long double, tnlCuda, long double, long int >( long double* destination, const long double* source, const long int size );
+
+template bool tnlArrayOperations< tnlHost >::compareMemory< char, tnlHost, char, int >( const char* data1, const char* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< int, tnlHost, int, int >( const int* data1, const int* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long int, tnlHost, long int, int >( const long int* data1, const long int* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< float, tnlHost, float, int >( const float* data1, const float* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< double, tnlHost, double, int >( const double* data1, const double* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long double, tnlHost, long double, int >( const long double* data1, const long double* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< char, tnlHost, char, long int >( const char* data1, const char* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< int, tnlHost, int, long int >( const int* data1, const int* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long int, tnlHost, long int, long int >( const long int* data1, const long int* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< float, tnlHost, float, long int >( const float* data1, const float* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< double, tnlHost, double, long int >( const double* data1, const double* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long double, tnlHost, long double, long int >( const long double* data1, const long double* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< char, tnlCuda, char, int >( const char* data1, const char* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< int, tnlCuda, int, int >( const int* data1, const int* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long int, tnlCuda, long int, int >( const long int* data1, const long int* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< float, tnlCuda, float, int >( const float* data1, const float* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< double, tnlCuda, double, int >( const double* data1, const double* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long double, tnlCuda, long double, int >( const long double* data1, const long double* data2, const int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< char, tnlCuda, char, long int >( const char* data1, const char* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< int, tnlCuda, int, long int >( const int* data1, const int* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long int, tnlCuda, long int, long int >( const long int* data1, const long int* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< float, tnlCuda, float, long int >( const float* data1, const float* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< double, tnlCuda, double, long int >( const double* data1, const double* data2, const long int size );
+template bool tnlArrayOperations< tnlHost >::compareMemory< long double, tnlCuda, long double, long int >( const long double* data1, const long double* data2, const long int size );
+
+template bool tnlArrayOperations< tnlHost >::setMemory< char, int >( char* destination, const char& value, const int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< int, int >( int* destination, const int& value, const int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< long int, int >( long int* destination, const long int& value, const int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< float, int >( float* destination, const float& value, const int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< double, int >( double* destination, const double& value, const int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< long double, int >( long double* destination, const long double& value, const int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< char, long int >( char* destination, const char& value, const long int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< int, long int >( int* destination, const int& value, const long int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< long int, long int >( long int* destination, const long int& value, const long int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< float, long int >( float* destination, const float& value, const long int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< double, long int >( double* destination, const double& value, const long int size );
+template bool tnlArrayOperations< tnlHost >::setMemory< long double, long int >( long double* destination, const long double& value, const long int size );
+
+#endif
+
+
+
+
diff --git a/src/implementation/core/arrays/tnlArrayOperationsHost_impl.h b/src/implementation/core/arrays/tnlArrayOperationsHost_impl.h
index a8a321d94e13919ba9941881652c8138881e66c9..c1a1279fad91fa68a57df18a90ef076d943948be 100644
--- a/src/implementation/core/arrays/tnlArrayOperationsHost_impl.h
+++ b/src/implementation/core/arrays/tnlArrayOperationsHost_impl.h
@@ -17,7 +17,7 @@
#ifndef TNLARRAYOPERATIONSHOST_IMPL_H_
#define TNLARRAYOPERATIONSHOST_IMPL_H_
-
+#include <tnlConfig.h>
#include <core/cuda/device-check.h>
template< typename Element, typename Index >
@@ -85,6 +85,7 @@ bool tnlArrayOperations< tnlHost > :: copyMemory( DestinationElement* destinatio
destination[ i ] = ( DestinationElement) source[ i ];
if( DestinationDevice :: getDevice() == tnlCudaDevice )
{
+
#ifdef HAVE_CUDA
DestinationElement* buffer = new DestinationElement[ tnlCuda::getGPUTransferBufferSize() ];
if( ! buffer )
diff --git a/src/implementation/solvers/linear/krylov/tnlGMRESSolver_impl.h b/src/implementation/solvers/linear/krylov/tnlGMRESSolver_impl.h
index b4549ec136f2cf4504b1e9de6f375dd5d91e948a..81393a8e09d62991146372811656a3f8b523918d 100644
--- a/src/implementation/solvers/linear/krylov/tnlGMRESSolver_impl.h
+++ b/src/implementation/solvers/linear/krylov/tnlGMRESSolver_impl.h
@@ -228,6 +228,7 @@ bool tnlGMRESSolver< Matrix, Preconditioner > :: solve( const Vector& b, Vector&
return true;
}
//DBG_WAIT;
+ this -> refreshSolverMonitor();
if( ! this -> nextIteration() )
return false;
}
@@ -252,6 +253,7 @@ bool tnlGMRESSolver< Matrix, Preconditioner > :: solve( const Vector& b, Vector&
beta = _r. lpNorm( ( RealType ) 2.0 );
}
this -> setResidue( beta / normb );
+ this -> refreshSolverMonitor();
if( ! this -> nextIteration() )
return false;
}
diff --git a/tests/unit-tests/core/cuda/tnlCudaReductionTester.h b/tests/unit-tests/core/cuda/tnlCudaReductionTester.h
index 9ac39964adc3cfff4b32373912401bd36945874d..3fbda6feab66390d8310d42a49c37b74bb584472 100644
--- a/tests/unit-tests/core/cuda/tnlCudaReductionTester.h
+++ b/tests/unit-tests/core/cuda/tnlCudaReductionTester.h
@@ -309,7 +309,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
for( int i = 0; i < size; i ++ )
hostData[ i ] = 1;
- copyMemoryHostToCuda( deviceData, hostData, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData, hostData, size );
CPPUNIT_ASSERT( checkCudaDevice );
tnlParallelReductionLogicalAnd< Type, int > andOperation;
@@ -323,7 +323,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
CPPUNIT_ASSERT( result == 1 );
hostData[ 0 ] = 0;
- copyMemoryHostToCuda( deviceData, hostData, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData, hostData, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
( reductionOnCudaDevice( andOperation, size, deviceData, ( Type* ) 0, result ) ) );
@@ -335,7 +335,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
for( int i = 0; i < size; i ++ )
hostData[ i ] = 0;
- copyMemoryHostToCuda( deviceData, hostData, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData, hostData, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
( reductionOnCudaDevice( andOperation, size, deviceData, ( Type* ) 0, result ) ) );
@@ -350,14 +350,14 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
{
int size( 7628198 );
Type *hostData, *deviceData;
- allocateMemoryHost( hostData, size );
- allocateMemoryCuda( deviceData, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData, size );
CPPUNIT_ASSERT( checkCudaDevice );
for( int i = 0; i < size; i ++ )
hostData[ i ] = 1;
- copyMemoryHostToCuda( deviceData, hostData, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData, hostData, size );
CPPUNIT_ASSERT( checkCudaDevice );
tnlParallelReductionLogicalAnd< Type, int > andOperation;
@@ -371,7 +371,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
CPPUNIT_ASSERT( result == 1 );
hostData[ 0 ] = 0;
- copyMemoryHostToCuda( deviceData, hostData, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData, hostData, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
( reductionOnCudaDevice( andOperation, size, deviceData, ( Type* ) 0, result ) ) );
@@ -383,7 +383,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
for( int i = 0; i < size; i ++ )
hostData[ i ] = 0;
- copyMemoryHostToCuda( deviceData, hostData, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData, hostData, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
( reductionOnCudaDevice( andOperation, size, deviceData, ( Type* ) 0, result ) ) );
@@ -399,16 +399,16 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
const int size( 125 );
Type *hostData1, *hostData2,
*deviceData1, *deviceData2;
- allocateMemoryHost( hostData1, size );
- allocateMemoryHost( hostData2, size );
- allocateMemoryCuda( deviceData1, size );
- allocateMemoryCuda( deviceData2, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData1, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData2, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData1, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
for( int i = 0; i < size; i ++ )
hostData1[ i ] = hostData2[ i ] = 1;
- copyMemoryHostToCuda( deviceData1, hostData1, size );
- copyMemoryHostToCuda( deviceData2, hostData2, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData2, hostData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
bool result( false );
@@ -424,7 +424,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
CPPUNIT_ASSERT( result == false );
hostData1[ 0 ] = 0;
- copyMemoryHostToCuda( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
@@ -437,7 +437,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
for( int i = 0; i < size; i ++ )
hostData1[ i ] = 0;
- copyMemoryHostToCuda( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
@@ -455,16 +455,16 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
const int size( 1258976 );
Type *hostData1, *hostData2,
*deviceData1, *deviceData2;
- allocateMemoryHost( hostData1, size );
- allocateMemoryHost( hostData2, size );
- allocateMemoryCuda( deviceData1, size );
- allocateMemoryCuda( deviceData2, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData1, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData2, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData1, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
for( int i = 0; i < size; i ++ )
hostData1[ i ] = hostData2[ i ] = 1;
- copyMemoryHostToCuda( deviceData1, hostData1, size );
- copyMemoryHostToCuda( deviceData2, hostData2, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData2, hostData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
bool result( false );
@@ -480,7 +480,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
CPPUNIT_ASSERT( result == false );
hostData1[ 0 ] = 0;
- copyMemoryHostToCuda( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
@@ -493,7 +493,7 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
for( int i = 0; i < size; i ++ )
hostData1[ i ] = 0;
- copyMemoryHostToCuda( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
CPPUNIT_ASSERT( checkCudaDevice );
CPPUNIT_ASSERT(
@@ -511,10 +511,10 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
const int size( 125 );
Type *hostData1, *hostData2,
*deviceData1, *deviceData2;
- allocateMemoryHost( hostData1, size );
- allocateMemoryHost( hostData2, size );
- allocateMemoryCuda( deviceData1, size );
- allocateMemoryCuda( deviceData2, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData1, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData2, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData1, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
hostData1[ 0 ] = 0;
@@ -526,8 +526,8 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
hostData2[ i ] = -hostData2[ i - 1 ];
sdot += hostData1[ i ] * hostData2[ i ];
}
- copyMemoryHostToCuda( deviceData1, hostData1, size );
- copyMemoryHostToCuda( deviceData2, hostData2, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData2, hostData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
Type result( 0.0 );
@@ -545,10 +545,10 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
const int size( 125789 );
Type *hostData1, *hostData2,
*deviceData1, *deviceData2;
- allocateMemoryHost( hostData1, size );
- allocateMemoryHost( hostData2, size );
- allocateMemoryCuda( deviceData1, size );
- allocateMemoryCuda( deviceData2, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData1, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostData2, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData1, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
hostData1[ 0 ] = 0;
@@ -560,8 +560,8 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
hostData2[ i ] = -hostData2[ i - 1 ];
sdot += hostData1[ i ] * hostData2[ i ];
}
- copyMemoryHostToCuda( deviceData1, hostData1, size );
- copyMemoryHostToCuda( deviceData2, hostData2, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData1, hostData1, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceData2, hostData2, size );
CPPUNIT_ASSERT( checkCudaDevice );
Type result( 0.0 );
@@ -578,12 +578,12 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
const int size( 123 );
Type *hostZeros, *hostOnes, *hostLinear,
*deviceZeros, *deviceOnes, *deviceLinear;
- allocateMemoryHost( hostZeros, size );
- allocateMemoryHost( hostOnes, size );
- allocateMemoryHost( hostLinear, size );
- allocateMemoryCuda( deviceZeros, size );
- allocateMemoryCuda( deviceOnes, size );
- allocateMemoryCuda( deviceLinear, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostZeros, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostOnes, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostLinear, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceZeros, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceOnes, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceLinear, size );
CPPUNIT_ASSERT( checkCudaDevice );
for( int i = 0; i < size; i ++ )
@@ -593,9 +593,9 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
hostLinear[ i ] = i;
}
- copyMemoryHostToCuda( deviceZeros, hostZeros, size );
- copyMemoryHostToCuda( deviceOnes, hostOnes, size );
- copyMemoryHostToCuda( deviceLinear, hostLinear, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceZeros, hostZeros, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceOnes, hostOnes, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceLinear, hostLinear, size );
CPPUNIT_ASSERT( checkCudaDevice );
tnlParallelReductionDiffSum< Type, int > diffSumOp;
@@ -680,12 +680,12 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
( reductionOnCudaDevice( diffAbsMaxOp, size, deviceZeros, deviceLinear, result ) ) );
CPPUNIT_ASSERT( result == size - 1 );
- freeMemoryHost( hostZeros );
- freeMemoryHost( hostOnes );
- freeMemoryHost( hostLinear );
- freeMemoryCuda( deviceZeros );
- freeMemoryCuda( deviceOnes );
- freeMemoryCuda( deviceLinear );
+ tnlArrayOperations< tnlHost >::freeMemory( hostZeros );
+ tnlArrayOperations< tnlHost >::freeMemory( hostOnes );
+ tnlArrayOperations< tnlHost >::freeMemory( hostLinear );
+ tnlArrayOperations< tnlCuda >::freeMemory( deviceZeros );
+ tnlArrayOperations< tnlCuda >::freeMemory( deviceOnes );
+ tnlArrayOperations< tnlCuda >::freeMemory( deviceLinear );
}
@@ -695,12 +695,12 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
const int size( 12387 );
Type *hostZeros, *hostOnes, *hostLinear,
*deviceZeros, *deviceOnes, *deviceLinear;
- allocateMemoryHost( hostZeros, size );
- allocateMemoryHost( hostOnes, size );
- allocateMemoryHost( hostLinear, size );
- allocateMemoryCuda( deviceZeros, size );
- allocateMemoryCuda( deviceOnes, size );
- allocateMemoryCuda( deviceLinear, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostZeros, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostOnes, size );
+ tnlArrayOperations< tnlHost >::allocateMemory( hostLinear, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceZeros, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceOnes, size );
+ tnlArrayOperations< tnlCuda >::allocateMemory( deviceLinear, size );
CPPUNIT_ASSERT( checkCudaDevice );
for( int i = 0; i < size; i ++ )
@@ -710,9 +710,9 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
hostLinear[ i ] = i;
}
- copyMemoryHostToCuda( deviceZeros, hostZeros, size );
- copyMemoryHostToCuda( deviceOnes, hostOnes, size );
- copyMemoryHostToCuda( deviceLinear, hostLinear, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceZeros, hostZeros, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceOnes, hostOnes, size );
+ tnlArrayOperations< tnlHost >::copyMemory< Type, tnlCuda, Type, int >( deviceLinear, hostLinear, size );
CPPUNIT_ASSERT( checkCudaDevice );
tnlParallelReductionDiffSum< Type, int > diffSumOp;
@@ -798,12 +798,12 @@ class tnlCudaReductionTester : public CppUnit :: TestCase
( reductionOnCudaDevice( diffAbsMaxOp, size, deviceZeros, deviceLinear, result ) ) );
CPPUNIT_ASSERT( result == size - 1 );
- freeMemoryHost( hostZeros );
- freeMemoryHost( hostOnes );
- freeMemoryHost( hostLinear );
- freeMemoryCuda( deviceZeros );
- freeMemoryCuda( deviceOnes );
- freeMemoryCuda( deviceLinear );
+ tnlArrayOperations< tnlHost >::freeMemory( hostZeros );
+ tnlArrayOperations< tnlHost >::freeMemory( hostOnes );
+ tnlArrayOperations< tnlHost >::freeMemory( hostLinear );
+ tnlArrayOperations< tnlCuda >::freeMemory( deviceZeros );
+ tnlArrayOperations< tnlCuda >::freeMemory( deviceOnes );
+ tnlArrayOperations< tnlCuda >::freeMemory( deviceLinear );
}
};