Commit 322b5b58 authored by Jakub Klinkovský's avatar Jakub Klinkovský
Browse files

Reordering and optimizing tests in VectorTest to improve the compilation time

parent 60bffc04

src/UnitTests/Containers/VectorTest-1.h

+215 −49
Original line number Diff line number Diff line
@@ -13,23 +13,9 @@ 
#pragma once



#ifdef HAVE_GTEST

#include <limits>



#include <TNL/Experimental/Arithmetics/Quad.h>

#include <TNL/Containers/Vector.h>

#include <TNL/Containers/VectorView.h>

#include "VectorTestSetup.h"



#include "gtest/gtest.h"



using namespace TNL;

using namespace TNL::Containers;

using namespace TNL::Containers::Algorithms;

using namespace TNL::Arithmetics;



// should be small enough to have fast tests, but larger than minGPUReductionDataSize

// and large enough to require multiple CUDA blocks for reduction

constexpr int VECTOR_TEST_SIZE = 5000;

constexpr int VECTOR_TEST_SIZE = 100;



TYPED_TEST( VectorTest, constructors )

{
@@ -91,72 +77,231 @@ TYPED_TEST( VectorTest, constructors ) 
   EXPECT_EQ( a3.getElement( 2 ), 9 );

}



TYPED_TEST( VectorTest, max )

TEST( VectorSpecialCasesTest, defaultConstructors )

{

   using ArrayType = Containers::Array< int, Devices::Host >;

   using VectorViewType = VectorView< int, Devices::Host >;

   using ArrayViewType = ArrayView< int, Devices::Host >;



   ArrayType a( 100 );

   a.setValue( 0 );



   ArrayViewType a_view;

   a_view.bind( a );



   VectorViewType v_view;

   v_view.bind( a );

   EXPECT_EQ( v_view.getData(), a_view.getData() );

}



TEST( VectorSpecialCasesTest, assignmentThroughView )

{

   using VectorType = Containers::Vector< int, Devices::Host >;

   using ViewType = VectorView< int, Devices::Host >;



   static_assert( Algorithms::Details::HasSubscriptOperator< VectorType >::value, "Subscript operator detection by SFINAE does not work for Vector." );

   static_assert( Algorithms::Details::HasSubscriptOperator< ViewType >::value, "Subscript operator detection by SFINAE does not work for VectorView." );



   VectorType u( 100 ), v( 100 );

   ViewType u_view( u ), v_view( v );



   u.setValue( 42 );

   v.setValue( 0 );

   v_view = u_view;

   EXPECT_EQ( u_view.getData(), u.getData() );

   EXPECT_EQ( v_view.getData(), v.getData() );

   for( int i = 0; i < 100; i++ )

      EXPECT_EQ( v_view[ i ], 42 );



   u.setValue( 42 );

   v.setValue( 0 );

   v_view = u;

   EXPECT_EQ( u_view.getData(), u.getData() );

   EXPECT_EQ( v_view.getData(), v.getData() );

   for( int i = 0; i < 100; i++ )

      EXPECT_EQ( v_view[ i ], 42 );

}



TEST( VectorSpecialCasesTest, operationsOnConstView )

{

   using VectorType = Containers::Vector< int, Devices::Host >;

   using ViewType = VectorView< const int, Devices::Host >;



   VectorType u( 100 ), v( 100 );

   ViewType u_view( u ), v_view( v );



   u.setValue( 1 );

   v.setValue( 1 );



   EXPECT_EQ( u_view.max(), 1 );

   EXPECT_EQ( u_view.min(), 1 );

   EXPECT_EQ( u_view.absMax(), 1 );

   EXPECT_EQ( u_view.absMin(), 1 );

   EXPECT_EQ( u_view.lpNorm( 1 ), 100 );

   EXPECT_EQ( u_view.differenceMax( v_view ), 0 );

   EXPECT_EQ( u_view.differenceMin( v_view ), 0 );

   EXPECT_EQ( u_view.differenceAbsMax( v_view ), 0 );

   EXPECT_EQ( u_view.differenceAbsMin( v_view ), 0 );

   EXPECT_EQ( u_view.differenceLpNorm( v_view, 1 ), 0 );

   EXPECT_EQ( u_view.differenceSum( v_view ), 0 );

   EXPECT_EQ( u_view.scalarProduct( v_view ), 100 );

}



