void verify_rdft2(bench_problem *p, int rounds, double tol, errors *e)
{
C *inA, *inB, *inC, *outA, *outB, *outC, *tmp;
int n, vecn, N;
dofft_rdft2_closure k;
BENCH_ASSERT(p->kind == PROBLEM_REAL);
if (!FINITE_RNK(p->sz->rnk) || !FINITE_RNK(p->vecsz->rnk))
return; /* give up */
k.k.apply = rdft2_apply;
k.k.recopy_input = 0;
k.p = p;
if (rounds == 0)
rounds = 20; /* default value */
n = tensor_sz(p->sz);
vecn = tensor_sz(p->vecsz);
N = n * vecn;
inA = (C *) bench_malloc(N * sizeof(C));
inB = (C *) bench_malloc(N * sizeof(C));
inC = (C *) bench_malloc(N * sizeof(C));
outA = (C *) bench_malloc(N * sizeof(C));
outB = (C *) bench_malloc(N * sizeof(C));
outC = (C *) bench_malloc(N * sizeof(C));
tmp = (C *) bench_malloc(N * sizeof(C));
e->i = impulse(&k.k, n, vecn, inA, inB, inC, outA, outB, outC,
tmp, rounds, tol);
e->l = linear(&k.k, 1, N, inA, inB, inC, outA, outB, outC,
tmp, rounds, tol);
e->s = 0.0;
if (p->sign < 0)
e->s = dmax(e->s, tf_shift(&k.k, 1, p->sz, n, vecn, p->sign,
inA, inB, outA, outB,
tmp, rounds, tol, TIME_SHIFT));
else
e->s = dmax(e->s, tf_shift(&k.k, 1, p->sz, n, vecn, p->sign,
inA, inB, outA, outB,
tmp, rounds, tol, FREQ_SHIFT));
if (!p->in_place && !p->destroy_input)
preserves_input(&k.k, p->sign < 0 ? mkreal : mkhermitian1,
N, inA, inB, outB, rounds);
bench_free(tmp);
bench_free(outC);
bench_free(outB);
bench_free(outA);
bench_free(inC);
bench_free(inB);
bench_free(inA);
}
void verify_dft(bench_problem *p, int rounds, double tol, errors *e)
{
C *inA, *inB, *inC, *outA, *outB, *outC, *tmp;
int n, vecn, N;
dofft_dft_closure k;
BENCH_ASSERT(p->kind == PROBLEM_COMPLEX);
k.k.apply = dft_apply;
k.k.recopy_input = 0;
k.p = p;
if (rounds == 0)
rounds = 20; /* default value */
n = tensor_sz(p->sz);
vecn = tensor_sz(p->vecsz);
N = n * vecn;
inA = (C *) bench_malloc(N * sizeof(C));
inB = (C *) bench_malloc(N * sizeof(C));
inC = (C *) bench_malloc(N * sizeof(C));
outA = (C *) bench_malloc(N * sizeof(C));
outB = (C *) bench_malloc(N * sizeof(C));
outC = (C *) bench_malloc(N * sizeof(C));
tmp = (C *) bench_malloc(N * sizeof(C));
e->i = impulse(&k.k, n, vecn, inA, inB, inC, outA, outB, outC,
tmp, rounds, tol);
e->l = linear(&k.k, 0, N, inA, inB, inC, outA, outB, outC,
tmp, rounds, tol);
e->s = 0.0;
e->s = dmax(e->s, tf_shift(&k.k, 0, p->sz, n, vecn, p->sign,
inA, inB, outA, outB,
tmp, rounds, tol, TIME_SHIFT));
e->s = dmax(e->s, tf_shift(&k.k, 0, p->sz, n, vecn, p->sign,
inA, inB, outA, outB,
tmp, rounds, tol, FREQ_SHIFT));
if (!p->in_place && !p->destroy_input)
preserves_input(&k.k, 0, N, inA, inB, outB, rounds);
bench_free(tmp);
bench_free(outC);
bench_free(outB);
bench_free(outA);
bench_free(inC);
bench_free(inB);
bench_free(inA);
}
void report_verbose(const bench_problem *p, double *t, int st)
{
struct stats s;
char bmin[64], bmax[64], bavg[64], bmedian[64], btmin[64];
char bsetup[64];
int copyp = tensor_sz(p->sz) == 1;
mkstat(t, st, &s);
sprintf_time(s.min, bmin, 64);
sprintf_time(s.max, bmax, 64);
sprintf_time(s.avg, bavg, 64);
sprintf_time(s.median, bmedian, 64);
sprintf_time(time_min, btmin, 64);
sprintf_time(p->setup_time, bsetup, 64);
ovtpvt("Problem: %s, setup: %s, time: %s, %s: %.5g\n",
p->pstring, bsetup, bmin,
copyp ? "fp-move/us" : "``mflops''",
mflops(p, s.min));
if (verbose) {
ovtpvt("Took %d measurements for at least %s each.\n", st, btmin);
ovtpvt("Time: min %s, max %s, avg %s, median %s\n",
bmin, bmax, bavg, bmedian);
}
}
static void cpyhc2(R *ra, R *ia,
const bench_tensor *sza, const bench_tensor *vecsza,
int scalea,
R *rb, R *ib, const bench_tensor *szb)
{
cpyhc2_closure k;
BENCH_ASSERT(sza->rnk <= 1);
k.k.apply = cpyhc20;
k.n = tensor_sz(sza);
k.scalea = scalea;
if (!FINITE_RNK(sza->rnk) || sza->rnk == 0)
k.as = 0;
else
k.as = sza->dims[0].os;
k.ra = ra; k.ia = ia; k.rb = rb; k.ib = ib;
bench_dotens2(vecsza, szb, &k.k);
}
void accuracy_dft(bench_problem *p, int rounds, int impulse_rounds,
double t[6])
{
dofft_dft_closure k;
int n;
C *a, *b;
BENCH_ASSERT(p->kind == PROBLEM_COMPLEX);
BENCH_ASSERT(p->sz->rnk == 1);
BENCH_ASSERT(p->vecsz->rnk == 0);
k.k.apply = dft_apply;
k.k.recopy_input = 0;
k.p = p;
n = tensor_sz(p->sz);
a = (C *) bench_malloc(n * sizeof(C));
b = (C *) bench_malloc(n * sizeof(C));
accuracy_test(&k.k, 0, p->sign, n, a, b, rounds, impulse_rounds, t);
bench_free(b);
bench_free(a);
}
void accuracy_r2r(bench_problem *p, int rounds, int impulse_rounds,
double t[6])
{
dofft_r2r_closure k;
int n, n0 = 1;
C *a, *b;
aconstrain constrain = 0;
BENCH_ASSERT(p->kind == PROBLEM_R2R);
BENCH_ASSERT(p->sz->rnk == 1);
BENCH_ASSERT(p->vecsz->rnk == 0);
k.k.apply = r2r_apply;
k.k.recopy_input = 0;
k.p = p;
n = tensor_sz(p->sz);
switch (p->k[0]) {
case R2R_R2HC: constrain = mkreal; n0 = n; break;
case R2R_HC2R: constrain = mkhermitian1; n0 = n; break;
case R2R_REDFT00: constrain = mkre00; n0 = 2*(n-1); break;
case R2R_RODFT00: constrain = mkro00; n0 = 2*(n+1); break;
case R2R_REDFT01: constrain = mkre01; n0 = 4*n; break;
case R2R_REDFT10: constrain = mkre10; n0 = 4*n; break;
case R2R_RODFT01: constrain = mkro01; n0 = 4*n; break;
case R2R_RODFT10: constrain = mkio10; n0 = 4*n; break;
case R2R_REDFT11: constrain = mkre11; n0 = 8*n; break;
case R2R_RODFT11: constrain = mkro11; n0 = 8*n; break;
default: BENCH_ASSERT(0); /* not yet implemented */
}
k.n0 = n0;
a = (C *) bench_malloc(n0 * sizeof(C));
b = (C *) bench_malloc(n0 * sizeof(C));
accuracy_test(&k.k, constrain, -1, n0, a, b, rounds, impulse_rounds, t);
bench_free(b);
bench_free(a);
}
void accuracy_rdft2(bench_problem *p, int rounds, int impulse_rounds,
double t[6])
{
dofft_rdft2_closure k;
int n;
C *a, *b;
BENCH_ASSERT(p->kind == PROBLEM_REAL);
BENCH_ASSERT(p->sz->rnk == 1);
BENCH_ASSERT(p->vecsz->rnk == 0);
k.k.apply = rdft2_apply;
k.k.recopy_input = 0;
k.p = p;
n = tensor_sz(p->sz);
a = (C *) bench_malloc(n * sizeof(C));
b = (C *) bench_malloc(n * sizeof(C));
accuracy_test(&k.k, p->sign < 0 ? mkreal : mkhermitian1, p->sign,
n, a, b, rounds, impulse_rounds, t);
bench_free(b);
bench_free(a);
}
void verify_r2r(bench_problem *p, int rounds, double tol, errors *e)
{
R *inA, *inB, *inC, *outA, *outB, *outC, *tmp;
info nfo;
int n, vecn, N;
double impulse_amp = 1.0;
dim_stuff *d;
int i;
if (rounds == 0)
rounds = 20; /* default value */
n = tensor_sz(p->sz);
vecn = tensor_sz(p->vecsz);
N = n * vecn;
d = (dim_stuff *) bench_malloc(sizeof(dim_stuff) * p->sz->rnk);
for (i = 0; i < p->sz->rnk; ++i) {
int n0, i0, k0;
trigfun ti, ts;
d[i].n = n0 = p->sz->dims[i].n;
if (p->k[i] > R2R_DHT)
n0 = 2 * (n0 + (p->k[i] == R2R_REDFT00 ? -1 :
(p->k[i] == R2R_RODFT00 ? 1 : 0)));
switch (p->k[i]) {
case R2R_R2HC:
i0 = k0 = 0;
ti = realhalf;
ts = coshalf;
break;
case R2R_DHT:
i0 = k0 = 0;
ti = unity;
ts = cos00;
break;
case R2R_HC2R:
i0 = k0 = 0;
ti = unity;
ts = cos00;
break;
case R2R_REDFT00:
i0 = k0 = 0;
ti = ts = cos00;
break;
case R2R_REDFT01:
i0 = k0 = 0;
ti = ts = cos01;
break;
case R2R_REDFT10:
i0 = k0 = 0;
ti = cos10; impulse_amp *= 2.0;
ts = cos00;
break;
case R2R_REDFT11:
i0 = k0 = 0;
ti = cos11; impulse_amp *= 2.0;
ts = cos01;
break;
case R2R_RODFT00:
i0 = k0 = 1;
ti = sin00; impulse_amp *= 2.0;
ts = cos00;
break;
case R2R_RODFT01:
i0 = 1; k0 = 0;
ti = sin01; impulse_amp *= n == 1 ? 1.0 : 2.0;
ts = cos01;
break;
case R2R_RODFT10:
i0 = 0; k0 = 1;
ti = sin10; impulse_amp *= 2.0;
ts = cos00;
break;
case R2R_RODFT11:
i0 = k0 = 0;
ti = sin11; impulse_amp *= 2.0;
ts = cos01;
break;
default:
BENCH_ASSERT(0);
return;
}
d[i].n0 = n0;
d[i].i0 = i0;
d[i].k0 = k0;
d[i].ti = ti;
d[i].ts = ts;
}
inA = (R *) bench_malloc(N * sizeof(R));
inB = (R *) bench_malloc(N * sizeof(R));
inC = (R *) bench_malloc(N * sizeof(R));
outA = (R *) bench_malloc(N * sizeof(R));
outB = (R *) bench_malloc(N * sizeof(R));
outC = (R *) bench_malloc(N * sizeof(R));
tmp = (R *) bench_malloc(N * sizeof(R));
nfo.p = p;
nfo.probsz = p->sz;
nfo.totalsz = tensor_append(p->vecsz, nfo.probsz);
nfo.pckdsz = verify_pack(nfo.totalsz, 1);
nfo.pckdvecsz = verify_pack(p->vecsz, tensor_sz(nfo.probsz));
e->i = rimpulse(d, impulse_amp, n, vecn, &nfo,
inA, inB, inC, outA, outB, outC, tmp, rounds, tol);
e->l = rlinear(N, &nfo, inA, inB, inC, outA, outB, outC, tmp, rounds,tol);
e->s = t_shift(n, vecn, &nfo, inA, inB, outA, outB, tmp,
rounds, tol, d);
/* grr, verify-lib.c:preserves_input() only works for complex */
if (!p->in_place && !p->destroy_input) {
bench_tensor *totalsz_swap, *pckdsz_swap;
totalsz_swap = tensor_copy_swapio(nfo.totalsz);
pckdsz_swap = tensor_copy_swapio(nfo.pckdsz);
for (i = 0; i < rounds; ++i) {
rarand(inA, N);
dofft(&nfo, inA, outB);
cpyr((R *) nfo.p->in, totalsz_swap, inB, pckdsz_swap);
racmp(inB, inA, N, "preserves_input", 0.0);
}
tensor_destroy(totalsz_swap);
tensor_destroy(pckdsz_swap);
}
tensor_destroy(nfo.totalsz);
tensor_destroy(nfo.pckdsz);
tensor_destroy(nfo.pckdvecsz);
bench_free(tmp);
bench_free(outC);
bench_free(outB);
bench_free(outA);
bench_free(inC);
bench_free(inB);
bench_free(inA);
bench_free(d);
}
static void rdft2_apply(dofft_closure *k_,
bench_complex *in, bench_complex *out)
{
dofft_rdft2_closure *k = (dofft_rdft2_closure *)k_;
bench_problem *p = k->p;
bench_tensor *totalsz, *pckdsz, *totalsz_swap, *pckdsz_swap;
bench_tensor *probsz2, *totalsz2, *pckdsz2;
bench_tensor *probsz2_swap, *totalsz2_swap, *pckdsz2_swap;
bench_real *ri, *ii, *ro, *io;
int n2, totalscale;
totalsz = tensor_append(p->vecsz, p->sz);
pckdsz = verify_pack(totalsz, 2);
n2 = tensor_sz(totalsz);
if (FINITE_RNK(p->sz->rnk) && p->sz->rnk > 0)
n2 = (n2 / p->sz->dims[p->sz->rnk - 1].n) *
(p->sz->dims[p->sz->rnk - 1].n / 2 + 1);
ri = (bench_real *) p->in;
ro = (bench_real *) p->out;
if (FINITE_RNK(p->sz->rnk) && p->sz->rnk > 0 && n2 > 0) {
probsz2 = tensor_copy_sub(p->sz, p->sz->rnk - 1, 1);
totalsz2 = tensor_copy_sub(totalsz, 0, totalsz->rnk - 1);
pckdsz2 = tensor_copy_sub(pckdsz, 0, pckdsz->rnk - 1);
}
else {
probsz2 = mktensor(0);
totalsz2 = tensor_copy(totalsz);
pckdsz2 = tensor_copy(pckdsz);
}
totalsz_swap = tensor_copy_swapio(totalsz);
pckdsz_swap = tensor_copy_swapio(pckdsz);
totalsz2_swap = tensor_copy_swapio(totalsz2);
pckdsz2_swap = tensor_copy_swapio(pckdsz2);
probsz2_swap = tensor_copy_swapio(probsz2);
/* confusion: the stride is the distance between complex elements
when using interleaved format, but it is the distance between
real elements when using split format */
if (p->split) {
ii = p->ini ? (bench_real *) p->ini : ri + n2;
io = p->outi ? (bench_real *) p->outi : ro + n2;
totalscale = 1;
} else {
ii = p->ini ? (bench_real *) p->ini : ri + 1;
io = p->outi ? (bench_real *) p->outi : ro + 1;
totalscale = 2;
}
if (p->sign < 0) { /* R2HC */
int N, vN, i;
cpyr(&c_re(in[0]), pckdsz, ri, totalsz);
after_problem_rcopy_from(p, ri);
doit(1, p);
after_problem_hccopy_to(p, ro, io);
if (k->k.recopy_input)
cpyr(ri, totalsz_swap, &c_re(in[0]), pckdsz_swap);
cpyhc2(ro, io, probsz2, totalsz2, totalscale,
&c_re(out[0]), &c_im(out[0]), pckdsz2);
N = tensor_sz(p->sz);
vN = tensor_sz(p->vecsz);
for (i = 0; i < vN; ++i)
mkhermitian(out + i*N, p->sz->rnk, p->sz->dims, 1);
}
else { /* HC2R */
icpyhc2(ri, ii, probsz2, totalsz2, totalscale,
&c_re(in[0]), &c_im(in[0]), pckdsz2);
after_problem_hccopy_from(p, ri, ii);
doit(1, p);
after_problem_rcopy_to(p, ro);
if (k->k.recopy_input)
cpyhc2(ri, ii, probsz2_swap, totalsz2_swap, totalscale,
&c_re(in[0]), &c_im(in[0]), pckdsz2_swap);
mkreal(out, tensor_sz(pckdsz));
cpyr(ro, totalsz, &c_re(out[0]), pckdsz);
}
tensor_destroy(totalsz);
tensor_destroy(pckdsz);
tensor_destroy(totalsz_swap);
tensor_destroy(pckdsz_swap);
tensor_destroy(probsz2);
tensor_destroy(totalsz2);
tensor_destroy(pckdsz2);
tensor_destroy(probsz2_swap);
tensor_destroy(totalsz2_swap);
tensor_destroy(pckdsz2_swap);
}