cannam@127: /*
cannam@127:  * Copyright (c) 2001 Matteo Frigo
cannam@127:  * Copyright (c) 2001 Massachusetts Institute of Technology
cannam@127:  *
cannam@127:  * This program is free software; you can redistribute it and/or modify
cannam@127:  * it under the terms of the GNU General Public License as published by
cannam@127:  * the Free Software Foundation; either version 2 of the License, or
cannam@127:  * (at your option) any later version.
cannam@127:  *
cannam@127:  * This program is distributed in the hope that it will be useful,
cannam@127:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
cannam@127:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
cannam@127:  * GNU General Public License for more details.
cannam@127:  *
cannam@127:  * You should have received a copy of the GNU General Public License
cannam@127:  * along with this program; if not, write to the Free Software
cannam@127:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
cannam@127:  *
cannam@127:  */
cannam@127: 
cannam@127: #ifndef __BENCH_USER_H__
cannam@127: #define __BENCH_USER_H__
cannam@127: 
cannam@127: #ifdef __cplusplus
cannam@127: extern "C" {
cannam@127: #endif                          /* __cplusplus */
cannam@127: 
cannam@127: /* benchmark program definitions for user code */
cannam@127: #include "config.h"
cannam@127: #include <limits.h>
cannam@127: 
cannam@127: #if HAVE_STDDEF_H
cannam@127: #include <stddef.h>
cannam@127: #endif
cannam@127: 
cannam@127: #if HAVE_STDLIB_H
cannam@127: #include <stdlib.h>
cannam@127: #endif
cannam@127: 
cannam@127: #if defined(BENCHFFT_SINGLE)
cannam@127: typedef float bench_real;
cannam@127: #elif defined(BENCHFFT_LDOUBLE)
cannam@127: typedef long double bench_real;
cannam@127: #elif defined(BENCHFFT_QUAD)
cannam@127: typedef __float128 bench_real;
cannam@127: #else
cannam@127: typedef double bench_real;
cannam@127: #endif
cannam@127: 
cannam@127: typedef bench_real bench_complex[2];
cannam@127: 
cannam@127: #define c_re(c)  ((c)[0])
cannam@127: #define c_im(c)  ((c)[1])
cannam@127: 
cannam@127: #undef DOUBLE_PRECISION
cannam@127: #define DOUBLE_PRECISION (sizeof(bench_real) == sizeof(double))
cannam@127: #undef SINGLE_PRECISION
cannam@127: #define SINGLE_PRECISION (!DOUBLE_PRECISION && sizeof(bench_real) == sizeof(float))
cannam@127: #undef LDOUBLE_PRECISION
cannam@127: #define LDOUBLE_PRECISION (!DOUBLE_PRECISION && sizeof(bench_real) == sizeof(long double))
cannam@127: 
cannam@127: #undef QUAD_PRECISION
cannam@127: #ifdef BENCHFFT_QUAD
cannam@127: #define QUAD_PRECISION (!LDOUBLE_PRECISION && sizeof(bench_real) == sizeof(__float128))
cannam@127: #else
cannam@127: #define QUAD_PRECISION 0
cannam@127: #endif
cannam@127: 
cannam@127: typedef enum { PROBLEM_COMPLEX, PROBLEM_REAL, PROBLEM_R2R } problem_kind_t;
cannam@127: 
cannam@127: typedef enum {
cannam@127:      R2R_R2HC, R2R_HC2R, R2R_DHT,
cannam@127:      R2R_REDFT00, R2R_REDFT01, R2R_REDFT10, R2R_REDFT11,
cannam@127:      R2R_RODFT00, R2R_RODFT01, R2R_RODFT10, R2R_RODFT11
cannam@127: } r2r_kind_t;
cannam@127: 
cannam@127: typedef struct {
cannam@127:      int n;
cannam@127:      int is;			/* input stride */
cannam@127:      int os;			/* output stride */
cannam@127: } bench_iodim;
cannam@127: 
cannam@127: typedef struct {
cannam@127:      int rnk;
cannam@127:      bench_iodim *dims;
cannam@127: } bench_tensor;
cannam@127: 
cannam@127: bench_tensor *mktensor(int rnk);
cannam@127: void tensor_destroy(bench_tensor *sz);
cannam@127: int tensor_sz(const bench_tensor *sz);
cannam@127: bench_tensor *tensor_compress(const bench_tensor *sz);
cannam@127: int tensor_unitstridep(bench_tensor *t);
cannam@127: int tensor_rowmajorp(bench_tensor *t);
cannam@127: int tensor_real_rowmajorp(bench_tensor *t, int sign, int in_place);
cannam@127: bench_tensor *tensor_append(const bench_tensor *a, const bench_tensor *b);
cannam@127: bench_tensor *tensor_copy(const bench_tensor *sz);
cannam@127: bench_tensor *tensor_copy_sub(const bench_tensor *sz, int start_dim, int rnk);
cannam@127: bench_tensor *tensor_copy_swapio(const bench_tensor *sz);
cannam@127: void tensor_ibounds(bench_tensor *t, int *lbp, int *ubp);
cannam@127: void tensor_obounds(bench_tensor *t, int *lbp, int *ubp);
cannam@127: 
cannam@127: /*
cannam@127:   Definition of rank -infinity.
cannam@127:   This definition has the property that if you want rank 0 or 1,
cannam@127:   you can simply test for rank <= 1.  This is a common case.
cannam@127:  
cannam@127:   A tensor of rank -infinity has size 0.
cannam@127: */
cannam@127: #define BENCH_RNK_MINFTY  INT_MAX
cannam@127: #define BENCH_FINITE_RNK(rnk) ((rnk) != BENCH_RNK_MINFTY)
cannam@127: 
cannam@127: typedef struct {
cannam@127:      problem_kind_t kind;
cannam@127:      r2r_kind_t *k;
cannam@127:      bench_tensor *sz;
cannam@127:      bench_tensor *vecsz;
cannam@127:      int sign;
cannam@127:      int in_place;
cannam@127:      int destroy_input;
cannam@127:      int split;
cannam@127:      void *in, *out;
cannam@127:      void *inphys, *outphys;
cannam@127:      int iphyssz, ophyssz;
cannam@127:      char *pstring;
cannam@127:      void *userinfo; /* user can store whatever */
cannam@127:      int scrambled_in, scrambled_out; /* hack for MPI */
cannam@127: 
cannam@127:      /* internal hack so that we can use verifier in FFTW test program */
cannam@127:      void *ini, *outi; /* if nonzero, point to imag. parts for dft */
cannam@127: 
cannam@127:      /* another internal hack to avoid passing around too many parameters */
cannam@127:      double setup_time;
cannam@127: } bench_problem;
cannam@127: 
cannam@127: extern int verbose;
cannam@127: 
cannam@127: extern int no_speed_allocation;
cannam@127: 
cannam@127: extern int always_pad_real;
cannam@127: 
cannam@127: #define LIBBENCH_TIMER 0
cannam@127: #define USER_TIMER 1
cannam@127: #define BENCH_NTIMERS 2
cannam@127: extern void timer_start(int which_timer);
cannam@127: extern double timer_stop(int which_timer);
cannam@127: 
cannam@127: extern int can_do(bench_problem *p);
cannam@127: extern void setup(bench_problem *p);
cannam@127: extern void doit(int iter, bench_problem *p);
cannam@127: extern void done(bench_problem *p);
cannam@127: extern void main_init(int *argc, char ***argv);
cannam@127: extern void cleanup(void);
cannam@127: extern void verify(const char *param, int rounds, double tol);
cannam@127: extern void useropt(const char *arg);
cannam@127: 
cannam@127: extern void verify_problem(bench_problem *p, int rounds, double tol);
cannam@127: 
cannam@127: extern void problem_alloc(bench_problem *p);
cannam@127: extern void problem_free(bench_problem *p);
cannam@127: extern void problem_zero(bench_problem *p);
cannam@127: extern void problem_destroy(bench_problem *p);
cannam@127: 
cannam@127: extern int power_of_two(int n);
cannam@127: extern int log_2(int n);
cannam@127: 
cannam@127: 
cannam@127: #define CASSIGN(out, in) (c_re(out) = c_re(in), c_im(out) = c_im(in))
cannam@127: 
cannam@127: bench_tensor *verify_pack(const bench_tensor *sz, int s);
cannam@127: 
cannam@127: typedef struct {
cannam@127:      double l;
cannam@127:      double i;
cannam@127:      double s;
cannam@127: } errors;
cannam@127: 
cannam@127: void verify_dft(bench_problem *p, int rounds, double tol, errors *e);
cannam@127: void verify_rdft2(bench_problem *p, int rounds, double tol, errors *e);
cannam@127: void verify_r2r(bench_problem *p, int rounds, double tol, errors *e);
cannam@127: 
cannam@127: /**************************************************************/
cannam@127: /* routines to override */
cannam@127: 
cannam@127: extern void after_problem_ccopy_from(bench_problem *p, bench_real *ri, bench_real *ii);
cannam@127: extern void after_problem_ccopy_to(bench_problem *p, bench_real *ro, bench_real *io);
cannam@127: extern void after_problem_hccopy_from(bench_problem *p, bench_real *ri, bench_real *ii);
cannam@127: extern void after_problem_hccopy_to(bench_problem *p, bench_real *ro, bench_real *io);
cannam@127: extern void after_problem_rcopy_from(bench_problem *p, bench_real *ri);
cannam@127: extern void after_problem_rcopy_to(bench_problem *p, bench_real *ro);
cannam@127: extern void bench_exit(int status);
cannam@127: extern double bench_cost_postprocess(double cost);
cannam@127: 
cannam@127: /**************************************************************
cannam@127:  * malloc
cannam@127:  **************************************************************/
cannam@127: extern void *bench_malloc(size_t size);
cannam@127: extern void bench_free(void *ptr);
cannam@127: extern void bench_free0(void *ptr);
cannam@127: 
cannam@127: /**************************************************************
cannam@127:  * alloca
cannam@127:  **************************************************************/
cannam@127: #ifdef HAVE_ALLOCA_H
cannam@127: #include <alloca.h>
cannam@127: #endif
cannam@127: 
cannam@127: /**************************************************************
cannam@127:  * assert
cannam@127:  **************************************************************/
cannam@127: extern void bench_assertion_failed(const char *s, int line, const char *file);
cannam@127: #define BENCH_ASSERT(ex)						 \
cannam@127:       (void)((ex) || (bench_assertion_failed(#ex, __LINE__, __FILE__), 0))
cannam@127: 
cannam@127: #define UNUSED(x) (void)x
cannam@127: 
cannam@127: /***************************************
cannam@127:  * Documentation strings
cannam@127:  ***************************************/
cannam@127: struct bench_doc {
cannam@127:      const char *key;
cannam@127:      const char *val;
cannam@127:      const char *(*f)(void);
cannam@127: };
cannam@127: 
cannam@127: extern struct bench_doc bench_doc[];
cannam@127: 
cannam@127: #ifdef CC
cannam@127: #define CC_DOC BENCH_DOC("cc", CC)
cannam@127: #elif defined(BENCH_CC)
cannam@127: #define CC_DOC BENCH_DOC("cc", BENCH_CC)
cannam@127: #else
cannam@127: #define CC_DOC /* none */
cannam@127: #endif
cannam@127: 
cannam@127: #ifdef CXX
cannam@127: #define CXX_DOC BENCH_DOC("cxx", CXX)
cannam@127: #elif defined(BENCH_CXX)
cannam@127: #define CXX_DOC BENCH_DOC("cxx", BENCH_CXX)
cannam@127: #else
cannam@127: #define CXX_DOC /* none */
cannam@127: #endif
cannam@127: 
cannam@127: #ifdef F77
cannam@127: #define F77_DOC BENCH_DOC("f77", F77)
cannam@127: #elif defined(BENCH_F77)
cannam@127: #define F77_DOC BENCH_DOC("f77", BENCH_F77)
cannam@127: #else
cannam@127: #define F77_DOC /* none */
cannam@127: #endif
cannam@127: 
cannam@127: #ifdef F90
cannam@127: #define F90_DOC BENCH_DOC("f90", F90)
cannam@127: #elif defined(BENCH_F90)
cannam@127: #define F90_DOC BENCH_DOC("f90", BENCH_F90)
cannam@127: #else
cannam@127: #define F90_DOC /* none */
cannam@127: #endif
cannam@127: 
cannam@127: #define BEGIN_BENCH_DOC						\
cannam@127: struct bench_doc bench_doc[] = {				\
cannam@127:     CC_DOC							\
cannam@127:     CXX_DOC							\
cannam@127:     F77_DOC							\
cannam@127:     F90_DOC
cannam@127: 
cannam@127: #define BENCH_DOC(key, val) { key, val, 0 },
cannam@127: #define BENCH_DOCF(key, f) { key, 0, f },
cannam@127: 
cannam@127: #define END_BENCH_DOC				\
cannam@127:      {0, 0, 0}};
cannam@127: 
cannam@127: #ifdef __cplusplus
cannam@127: }                               /* extern "C" */
cannam@127: #endif                          /* __cplusplus */
cannam@127:     
cannam@127: #endif /* __BENCH_USER_H__ */