TEST( VectorSpecialCasesTest, initializationOfVectorViewByArrayView )

{

   using ArrayType = Containers::Array< int, Devices::Host >;

   using VectorViewType = VectorView< const int, Devices::Host >;

   using ArrayViewType = ArrayView< int, Devices::Host >;



   ArrayType a( 100 );

   a.setValue( 0 );

   ArrayViewType a_view( a );



   VectorViewType v_view( a_view );

   EXPECT_EQ( v_view.getData(), a_view.getData() );

   EXPECT_EQ( v_view.sum(), 0 );

}



TYPED_TEST( VectorTest, scalarMultiplication )

{

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   const int size = VECTOR_TEST_SIZE;



   VectorType v;

   v.setSize( size );

   ViewType v_view( v );

   setLinearSequence( v );

   VectorType u( size );

   ViewType u_view( u );



   typename VectorType::HostType expected;

   expected.setSize( size );

   for( int i = 0; i < size; i++ )

      expected[ i ] = 2.0 * i;



   setLinearSequence( u );

   VectorOperations::vectorScalarMultiplication( u, 2.0 );

   EXPECT_EQ( u, expected );



   setLinearSequence( u );

   u.scalarMultiplication( 2.0 );

   EXPECT_EQ( u, expected );



   setLinearSequence( u );

   u_view.scalarMultiplication( 2.0 );

   EXPECT_EQ( u, expected );



   EXPECT_EQ( v.max(), size - 1 );

   EXPECT_EQ( v_view.max(), size - 1 );

   EXPECT_EQ( VectorOperations::getVectorMax( v ), size - 1 );

   setLinearSequence( u );

   u *= 2.0;

   EXPECT_EQ( u, expected );



   setLinearSequence( u );

   u_view *= 2.0;

   EXPECT_EQ( u, expected );

}



TYPED_TEST( VectorTest, min )

TYPED_TEST( VectorTest, addVector )

{

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   const int size = VECTOR_TEST_SIZE;



   VectorType v;

   v.setSize( size );

   ViewType v_view( v );

   setLinearSequence( v );

   VectorType x, y;

   x.setSize( size );

   y.setSize( size );

   ViewType x_view( x ), y_view( y );



   typename VectorType::HostType expected1, expected2;

   expected1.setSize( size );

   expected2.setSize( size );

   for( int i = 0; i < size; i++ ) {

      expected1[ i ] = 2.0 + 3.0 * i;

      expected2[ i ] = 1.0 + 3.0 * i;

   }



   EXPECT_EQ( v.min(), 0 );

   EXPECT_EQ( v_view.min(), 0 );

   EXPECT_EQ( VectorOperations::getVectorMin( v ), 0 );

   setConstantSequence( x, 1 );

   setLinearSequence( y );

   VectorOperations::addVector( x, y, 3.0, 2.0 );

   EXPECT_EQ( x, expected1 );



   setConstantSequence( x, 1 );

   setLinearSequence( y );

   x.addVector( y, 3.0, 1.0 );

   EXPECT_EQ( x, expected2 );



   setConstantSequence( x, 1 );

   setLinearSequence( y );

   x_view.addVector( y_view, 3.0, 1.0 );

   EXPECT_EQ( x, expected2 );



   // multiplication by floating-point scalars which produces integer values

   setConstantSequence( x, 2 );

   setConstantSequence( y, 4 );

   x.addVector( y, 2.5, -1.5 );

   EXPECT_EQ( x.min(), 7 );

   EXPECT_EQ( x.max(), 7 );

}



TYPED_TEST( VectorTest, absMax )

TYPED_TEST( VectorTest, addVectors )

