[clfft] 26/128: Precallback - R2C 2D and 3D implementation plus few GTests
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Thu Oct 22 14:54:34 UTC 2015
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch master
in repository clfft.
commit 8092c998ec11d884fc3b6db1cc553842dc4c6dd8
Author: Pradeep <pradeep.rao at amd.com>
Date: Thu Aug 20 16:27:24 2015 +0530
Precallback - R2C 2D and 3D implementation plus few GTests
---
src/library/plan.cpp | 15 +
src/tests/accuracy_test_common.h | 67 +++
src/tests/accuracy_test_precallback.cpp | 908 ++++++++++++++++++++++++++++++++
3 files changed, 990 insertions(+)
diff --git a/src/library/plan.cpp b/src/library/plan.cpp
index 5642465..b5911fb 100644
--- a/src/library/plan.cpp
+++ b/src/library/plan.cpp
@@ -2133,6 +2133,13 @@ clfftStatus clfftBakePlan( clfftPlanHandle plHandle, cl_uint numQueues, cl_comma
rowPlan->outStride.push_back(fftPlan->outStride[index]);
}
+ //Set callback data if set on top level plan
+ if (fftPlan->hasPreCallback)
+ {
+ rowPlan->hasPreCallback = true;
+ rowPlan->preCallback = fftPlan->preCallback;
+ rowPlan->precallUserData = fftPlan->precallUserData;
+ }
OPENCL_V(clfftBakePlan(fftPlan->planX, numQueues, commQueueFFT, NULL, NULL ), _T( "BakePlan for planX failed" ) );
@@ -2993,6 +3000,14 @@ clfftStatus clfftBakePlan( clfftPlanHandle plHandle, cl_uint numQueues, cl_comma
xyPlan->outStride.push_back(fftPlan->outStride[index]);
}
+ //Set callback data if set on top level plan
+ if (fftPlan->hasPreCallback)
+ {
+ xyPlan->hasPreCallback = true;
+ xyPlan->preCallback = fftPlan->preCallback;
+ xyPlan->precallUserData = fftPlan->precallUserData;
+ }
+
OPENCL_V(clfftBakePlan(fftPlan->planX, numQueues, commQueueFFT, NULL, NULL ), _T( "BakePlan 3D->2D planX failed" ) );
if( (xyPlan->inStride[0] == 1) && (xyPlan->outStride[0] == 1) &&
diff --git a/src/tests/accuracy_test_common.h b/src/tests/accuracy_test_common.h
index 7807701..a6256e3 100644
--- a/src/tests/accuracy_test_common.h
+++ b/src/tests/accuracy_test_common.h
@@ -513,3 +513,70 @@ void real_to_complex_round_trip( data_pattern pattern,
EXPECT_EQ( true, test_fft.result() == expected );
}
+
+/*****************************************************/
+/*****************************************************/
+// dimension is inferred from lengths.size()
+// tightly packed is inferred from strides.empty()
+template< class T, class cl_T, class fftw_T >
+void precallback_real_to_complex_round_trip( data_pattern pattern,
+ std::vector<size_t> lengths, size_t batch )
+{
+ placeness::placeness_t placeness = placeness::in_place;
+
+ clfft<T, cl_T> test_fft( static_cast<clfftDim>(lengths.size()), &lengths[0],
+ NULL, NULL, batch, 0, 0,
+ cl_layout(layout::real), cl_layout(layout::hermitian_interleaved),
+ cl_placeness( placeness ) );
+
+ buffer<T> expected( lengths.size(), &lengths[0], NULL, batch, 0, layout::real, CLFFT_OUTOFPLACE );
+
+ if( pattern == sawtooth )
+ {
+ test_fft.set_input_to_sawtooth( 1.0f );
+ expected.set_all_to_sawtooth( 1.0f );
+ }
+ else if( pattern == value )
+ {
+ test_fft.set_input_to_value( 2.0f );
+ expected.set_all_to_value( 2.0f );
+ }
+ else if( pattern == impulse )
+ {
+ test_fft.set_input_to_impulse();
+ expected.set_all_to_impulse();
+ }
+ else if( pattern == erratic )
+ {
+ test_fft.set_input_to_random();
+ expected.set_all_to_random_data( 10, super_duper_global_seed );
+ }
+ else
+ {
+ throw std::runtime_error( "invalid pattern type in real_to_complex_round_trip()" );
+ }
+
+ // if we're starting with unequal data, we're destined for failure
+ EXPECT_EQ( true, test_fft.input_buffer() == expected );
+
+ test_fft.set_input_precallback();
+
+ //precallback user data
+ buffer<T> userdata( lengths.size(), &lengths[0], NULL, batch, 0, layout::real, CLFFT_OUTOFPLACE);
+ userdata.set_all_to_random_data(lengths[0], 10);
+
+ expected *= userdata;
+
+ test_fft.transform();
+
+ // confirm that we actually did something
+ bool stash_suppress_output = suppress_output;
+ suppress_output = true;
+ EXPECT_EQ( false, test_fft.result() == expected );
+ suppress_output = stash_suppress_output;
+
+ test_fft.swap_layouts();
+ test_fft.transform();
+
+ EXPECT_EQ( true, test_fft.result() == expected );
+}
diff --git a/src/tests/accuracy_test_precallback.cpp b/src/tests/accuracy_test_precallback.cpp
index 6a392a4..c9c01e8 100644
--- a/src/tests/accuracy_test_precallback.cpp
+++ b/src/tests/accuracy_test_precallback.cpp
@@ -45,8 +45,105 @@ protected:
}
};
+class mixed_radix_precallback : public ::testing::TestWithParam<size_t> {
+ protected:
+ mixed_radix_precallback(){}
+ virtual ~mixed_radix_precallback(){}
+ virtual void SetUp(){}
+ virtual void TearDown(){}
+};
+
+class Supported_Fft_Sizes_precallback
+{
+public:
+ std::vector<size_t> sizes;
+ const size_t max_mixed_radices_to_test;
+
+ Supported_Fft_Sizes_precallback()
+ : max_mixed_radices_to_test( 4096 )
+ {
+ size_t i=0, j=0, k=0;
+ size_t sum, sumi, sumj, sumk;
+
+ sumi = 1; i = 0;
+ while(1)
+ {
+ sumj = 1; j = 0;
+ while(1)
+ {
+ sumk = 1; k = 0;
+ while(1)
+ {
+ sum = (sumi*sumj*sumk);
+ if( sum > max_mixed_radices_to_test ) break;
+
+ sizes.push_back(sum);
+ k++;
+ sumk *= 2;
+ }
+
+ if(k == 0) break;
+ j++;
+ sumj *= 3;
+ }
+
+ if( (j == 0) && (k == 0) ) break;
+ i++;
+ sumi *= 5;
+ }
+ }
+} supported_sizes;
+
+INSTANTIATE_TEST_CASE_P(
+ mixed_radices_precallback,
+ mixed_radix_precallback,
+ ::testing::ValuesIn( supported_sizes.sizes )
+);
+
namespace precallback
{
+
+template< typename T, typename cl_T, typename fftw_T >
+void mixed_radix_real_to_hermitian( size_t problem_size )
+{
+ try
+ {
+ if(verbose) std::cout << "Now testing problem size " << problem_size << std::endl;
+
+ std::vector<size_t> lengths;
+ lengths.push_back( problem_size );
+ size_t batch = 1;
+
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+ }
+ catch( const std::exception& err ) {
+ handle_exception(err);
+ }
+}
+
+TEST_P( mixed_radix_precallback, single_precision_real_to_hermitian_auto_generated ) {
+ size_t problem_size = GetParam();
+ RecordProperty("problem_size", (int)problem_size);
+ mixed_radix_real_to_hermitian<float, cl_float, fftwf_complex>(problem_size);
+}
+
+TEST_P( mixed_radix_precallback, double_precision_real_to_hermitian_auto_generated ) {
+ size_t problem_size = GetParam();
+ RecordProperty("problem_size", (int)problem_size);
+ mixed_radix_real_to_hermitian<double, cl_double, fftw_complex>(problem_size);
+}
+
// *****************************************************
// *****************************************************
template< class T, class cl_T, class fftw_T >
@@ -459,4 +556,815 @@ TEST_F(accuracy_test_precallback_double, pow3_large_1D_in_place_real_to_hermitia
catch( const std::exception& err ) { handle_exception(err); }
}
+template< class T, class cl_T, class fftw_T >
+void pow3_normal_1D_out_of_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal3 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_normal_1D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow3_normal_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_normal_1D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow3_normal_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow3_normal_1D_array_real_to_hermitian_with_odd_batch_size()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal3 );
+ size_t batch = 5;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_normal_1D_array_real_to_hermitian_with_odd_batch_size)
+{
+ try { pow3_normal_1D_array_real_to_hermitian_with_odd_batch_size< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_normal_1D_array_real_to_hermitian_with_odd_batch_size)
+{
+ try { pow3_normal_1D_array_real_to_hermitian_with_odd_batch_size< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow3_very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 9 );
+ size_t batch = 2;
+
+ std::vector<size_t> input_strides;
+ input_strides.push_back( 16 );
+
+ size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 128;
+
+ std::vector<size_t> output_strides;
+ output_strides.push_back( 2 );
+
+ size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 2;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = impulse;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow3_very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow3_very_small_1D_in_place_different_input_output_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow3_very_small_1D_non_unit_stride_and_distance_real_to_complex()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 9 );
+ size_t batch = 2;
+
+ std::vector<size_t> input_strides;
+ input_strides.push_back( 2 );
+
+ size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 2;
+
+ std::vector<size_t> output_strides( input_strides );
+ size_t output_distance = input_distance;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = impulse;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_very_small_1D_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow3_very_small_1D_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_very_small_1D_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow3_very_small_1D_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow3_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 9 );
+ size_t batch = 2;
+
+ std::vector<size_t> input_strides;
+ input_strides.push_back( 16 );
+
+ size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 128;
+
+ std::vector<size_t> output_strides;
+ output_strides.push_back( 2 );
+
+ size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 2;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = impulse;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow3_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow3_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow3_normal_1D_user_defined_scale_real_to_hermitian()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal3 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_planar;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = impulse;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness, 42.0f );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_normal_1D_user_defined_scale_real_to_hermitian)
+{
+ try { pow3_normal_1D_user_defined_scale_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_normal_1D_user_defined_scale_real_to_hermitian)
+{
+ try { pow3_normal_1D_user_defined_scale_real_to_hermitian< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow3_normal_1D_round_trip_real_to_complex()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal3 );
+ size_t batch = 1;
+
+ data_pattern pattern = impulse;
+ precallback_real_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_normal_1D_round_trip_real_to_complex)
+{
+ try { pow3_normal_1D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_normal_1D_round_trip_real_to_complex)
+{
+ try { pow3_normal_1D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow3_large_1D_round_trip_real_to_complex()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( large3 );
+ size_t batch = 1;
+
+ data_pattern pattern = impulse;
+ precallback_real_to_complex_round_trip<T, cl_T, fftw_T>( pattern, lengths, batch );
+}
+
+TEST_F(accuracy_test_precallback_single, pow3_large_1D_round_trip_real_to_complex)
+{
+ try { pow3_large_1D_round_trip_real_to_complex< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow3_large_1D_round_trip_real_to_complex)
+{
+ try { pow3_large_1D_round_trip_real_to_complex< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_normal_2D_in_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal2 );
+ lengths.push_back( normal2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_normal_2D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_normal_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_normal_2D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_normal_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_normal_2D_out_of_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal2 );
+ lengths.push_back( normal2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_normal_2D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow2_normal_2D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_normal_2D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow2_normal_2D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_large_2D_out_of_place_real_to_hermitian_planar()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( MaxLength2D<T>(2) );
+ lengths.push_back( normal2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_planar;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_large_2D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow2_large_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_large_2D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow2_large_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_small_2D_in_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( small2 );
+ lengths.push_back( small2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_small_2D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_small_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_small_2D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_small_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_small_2D_non_unit_stride_and_distance_real_to_hermitian()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 4 );
+ lengths.push_back( 4 );
+ size_t batch = 2;
+
+ std::vector<size_t> input_strides;
+ input_strides.push_back( 5 );
+ input_strides.push_back( lengths[0] * input_strides[0] + 1 );
+
+ std::vector<size_t> output_strides;
+ output_strides.push_back( 2 );
+ output_strides.push_back( lengths[0] * output_strides[0] + 2 );
+
+ size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 30;
+ size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 42;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_small_2D_non_unit_stride_and_distance_real_to_hermitian)
+{
+ try { pow2_small_2D_non_unit_stride_and_distance_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_small_2D_non_unit_stride_and_distance_real_to_hermitian)
+{
+ try { pow2_small_2D_non_unit_stride_and_distance_real_to_hermitian< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void mixed_another_targeted_real_to_hermitian_transform()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 30 );
+ lengths.push_back( 10125 );
+ size_t batch = 1;
+
+ std::vector<size_t> input_strides;
+ input_strides.push_back( 1 );
+ input_strides.push_back( 32 );
+ size_t input_distance = 324000;
+
+ std::vector<size_t> output_strides;
+ output_strides.push_back( 1 );
+ output_strides.push_back( 16 );
+ size_t output_distance = 162000;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, mixed_another_targeted_real_to_hermitian_transform)
+{
+ try { mixed_another_targeted_real_to_hermitian_transform< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, mixed_another_targeted_real_to_hermitian_transform)
+{
+ try { mixed_another_targeted_real_to_hermitian_transform< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void mixed_larger_targeted_real_to_hermitian_transform()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 15 );
+ lengths.push_back( 4500 );
+ size_t batch = 2;
+
+ std::vector<size_t> input_strides;
+ input_strides.push_back( 1 );
+ input_strides.push_back( 16 );
+ size_t input_distance = 72000;
+
+ std::vector<size_t> output_strides;
+ output_strides.push_back( 1 );
+ output_strides.push_back( 8 );
+ size_t output_distance = 36000;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, mixed_larger_targeted_real_to_hermitian_transform)
+{
+ try { mixed_larger_targeted_real_to_hermitian_transform< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, mixed_larger_targeted_real_to_hermitian_transform)
+{
+ try { mixed_larger_targeted_real_to_hermitian_transform< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void mixed_1D_length_375_real_to_hermitian()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 375 );
+ size_t batch = 1;
+
+ std::vector<size_t> input_strides;
+ size_t input_distance = 0;
+
+ std::vector<size_t> output_strides;
+ size_t output_distance = 0;
+
+ layout::buffer_layout_t layout = layout::hermitian_planar;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, mixed_1D_length_375_real_to_hermitian)
+{
+ try { mixed_1D_length_375_real_to_hermitian< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, mixed_1D_length_375_real_to_hermitian)
+{
+ try { mixed_1D_length_375_real_to_hermitian< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow5_normal_1D_in_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal5 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow5_normal_1D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow5_normal_1D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow5_normal_1D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow5_normal_1D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow5_small_1D_out_of_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( small5 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow5_small_1D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow5_small_1D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow5_small_1D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow5_small_1D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow5_large_1D_out_of_place_real_to_hermitian_planar()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( large5 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_planar;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow5_large_1D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow5_large_1D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow5_large_1D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow5_large_1D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow5_normal_2D_in_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal5 );
+ lengths.push_back( normal5 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow5_normal_2D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow5_normal_2D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow5_normal_2D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow5_normal_2D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow5_large_2D_out_of_place_real_to_hermitian_planar()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( MaxLength2D<T>(5) );
+ lengths.push_back( normal5 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_planar;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow5_large_2D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow5_large_2D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow5_large_2D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow5_large_2D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow5_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 25 );
+ size_t batch = 2;
+
+ std::vector<size_t> input_strides;
+ input_strides.push_back( 16 );
+
+ size_t input_distance = lengths[lengths.size()-1] * input_strides[input_strides.size()-1] + 128;
+
+ std::vector<size_t> output_strides;
+ output_strides.push_back( 2 );
+
+ size_t output_distance = lengths[lengths.size()-1] * output_strides[output_strides.size()-1] + 2;
+
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = impulse;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow5_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow5_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow5_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex)
+{
+ try { pow5_very_small_1D_out_of_place_different_input_output_non_unit_stride_and_distance_real_to_complex< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_normal_3D_in_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( small2 );
+ lengths.push_back( normal2 );
+ lengths.push_back( small2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_normal_3D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_normal_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_normal_3D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_normal_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_normal_3D_out_of_place_real_to_hermitian_planar()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( normal2 );
+ lengths.push_back( small2 );
+ lengths.push_back( small2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_planar;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_normal_3D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow2_normal_3D_out_of_place_real_to_hermitian_planar< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_normal_3D_out_of_place_real_to_hermitian_planar)
+{
+ try { pow2_normal_3D_out_of_place_real_to_hermitian_planar< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_small_3D_out_of_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( small2 );
+ lengths.push_back( small2 );
+ lengths.push_back( small2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::out_of_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_small_3D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow2_small_3D_out_of_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_small_3D_out_of_place_real_to_hermitian_interleaved)
+{
+ try { pow2_small_3D_out_of_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+template< class T, class cl_T, class fftw_T >
+void pow2_large_3D_in_place_real_to_hermitian_interleaved()
+{
+ std::vector<size_t> lengths;
+ lengths.push_back( 2 );
+ lengths.push_back( 2 );
+ lengths.push_back( large2 );
+ size_t batch = 1;
+ std::vector<size_t> input_strides;
+ std::vector<size_t> output_strides;
+ size_t input_distance = 0;
+ size_t output_distance = 0;
+ layout::buffer_layout_t layout = layout::hermitian_interleaved;
+ placeness::placeness_t placeness = placeness::in_place;
+
+ data_pattern pattern = sawtooth;
+ precallback_real_to_complex<T, cl_T, fftw_T>( pattern, lengths, batch, input_strides, output_strides, input_distance, output_distance, layout, placeness );
+}
+
+TEST_F(accuracy_test_precallback_single, pow2_large_3D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_large_3D_in_place_real_to_hermitian_interleaved< float, cl_float, fftwf_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_precallback_double, pow2_large_3D_in_place_real_to_hermitian_interleaved)
+{
+ try { pow2_large_3D_in_place_real_to_hermitian_interleaved< double, cl_double, fftw_complex >(); }
+ catch( const std::exception& err ) { handle_exception(err); }
+}
+
+
}
\ No newline at end of file
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/clfft.git
More information about the debian-science-commits
mailing list