Commit b226f877 authored by Tomáš Oberhuber's avatar Tomáš Oberhuber
Browse files

Refactoring the array operations.

parent 3889eb07

src/implementation/core/arrays/CMakeLists.txt

+6 −3
Original line number Diff line number Diff line
@@ -9,8 +9,6 @@ SET( headers tnlArray_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

     ${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

src/implementation/core/arrays/tnlArrayOperationsCuda_impl.h

+1 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#ifndef TNLARRAYOPERATIONSCUDA_IMPL_H_

#define TNLARRAYOPERATIONSCUDA_IMPL_H_



#include <tnlConfig.h>

#include <core/mfuncs.h>



template< typename Element, typename Index >

src/implementation/core/arrays/tnlArrayOperationsHost_impl.cu

0 → 100644
+151 −0
Original line number Diff line number Diff line 
/***************************************************************************

                          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

src/implementation/core/arrays/tnlArrayOperationsHost_impl.h

+2 −1
Original line number Diff line number Diff line
@@ -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 )

src/implementation/solvers/linear/krylov/tnlGMRESSolver_impl.h

+2 −0
Original line number Diff line number Diff line
@@ -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;

   }