{

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   const int size = VECTOR_TEST_SIZE;



   VectorType v;

   v.setSize( size );

   ViewType v_view( v );

   setNegativeLinearSequence( v );

   VectorType x, y, z;

   x.setSize( size );

   y.setSize( size );

   z.setSize( size );

   ViewType x_view( x ), y_view( y ), z_view( z );



   typename VectorType::HostType expected1, expected2;

   expected1.setSize( size );

   expected2.setSize( size );

   for( int i = 0; i < size; i++ ) {

      expected1[ i ] = 1.0 + 3.0 * i + 2.0;

      expected2[ i ] = 2.0 + 3.0 * i + 2.0;

   }



   EXPECT_EQ( v.absMax(), size - 1 );

   EXPECT_EQ( v_view.absMax(), size - 1 );

   EXPECT_EQ( VectorOperations::getVectorAbsMax( v ), size - 1 );

   setConstantSequence( x, 1 );

   setLinearSequence( y );

   setConstantSequence( z, 2 );

   VectorOperations::addVectors( x, y, 3.0, z, 1.0, 1.0 );

   EXPECT_EQ( x, expected1 );



   setConstantSequence( x, 1 );

   setLinearSequence( y );

   setConstantSequence( z, 2 );

   x.addVectors( y, 3.0, z, 1.0, 2.0 );

   EXPECT_EQ( x, expected2 );



   setConstantSequence( x, 1 );

   setLinearSequence( y );

   setConstantSequence( z, 2 );

   x_view.addVectors( y_view, 3.0, z_view, 1.0, 2.0 );

   EXPECT_EQ( x, expected2 );



   // multiplication by floating-point scalars which produces integer values

   setConstantSequence( x, 2 );

   setConstantSequence( y, 4 );

   setConstantSequence( z, 6 );

   x.addVectors( y, 2.5, z, -1.5, -1.5 );

   EXPECT_EQ( x.min(), -2 );

   EXPECT_EQ( x.max(), -2 );

}



TYPED_TEST( VectorTest, absMin )

TYPED_TEST( VectorTest, abs )

{

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   const int size = VECTOR_TEST_SIZE;



   VectorType v;

   v.setSize( size );

   ViewType v_view( v );

   setNegativeLinearSequence( v );

   VectorType _u( size ), _v( size );

   ViewType u( _u ), v( _v );

   for( int i = 0; i < size; i++ )

      u.setElement( i, i );



   EXPECT_EQ( v.absMin(), 0 );

   EXPECT_EQ( v_view.absMin(), 0 );

   EXPECT_EQ( VectorOperations::getVectorAbsMin( v ), 0 );

   v = -u;

   EXPECT_TRUE( abs( v ) == u );

}



TYPED_TEST( VectorTest, comparison )
@@ -176,6 +321,27 @@ TYPED_TEST( VectorTest, comparison ) 
   EXPECT_TRUE( w + 1.0 < v + 4.0 );

}



TYPED_TEST( VectorTest, horizontalOperations )

{

   using VectorType = typename TestFixture::VectorType;

   using ViewType = typename TestFixture::ViewType;

   using RealType = typename VectorType::RealType;

   using IndexType = typename VectorType::IndexType;

   const int size = VECTOR_TEST_SIZE;



   VectorType _u( size ), _v( size ), _w( size );

   ViewType u( _u ), v( _v ), w( _w );

   EXPECT_EQ( u.getSize(), size );

   u = 0;

   v = 1;

   w = 2;



   u = u + 4 * TNL::max( v, 0 );

   EXPECT_TRUE( u.containsOnlyValue( 4.0 ) );



   u = u + 3 * w + 4 * TNL::max( v, 0 );

   EXPECT_TRUE( u.containsOnlyValue( 14.0 ) );

}



#endif // HAVE_GTEST

src/UnitTests/Containers/VectorTest-2.h

+266 −92
Original line number Diff line number Diff line
@@ -13,140 +13,314 @@ 
#pragma once



#ifdef HAVE_GTEST

#include <limits>



#include <TNL/Experimental/Arithmetics/Quad.h>

#include <TNL/Containers/Vector.h>

#include <TNL/Containers/VectorView.h>

#include "VectorTestSetup.h"



#include "gtest/gtest.h"



using namespace TNL;

using namespace TNL::Containers;

using namespace TNL::Containers::Algorithms;

using namespace TNL::Arithmetics;



// should be small enough to have fast tests, but larger than minGPUReductionDataSize

// and large enough to require multiple CUDA blocks for reduction

constexpr int VECTOR_TEST_SIZE = 5000;

constexpr int VECTOR_TEST_SIZE = 10000;



TYPED_TEST( VectorTest, lpNorm )

TYPED_TEST( VectorTest, prefixSum )

