[clfft] 13/32: added radix-10 tests. added pre/post callback tests for 1:3 and 1:5 transpose.
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Tue Apr 26 08:34:09 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch master
in repository clfft.
commit 8c76b90d3b2919e7d1ec2c7e8b17cc28a6354932
Author: Timmy <timmy.liu at amd.com>
Date: Wed Mar 23 09:58:20 2016 -0500
added radix-10 tests. added pre/post callback tests for 1:3 and 1:5 transpose.
---
src/library/generator.transpose.cpp | 162 ++++++++++--
src/library/plan.cpp | 14 +-
src/tests/accuracy_test_postcallback.cpp | 289 ++++++++++++++++++++++
src/tests/accuracy_test_pow3_precallback.cpp | 159 ++++++++++++
src/tests/accuracy_test_pow5.cpp | 356 +++++++++++++++++++++++++++
src/tests/accuracy_test_pow5_precallback.cpp | 158 ++++++++++++
6 files changed, 1112 insertions(+), 26 deletions(-)
diff --git a/src/library/generator.transpose.cpp b/src/library/generator.transpose.cpp
index d39f19d..a2374c6 100644
--- a/src/library/generator.transpose.cpp
+++ b/src/library/generator.transpose.cpp
@@ -1034,6 +1034,13 @@ clfftStatus genSwapKernelGeneral(const FFTGeneratedTransposeNonSquareAction::Sig
*/
//if pre-callback is set for the plan
+ if (params.fft_hasPreCallback)
+ {
+ //we have already checked available LDS for pre callback
+ //Insert callback function code at the beginning
+ clKernWrite(transKernel, 0) << params.fft_preCallback.funcstring << std::endl;
+ clKernWrite(transKernel, 0) << std::endl;
+ }
//if post-callback is set for the plan
//twiddle in swap kernel (for now, swap with twiddle seems to always be the second kernel after transpose)
@@ -1195,13 +1202,27 @@ clfftStatus genSwapKernelGeneral(const FFTGeneratedTransposeNonSquareAction::Sig
{
for (int i = 0; i < LDS_per_WG; i = i + 256)
{
- if (i + 256 < LDS_per_WG)
- clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
+ if (i + 256 < LDS_per_WG)
+ {
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "] = " << params.fft_preCallback.funcname
+ << "(inputA-batch_offset*" << smaller_dim * bigger_dim << ", batch_offset*" << smaller_dim * bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
+ }
else
{
// need to handle boundary
clKernWrite(transKernel, 3) << "if(idx+" << i << "<" << LDS_per_WG << "){" << std::endl;
- clKernWrite(transKernel, 6) << "prevValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "] = " << params.fft_preCallback.funcname
+ << "(inputA-batch_offset*" << smaller_dim * bigger_dim << ", batch_offset*" << smaller_dim * bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ clKernWrite(transKernel, 6) << "prevValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
clKernWrite(transKernel, 3) << "}" << std::endl;
}
}
@@ -1216,15 +1237,33 @@ clfftStatus genSwapKernelGeneral(const FFTGeneratedTransposeNonSquareAction::Sig
{
if (i + 256 < LDS_per_WG)
{
- clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
- clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "] = " << params.fft_preCallback.funcname <<
+ "(inputA_R-batch_offset*"<< smaller_dim * bigger_dim <<", inputA_I-batch_offset*"<< smaller_dim * bigger_dim <<
+ ", batch_offset*" << smaller_dim * bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ {
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ }
}
else
{
// need to handle boundary
clKernWrite(transKernel, 3) << "if(idx+" << i << "<" << LDS_per_WG << "){" << std::endl;
- clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
- clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "] = " << params.fft_preCallback.funcname <<
+ "(inputA_R-batch_offset*" << smaller_dim * bigger_dim << ", inputA_I-batch_offset*" << smaller_dim * bigger_dim <<
+ ", batch_offset*" << smaller_dim * bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ {
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
+ clKernWrite(transKernel, 3) << "prevValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ }
clKernWrite(transKernel, 3) << "}" << std::endl;
}
}
@@ -1283,12 +1322,24 @@ clfftStatus genSwapKernelGeneral(const FFTGeneratedTransposeNonSquareAction::Sig
for (int i = 0; i < LDS_per_WG; i = i + 256)
{
if (i + 256 < LDS_per_WG)
- clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "] = " << params.fft_preCallback.funcname
+ << "(inputA-batch_offset*" << smaller_dim * bigger_dim << ", batch_offset*" << smaller_dim*bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
else
{
// need to handle boundary
clKernWrite(transKernel, 6) << "if(idx+" << i << "<" << LDS_per_WG << "){" << std::endl;
- clKernWrite(transKernel, 9) << "nextValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "] = " << params.fft_preCallback.funcname
+ << "(inputA-batch_offset*" << smaller_dim * bigger_dim << ", batch_offset*" << smaller_dim*bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ clKernWrite(transKernel, 9) << "nextValue[idx+" << i << "] = inputA[group_offset+idx+" << i << "];" << std::endl;
clKernWrite(transKernel, 6) << "}" << std::endl;
}
}
@@ -1303,15 +1354,33 @@ clfftStatus genSwapKernelGeneral(const FFTGeneratedTransposeNonSquareAction::Sig
{
if (i + 256 < LDS_per_WG)
{
- clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
- clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "] = " << params.fft_preCallback.funcname <<
+ "(inputA_R-batch_offset*" << smaller_dim * bigger_dim << ", inputA_I-batch_offset*" << smaller_dim * bigger_dim <<
+ ", batch_offset*" << smaller_dim * bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ {
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ }
}
else
{
// need to handle boundary
clKernWrite(transKernel, 6) << "if(idx+" << i << "<" << LDS_per_WG << "){" << std::endl;
- clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
- clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ if (params.fft_hasPreCallback)
+ {
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "] = " << params.fft_preCallback.funcname <<
+ "(inputA_R-batch_offset*" << smaller_dim * bigger_dim << ", inputA_I-batch_offset*" << smaller_dim * bigger_dim <<
+ ", batch_offset*" << smaller_dim * bigger_dim << "+group_offset+idx+" << i << ", pre_userdata);" << std::endl;
+ }
+ else
+ {
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].x = inputA_R[group_offset+idx+" << i << "];" << std::endl;
+ clKernWrite(transKernel, 6) << "nextValue[idx+" << i << "].y = inputA_I[group_offset+idx+" << i << "];" << std::endl;
+ }
clKernWrite(transKernel, 6) << "}" << std::endl;
}
}
@@ -2035,7 +2104,7 @@ clfftStatus genTransposeKernelBatched(const FFTGeneratedTransposeSquareAction::S
clKernWrite(transKernel, 3) << "}" << std::endl;
}
- else {
+ else {//mult_of_16
clKernWrite(transKernel, 3) << "int index;" << std::endl;
clKernWrite(transKernel, 3) << "if (" << params.fft_N[0] << " - (t_gx_p + 1) *" << 16 * reShapeFactor << ">0){" << std::endl;
@@ -2205,14 +2274,25 @@ clfftStatus genTransposeKernelBatched(const FFTGeneratedTransposeSquareAction::S
case CLFFT_COMPLEX_INTERLEAVED:
if (params.fft_hasPostCallback)
{
- clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index]";
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ {
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index]";
+ }
+ else
+ {
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA - iOffset, iOffset + ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index]";
+ }
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
}
clKernWrite(transKernel, 0) << ");" << std::endl;
-
- clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index]";
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ {
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index]";
+ }
+ else
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA - iOffset, iOffset + ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index]";
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
@@ -2228,14 +2308,29 @@ clfftStatus genTransposeKernelBatched(const FFTGeneratedTransposeSquareAction::S
case CLFFT_COMPLEX_PLANAR:
if (params.fft_hasPostCallback)
{
- clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index].x, yx_s[index].y";
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ {
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index].x, yx_s[index].y";
+ }
+ else
+ {
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA_R-iOffset, outputA_I-iOffset, iOffset+((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index].x, yx_s[index].y";
+ }
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
}
clKernWrite(transKernel, 0) << ");" << std::endl;
- clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index].x, xy_s[index].y";
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ {
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index].x, xy_s[index].y";
+ }
+ else
+ {
+ clKernWrite(transKernel, 9) << params.fft_postCallback.funcname << "(outputA_R-iOffset, outputA_I-iOffset, iOffset+((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index].x, xy_s[index].y";
+
+ }
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
@@ -2275,7 +2370,10 @@ clfftStatus genTransposeKernelBatched(const FFTGeneratedTransposeSquareAction::S
clKernWrite(transKernel, 9) << "if ((idy + loop*" << 16 / reShapeFactor << ")<" << params.fft_N[0] << " && idx<" << params.fft_N[0] << ")" << std::endl;
if (params.fft_hasPostCallback)
{
- clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index]";
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index]";
+ else
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA - iOffset, iOffset + ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index]";
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
@@ -2283,8 +2381,11 @@ clfftStatus genTransposeKernelBatched(const FFTGeneratedTransposeSquareAction::S
clKernWrite(transKernel, 0) << ");" << std::endl;
clKernWrite(transKernel, 9) << "if ((t_gy_p * " << 16 * reShapeFactor << " + lidx)<" << params.fft_N[0] << " && (t_gx_p * " << 16 * reShapeFactor << " + lidy + loop*" << 16 / reShapeFactor << ")<" << params.fft_N[0] << ")" << std::endl;
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index]";
+ else
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA - iOffset, iOffset + ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index]";
- clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index]";
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
@@ -2303,7 +2404,14 @@ clfftStatus genTransposeKernelBatched(const FFTGeneratedTransposeSquareAction::S
if (params.fft_hasPostCallback)
{
- clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index].x, yx_s[index].y";
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ {
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index].x, yx_s[index].y";
+ }
+ else
+ {
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA_R-iOffset, outputA_I-iOffset, iOffset+((idy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + idx), post_userdata, yx_s[index].x, yx_s[index].y";
+ }
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
@@ -2311,8 +2419,14 @@ clfftStatus genTransposeKernelBatched(const FFTGeneratedTransposeSquareAction::S
clKernWrite(transKernel, 0) << "); }" << std::endl;
clKernWrite(transKernel, 9) << "if ((t_gy_p * " << 16 * reShapeFactor << " + lidx)<" << params.fft_N[0] << " && (t_gx_p * " << 16 * reShapeFactor << " + lidy + loop*" << 16 / reShapeFactor << ")<" << params.fft_N[0] << ") {" << std::endl;
-
- clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index].x, xy_s[index].y";
+ if (params.transposeMiniBatchSize < 2)//which means the matrix was not broken down into sub square matrics
+ {
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA_R, outputA_I, ((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index].x, xy_s[index].y";
+ }
+ else
+ {
+ clKernWrite(transKernel, 12) << params.fft_postCallback.funcname << "(outputA_R-iOffset, outputA_I-iOffset, iOffset+((lidy + loop*" << 16 / reShapeFactor << ")*" << params.fft_N[0] << " + lidx + starting_index_yx), post_userdata, xy_s[index].x, xy_s[index].y";
+ }
if (params.fft_postCallback.localMemSize > 0)
{
clKernWrite(transKernel, 0) << ", localmem";
diff --git a/src/library/plan.cpp b/src/library/plan.cpp
index 8e951a3..0428c1c 100644
--- a/src/library/plan.cpp
+++ b/src/library/plan.cpp
@@ -610,8 +610,16 @@ clfftStatus clfftBakePlan( clfftPlanHandle plHandle, cl_uint numQueues, cl_comma
}
}
// add some special cases
+ if (fftPlan->length[0] == 10000)
+ clLengths[1] = 100;//100 x 100
if (fftPlan->length[0] == 100000)
- clLengths[1] = 100;
+ clLengths[1] = 100;//100 x 1,000
+ if (fftPlan->length[0] == 10000000)
+ clLengths[1] = 1000;//1,000 x 10,000
+ if (fftPlan->length[0] == 100000000)
+ clLengths[1] = 10000;//10,000 x 10,000
+ if (fftPlan->length[0] == 1000000000)
+ clLengths[1] = 10000;//10,000 x 100,000
clLengths[0] = fftPlan->length[0]/clLengths[1];
//timmy ensure clLengths[0] > clLengths[1] only when inplace is enabled
@@ -655,8 +663,10 @@ clfftStatus clfftBakePlan( clfftPlanHandle plHandle, cl_uint numQueues, cl_comma
(clLengths[0] == 10 * clLengths[1])) &&
fftPlan->placeness == CLFFT_INPLACE)
*/
- size_t dim_ratio = clLengths[1] / clLengths[0];
+ size_t dim_ratio = biggerDim / smallerDim;
+ size_t dim_residue = biggerDim % smallerDim;
if (clfftGetRequestLibNoMemAlloc() &&
+ dim_residue == 0 &&
((dim_ratio % 2 == 0) ||
(dim_ratio % 3 == 0) ||
(dim_ratio % 5 == 0) ||
diff --git a/src/tests/accuracy_test_postcallback.cpp b/src/tests/accuracy_test_postcallback.cpp
index 85c6c67..2299587 100644
--- a/src/tests/accuracy_test_postcallback.cpp
+++ b/src/tests/accuracy_test_postcallback.cpp
@@ -2734,5 +2734,294 @@ TEST_F(accuracy_test_postcallback_double, pow5_large_3D_out_of_place_hermitian_i
catch( const std::exception& err ) { handle_exception(err); }
}
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+// ^^^^^^^^^^^^^^^^^^^^^^^ huge 1D ^^^^^^^^^^^^^^^^^^^^^^ //
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+// *****************************************************
+// *****************************************************
+
+template< class T, class cl_T, class fftw_T>
+void huge_1D_forward_in_place_complex_to_complex(size_t lenSize, size_t batchSize, layout::buffer_layout_t layoutType, direction::direction_t direction_type)
+{
+ std::vector<size_t> lengths;
+ lengths.push_back(lenSize);
+ size_t batch = batchSize;
+ 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 in_layout = layoutType;
+ layout::buffer_layout_t out_layout = layoutType;
+ placeness::placeness_t placeness = placeness::in_place;
+ direction::direction_t direction = direction_type;
+
+ data_pattern pattern = sawtooth;
+ postcallback_complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+}
+
+//177147 = 243 * 243 * 3, forward (no need for backward), planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+//interleaved
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//1594323 = 729 * 729 * 3 foward (no need for backward), planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//14348907 = 2187 * 2187 * 3 backward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//78125 = 125 * 125 * 5, forward planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//1953125 = 625 * 625 * 5 forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//48828125 = 3125 * 3125 * 5 forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_postcallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
#pragma endregion
} //namespace
diff --git a/src/tests/accuracy_test_pow3_precallback.cpp b/src/tests/accuracy_test_pow3_precallback.cpp
index 583dee7..6b09d22 100644
--- a/src/tests/accuracy_test_pow3_precallback.cpp
+++ b/src/tests/accuracy_test_pow3_precallback.cpp
@@ -1809,6 +1809,165 @@ TEST_F(accuracy_test_pow3_precallback_double, large_1D_out_of_place_hermitian_pl
}
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+// ^^^^^^^^^^^^^^^^^^^^^^^ huge 1D ^^^^^^^^^^^^^^^^^^^^^^ //
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+// *****************************************************
+// *****************************************************
+
+template< class T, class cl_T, class fftw_T>
+void huge_1D_forward_in_place_complex_to_complex(size_t lenSize, size_t batchSize, layout::buffer_layout_t layoutType, direction::direction_t direction_type)
+{
+ std::vector<size_t> lengths;
+ lengths.push_back(lenSize);
+ size_t batch = batchSize;
+ 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 in_layout = layoutType;
+ layout::buffer_layout_t out_layout = layoutType;
+ placeness::placeness_t placeness = placeness::in_place;
+ direction::direction_t direction = direction_type;
+
+ data_pattern pattern = sawtooth;
+ precallback_complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+}
+
+//177147 = 243 * 243 * 3, forward (no need for backward), planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(177147, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_177147_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(177147, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//1594323 = 729 * 729 * 3 foward (no need for backward), planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1594323, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1594323_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1594323, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//14348907 = 2187 * 2187 * 3 backward and forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(14348907, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow3_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_14348907_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(14348907, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
// ^^^^^^^^^^^^^^^^^^^^^^^ normal 2D ^^^^^^^^^^^^^^^^^^^^^^ //
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
diff --git a/src/tests/accuracy_test_pow5.cpp b/src/tests/accuracy_test_pow5.cpp
index 9e7f4e6..89b0adf 100644
--- a/src/tests/accuracy_test_pow5.cpp
+++ b/src/tests/accuracy_test_pow5.cpp
@@ -2099,6 +2099,362 @@ TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_
catch (const std::exception& err) { handle_exception(err); }
}
+//10,0000 = 100 * 1,000, backward and forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//1,000,000 = 1,000 * 1,000, backward and forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1000000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_1000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_1000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1000000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//10,000,000 = 10,000 * 1,000, backward and forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(10000000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_10000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_10000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(10000000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//100,000,000 = 10,000 * 10,000, backward and forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 1, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_planar_to_complex_planar_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 3, layout::complex_planar, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_single, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(100000000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000000_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 1, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+TEST_F(accuracy_test_pow5_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_double, huge_1D_backward_in_place_complex_interleaved_to_complex_interleaved_100000000_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(100000000, 3, layout::complex_interleaved, direction::backward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
// ^^^^^^^^^^^^^^^^^^^^^^^ normal 2D ^^^^^^^^^^^^^^^^^^^^^^ //
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
diff --git a/src/tests/accuracy_test_pow5_precallback.cpp b/src/tests/accuracy_test_pow5_precallback.cpp
index eb78c14..ee1db2f 100644
--- a/src/tests/accuracy_test_pow5_precallback.cpp
+++ b/src/tests/accuracy_test_pow5_precallback.cpp
@@ -1809,6 +1809,164 @@ TEST_F(accuracy_test_pow5_precallback_double, large_1D_out_of_place_hermitian_pl
}
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+// ^^^^^^^^^^^^^^^^^^^^^^^ huge 1D ^^^^^^^^^^^^^^^^^^^^^^ //
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
+
+// *****************************************************
+// *****************************************************
+
+template< class T, class cl_T, class fftw_T>
+void huge_1D_forward_in_place_complex_to_complex(size_t lenSize, size_t batchSize, layout::buffer_layout_t layoutType, direction::direction_t direction_type)
+{
+ std::vector<size_t> lengths;
+ lengths.push_back(lenSize);
+ size_t batch = batchSize;
+ 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 in_layout = layoutType;
+ layout::buffer_layout_t out_layout = layoutType;
+ placeness::placeness_t placeness = placeness::in_place;
+ direction::direction_t direction = direction_type;
+
+ data_pattern pattern = sawtooth;
+ precallback_complex_to_complex<T, cl_T, fftw_T>(pattern, direction, lengths, batch, input_strides, output_strides, input_distance, output_distance, in_layout, out_layout, placeness);
+}
+
+//78125 = 125 * 125 * 5, backward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(78125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_78125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(78125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//1953125 = 625 * 625 * 5 backward and forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(1953125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_1953125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(1953125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//48828125 = 3125 * 3125 * 5 backward and forward, planar and interleaved, single and double, batch size 1 and 3
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 1, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_planar_to_complex_planar_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 3, layout::complex_planar, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+//interleaved
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_single, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< float, cl_float, fftwf_complex >(48828125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_1)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 1, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+TEST_F(accuracy_test_pow5_precallback_double, huge_1D_forward_in_place_complex_interleaved_to_complex_interleaved_48828125_3)
+{
+ try { huge_1D_forward_in_place_complex_to_complex< double, cl_double, fftw_complex >(48828125, 3, layout::complex_interleaved, direction::forward); }
+ catch (const std::exception& err) { handle_exception(err); }
+}
+
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
// ^^^^^^^^^^^^^^^^^^^^^^^ normal 2D ^^^^^^^^^^^^^^^^^^^^^^ //
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
--
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