{

   using VectorType = typename TestFixture::VectorType;

   using RealType = typename VectorType::RealType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   using RealType = typename VectorType::RealType;

   using DeviceType = typename VectorType::DeviceType;

   using IndexType = typename VectorType::IndexType;

   const int size = VECTOR_TEST_SIZE;

   const RealType epsilon = 64 * std::numeric_limits< RealType >::epsilon();



   VectorType v;

   v.setSize( size );

   if( std::is_same< RealType, float >::value ||

       std::is_same< IndexType, short >::value )

   return;



   VectorType v( size );

   ViewType v_view( v );

   typename VectorType::HostType v_host( size );



   v = 0;

   v_host = -1;

   v.prefixSum();

   v_host = v;

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_host[ i ], 0 );



   setLinearSequence( v );

   v_host = -1;

   v.prefixSum();

   v_host = v;

   for( int i = 1; i < size; i++ )

      EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i );



   setConstantSequence( v, 1 );

   v_host = -1;

   v_view.prefixSum();

   v_host = v_view;

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_host[ i ], i + 1 );



   const RealType expectedL1norm = size;

   const RealType expectedL2norm = std::sqrt( size );

   const RealType expectedL3norm = std::cbrt( size );

   EXPECT_EQ( v.lpNorm( 1.0 ), expectedL1norm );

   EXPECT_EQ( v.lpNorm( 2.0 ), expectedL2norm );

   EXPECT_NEAR( v.lpNorm( 3.0 ), expectedL3norm, epsilon );

   EXPECT_EQ( v_view.lpNorm( 1.0 ), expectedL1norm );

   EXPECT_EQ( v_view.lpNorm( 2.0 ), expectedL2norm );

   EXPECT_NEAR( v_view.lpNorm( 3.0 ), expectedL3norm, epsilon );

   EXPECT_EQ( VectorOperations::getVectorLpNorm( v, 1.0 ), expectedL1norm );

   EXPECT_EQ( VectorOperations::getVectorLpNorm( v, 2.0 ), expectedL2norm );

   EXPECT_NEAR( VectorOperations::getVectorLpNorm( v, 3.0 ), expectedL3norm, epsilon );

   v = 0;

   v_host = -1;

   v_view.prefixSum();

   v_host = v_view;

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_host[ i ], 0 );



   setLinearSequence( v );

   v_host = -1;

   v_view.prefixSum();

   v_host = v_view;

   for( int i = 1; i < size; i++ )

      EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i );



   ////

   // With CUDA, perform tests with multiple CUDA grids.

   if( std::is_same< DeviceType, Devices::Cuda >::value )

   {

#ifdef HAVE_CUDA

      Algorithms::CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Inclusive, RealType, IndexType >::setMaxGridSize( 3 );

      v = 0;

      v_host = -1;

      v.prefixSum();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Inclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v;

      for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_host[ i ], 0 );



      setLinearSequence( v );

      v_host = -1;

      v.prefixSum();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Inclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v;

      for( int i = 1; i < size; i++ )

         EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i );



      setConstantSequence( v, 1 );

      v_host = -1;

      v_view.prefixSum();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Inclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v_view;

      for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_host[ i ], i + 1 );



      v = 0;

      v_host = -1;

      v_view.prefixSum();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Inclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v_view;

      for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_host[ i ], 0 );



      setLinearSequence( v );

      v_host = -1;

      v_view.prefixSum();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Inclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v_view;

      for( int i = 1; i < size; i++ )

         EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i );

      CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Inclusive, RealType, IndexType >::resetMaxGridSize();

#endif

   }

}



TYPED_TEST( VectorTest, sum )

TYPED_TEST( VectorTest, exclusivePrefixSum )

{

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   // this test expect an even size

   const int size = VECTOR_TEST_SIZE % 2 ? VECTOR_TEST_SIZE - 1 : VECTOR_TEST_SIZE;

   using RealType = typename VectorType::RealType;

   using DeviceType = typename VectorType::DeviceType;

   using IndexType = typename VectorType::IndexType;

   const int size = VECTOR_TEST_SIZE;



   if( std::is_same< RealType, float >::value ||

       std::is_same< IndexType, short >::value )

      return;



   VectorType v;

   v.setSize( size );

   ViewType v_view( v );

   typename VectorType::HostType v_host( size );



   setConstantSequence( v, 1 );

   EXPECT_EQ( v.sum(), size );

   EXPECT_EQ( v_view.sum(), size );

   EXPECT_EQ( VectorOperations::getVectorSum( v ), size );

   v_host = -1;

   v.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

   v_host = v;

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_host[ i ], i );



   v.setValue( 0 );

   v_host = -1;

   v.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

   v_host = v;

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_host[ i ], 0 );



   setLinearSequence( v );

   EXPECT_EQ( v.sum(), 0.5 * size * ( size - 1 ) );

   EXPECT_EQ( v_view.sum(), 0.5 * size * ( size - 1 ) );

   EXPECT_EQ( VectorOperations::getVectorSum( v ), 0.5 * size * ( size - 1 ) );



   setNegativeLinearSequence( v );

   EXPECT_EQ( v.sum(), - 0.5 * size * ( size - 1 ) );

   EXPECT_EQ( v_view.sum(), - 0.5 * size * ( size - 1 ) );

   EXPECT_EQ( VectorOperations::getVectorSum( v ), - 0.5 * size * ( size - 1 ) );



   setOscilatingSequence( v, 1.0 );

   EXPECT_EQ( v.sum(), 0 );

   EXPECT_EQ( v_view.sum(), 0 );

   EXPECT_EQ( VectorOperations::getVectorSum( v ), 0 );

}

   v_host = -1;

   v.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

   v_host = v;

   for( int i = 1; i < size; i++ )

      EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i - 1 );



   setConstantSequence( v, 1 );

   v_host = -1;

   v_view.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

   v_host = v_view;

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_host[ i ], i );



TYPED_TEST( VectorTest, differenceMax )

   v.setValue( 0 );

   v_host = -1;

   v_view.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

   v_host = v_view;

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_host[ i ], 0 );



   setLinearSequence( v );

   v_host = -1;

   v_view.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

   v_host = v_view;

   for( int i = 1; i < size; i++ )

      EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i - 1 );



   ////

   // With CUDA, perform tests with multiple CUDA grids.

   if( std::is_same< DeviceType, Devices::Cuda >::value )

   {

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   const int size = VECTOR_TEST_SIZE;

#ifdef HAVE_CUDA

      CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::setMaxGridSize( 3 );



      setConstantSequence( v, 1 );

      v_host = -1;

      v.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v;

      for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_host[ i ], i );



   VectorType u( size ), v( size );

   ViewType u_view( u ), v_view( v );

   setLinearSequence( u );

   setConstantSequence( v, size / 2 );

      v.setValue( 0 );

      v_host = -1;

      v.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v;

      for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_host[ i ], 0 );



      setLinearSequence( v );

      v_host = -1;

      v.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v;

      for( int i = 1; i < size; i++ )

         EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i - 1 );



      setConstantSequence( v, 1 );

      v_host = -1;

      v_view.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v_view;

      for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_host[ i ], i );



   EXPECT_EQ( u.differenceMax( v ), size - 1 - size / 2 );

   EXPECT_EQ( u_view.differenceMax( v_view ), size - 1 - size / 2 );

   EXPECT_EQ( VectorOperations::getVectorDifferenceMax( u, v ), size - 1 - size / 2 );

      v.setValue( 0 );

      v_host = -1;

      v_view.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v_view;

      for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_host[ i ], 0 );



      setLinearSequence( v );

      v_host = -1;

      v_view.template prefixSum< Algorithms::PrefixSumType::Exclusive >();

      EXPECT_GT( ( CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::gridsCount ), 1  );

      v_host = v_view;

      for( int i = 1; i < size; i++ )

         EXPECT_EQ( v_host[ i ] - v_host[ i - 1 ], i - 1 );

      CudaPrefixSumKernelLauncher< Algorithms::PrefixSumType::Exclusive, RealType, IndexType >::resetMaxGridSize();

#endif

   }

}



TYPED_TEST( VectorTest, differenceMin )

{

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   const int size = VECTOR_TEST_SIZE;

// TODO: test prefix sum with custom begin and end parameters



   VectorType u( size ), v( size );

   ViewType u_view( u ), v_view( v );

   setLinearSequence( u );

   setConstantSequence( v, size / 2 );



   EXPECT_EQ( u.differenceMin( v ), - size / 2 );

   EXPECT_EQ( u_view.differenceMin( v_view ), - size / 2 );

   EXPECT_EQ( VectorOperations::getVectorDifferenceMin( u, v ), - size / 2 );

   EXPECT_EQ( v.differenceMin( u ), size / 2 - size + 1 );

   EXPECT_EQ( v_view.differenceMin( u_view ), size / 2 - size + 1 );

   EXPECT_EQ( VectorOperations::getVectorDifferenceMin( v, u ), size / 2 - size + 1 );



template< typename FlagsView >

void setupFlags( FlagsView& f )

{

   auto f1 = [] __cuda_callable__ ( typename FlagsView::IndexType i ) { return ( i % 5 ) == 0; };

   f.evaluate( f1 );

}



TYPED_TEST( VectorTest, differenceAbsMax )

/*

TYPED_TEST( VectorTest, segmentedPrefixSum )

{

   using VectorType = typename TestFixture::VectorType;

   using VectorOperations = typename TestFixture::VectorOperations;

   using ViewType = typename TestFixture::ViewType;

   // this test expects an odd size

   const int size = VECTOR_TEST_SIZE % 2 ? VECTOR_TEST_SIZE : VECTOR_TEST_SIZE - 1;

   using RealType = typename VectorType::RealType;

   using DeviceType = typename VectorType::DeviceType;

   using IndexType = typename VectorType::IndexType;

   using FlagsArrayType = Array< bool, DeviceType, IndexType >;

   using FlagsViewType = ArrayView< bool, DeviceType, IndexType >;

   const int size = VECTOR_TEST_SIZE;



   VectorType v( size );

   ViewType v_view( v );



   FlagsArrayType flags( size ), flags_copy( size );

   FlagsViewType flags_view( flags );

   //auto f1 = [] __cuda_callable__ ( IndexType i ) { return ( i % 5 ) == 0; };

   //flags_view.evaluate( f1 );

   setupFlags( flags_view );

   flags_copy = flags_view;



   v = 0;

   v.computeSegmentedPrefixSum( flags_view );

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v.getElement( i ), 0 );

   flags_view = flags_copy;



   VectorType u( size ), v( size );

   ViewType u_view( u ), v_view( v );

   setNegativeLinearSequence( u );

   setConstantSequence( v, - size / 2 );

   v = 1;

   v.computeSegmentedPrefixSum( flags_view );

   for( int i = 0; i < size; i++ )

         EXPECT_EQ( v.getElement( i ), ( i % 5 ) + 1 );

   flags_view = flags_copy;



   EXPECT_EQ( u.differenceAbsMax( v ), size - 1 - size / 2 );

   EXPECT_EQ( u_view.differenceAbsMax( v_view ), size - 1 - size / 2 );

   EXPECT_EQ( VectorOperations::getVectorDifferenceAbsMax( u, v ), size - 1 - size / 2 );

   setLinearSequence( v );

   v.computeSegmentedPrefixSum( flags_view );

   for( int i = 1; i < size; i++ )

   {

      if( flags.getElement( i ) )

         EXPECT_EQ( v.getElement( i ), i );

      else

         EXPECT_EQ( v.getElement( i ) - v.getElement( i - 1 ), i );

   }

   flags_view = flags_copy;



   v_view = 0;

   v_view.computeSegmentedPrefixSum( flags_view );

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v_view.getElement( i ), 0 );

   flags_view = flags_copy;



   v_view = 1;

   v_view.computeSegmentedPrefixSum( flags_view );

   for( int i = 0; i < size; i++ )

         EXPECT_EQ( v_view.getElement( i ), ( i % 5 ) + 1 );

   flags_view = flags_copy;



   //v_view.evaluate( [] __cuda_callable__ ( IndexType i ) { return i; } );

   setLinearSequence( v );

   v_view.computeSegmentedPrefixSum( flags_view );

   for( int i = 1; i < size; i++ )

   {

      if( flags.getElement( i ) )

         EXPECT_EQ( v_view.getElement( i ), i );

      else

         EXPECT_EQ( v_view.getElement( i ) - v_view.getElement( i - 1 ), i );

   }

}

*/



#endif // HAVE_GTEST

src/UnitTests/Containers/VectorTest-3.h

+56 −107

File changed.

Preview size limit exceeded, changes collapsed.

src/UnitTests/Containers/VectorTest-4.h

+132 −342

File changed.

Preview size limit exceeded, changes collapsed.

src/UnitTests/Containers/VectorTest-5.h

+47 −157

File changed.

Preview size limit exceeded, changes collapsed.