void libblis_test_symv_experiment
(
test_params_t* params,
test_op_t* op,
iface_t iface,
num_t datatype,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid
)
{
unsigned int n_repeats = params->n_repeats;
unsigned int i;
double time_min = DBL_MAX;
double time;
dim_t m;
uplo_t uploa;
conj_t conja;
conj_t conjx;
obj_t alpha, a, x, beta, y;
obj_t y_save;
// Map the dimension specifier to an actual dimension.
m = libblis_test_get_dim_from_prob_size( op->dim_spec[0], p_cur );
// Map parameter characters to BLIS constants.
bli_param_map_char_to_blis_uplo( pc_str[0], &uploa );
bli_param_map_char_to_blis_conj( pc_str[1], &conja );
bli_param_map_char_to_blis_conj( pc_str[2], &conjx );
// Create test scalars.
bli_obj_scalar_init_detached( datatype, &alpha );
bli_obj_scalar_init_detached( datatype, &beta );
// Create test operands (vectors and/or matrices).
libblis_test_mobj_create( params, datatype, BLIS_NO_TRANSPOSE,
sc_str[0], m, m, &a );
libblis_test_vobj_create( params, datatype,
sc_str[1], m, &x );
libblis_test_vobj_create( params, datatype,
sc_str[2], m, &y );
libblis_test_vobj_create( params, datatype,
sc_str[2], m, &y_save );
// Set alpha and beta.
if ( bli_obj_is_real( &y ) )
{
bli_setsc( 1.0, 0.0, &alpha );
bli_setsc( -1.0, 0.0, &beta );
}
else
{
bli_setsc( 0.5, 0.5, &alpha );
bli_setsc( -0.5, 0.5, &beta );
}
// Set the structure and uplo properties of A.
bli_obj_set_struc( BLIS_SYMMETRIC, &a );
bli_obj_set_uplo( uploa, &a );
// Randomize A, make it densely symmetric, and zero the unstored triangle
// to ensure the implementation reads only from the stored region.
libblis_test_mobj_randomize( params, TRUE, &a );
bli_mksymm( &a );
bli_mktrim( &a );
// Randomize x and y, and save y.
libblis_test_vobj_randomize( params, TRUE, &x );
libblis_test_vobj_randomize( params, TRUE, &y );
bli_copyv( &y, &y_save );
// Apply the remaining parameters.
bli_obj_set_conj( conja, &a );
bli_obj_set_conj( conjx, &x );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
bli_copym( &y_save, &y );
time = bli_clock();
libblis_test_symv_impl( iface, &alpha, &a, &x, &beta, &y );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 1.0 * m * m ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( &y ) ) *perf *= 4.0;
// Perform checks.
libblis_test_symv_check( params, &alpha, &a, &x, &beta, &y, &y_save, resid );
// Zero out performance and residual if output vector is empty.
libblis_test_check_empty_problem( &y, perf, resid );
// Free the test objects.
bli_obj_free( &a );
bli_obj_free( &x );
bli_obj_free( &y );
bli_obj_free( &y_save );
}
void libblis_test_trsm_check
(
test_params_t* params,
side_t side,
obj_t* alpha,
obj_t* a,
obj_t* b,
obj_t* b_orig,
double* resid
)
{
num_t dt = bli_obj_datatype( *b );
num_t dt_real = bli_obj_datatype_proj_to_real( *b );
dim_t m = bli_obj_length( *b );
dim_t n = bli_obj_width( *b );
obj_t norm;
obj_t t, v, w, z;
double junk;
//
// Pre-conditions:
// - a is randomized and triangular.
// - b_orig is randomized.
// Note:
// - alpha should have a non-zero imaginary component in the
// complex cases in order to more fully exercise the implementation.
//
// Under these conditions, we assume that the implementation for
//
// B := alpha * inv(transa(A)) * B_orig (side = left)
// B := alpha * B_orig * inv(transa(A)) (side = right)
//
// is functioning correctly if
//
// normf( v - z )
//
// is negligible, where
//
// v = B * t
//
// z = ( alpha * inv(transa(A)) * B ) * t (side = left)
// = alpha * inv(transa(A)) * B * t
// = alpha * inv(transa(A)) * w
//
// z = ( alpha * B * inv(transa(A)) ) * t (side = right)
// = alpha * B * tinv(ransa(A)) * t
// = alpha * B * w
bli_obj_scalar_init_detached( dt_real, &norm );
if ( bli_is_left( side ) )
{
bli_obj_create( dt, n, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, m, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
}
else // else if ( bli_is_left( side ) )
{
bli_obj_create( dt, n, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, n, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
}
libblis_test_vobj_randomize( params, TRUE, &t );
bli_gemv( &BLIS_ONE, b, &t, &BLIS_ZERO, &v );
if ( bli_is_left( side ) )
{
bli_gemv( alpha, b_orig, &t, &BLIS_ZERO, &w );
bli_trsv( &BLIS_ONE, a, &w );
bli_copyv( &w, &z );
}
else
{
bli_copyv( &t, &w );
bli_trsv( &BLIS_ONE, a, &w );
bli_gemv( alpha, b_orig, &w, &BLIS_ZERO, &z );
}
bli_subv( &z, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
}
void libblis_test_scalv_experiment
(
test_params_t* params,
test_op_t* op,
iface_t iface,
char* dc_str,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid
)
{
unsigned int n_repeats = params->n_repeats;
unsigned int i;
double time_min = DBL_MAX;
double time;
num_t datatype;
dim_t m;
conj_t conjbeta;
obj_t beta, y;
obj_t y_save;
// Use the datatype of the first char in the datatype combination string.
bli_param_map_char_to_blis_dt( dc_str[0], &datatype );
// Map the dimension specifier to an actual dimension.
m = libblis_test_get_dim_from_prob_size( op->dim_spec[0], p_cur );
// Map parameter characters to BLIS constants.
bli_param_map_char_to_blis_conj( pc_str[0], &conjbeta );
// Create test scalars.
bli_obj_scalar_init_detached( datatype, &beta );
// Create test operands (vectors and/or matrices).
libblis_test_vobj_create( params, datatype, sc_str[0], m, &y );
libblis_test_vobj_create( params, datatype, sc_str[0], m, &y_save );
// Set beta.
if ( bli_obj_is_real( &y ) )
bli_setsc( -2.0, 0.0, &beta );
else
bli_setsc( 0.0, -2.0, &beta );
// Randomize and save y.
libblis_test_vobj_randomize( params, FALSE, &y );
bli_copyv( &y, &y_save );
// Apply the parameters.
bli_obj_set_conj( conjbeta, &beta );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
bli_copyv( &y_save, &y );
time = bli_clock();
libblis_test_scalv_impl( iface, &beta, &y );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 1.0 * m ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( &y ) ) *perf *= 6.0;
// Perform checks.
libblis_test_scalv_check( params, &beta, &y, &y_save, resid );
// Zero out performance and residual if output vector is empty.
libblis_test_check_empty_problem( &y, perf, resid );
// Free the test objects.
bli_obj_free( &y );
bli_obj_free( &y_save );
}
void libblis_test_dotxaxpyf_experiment
(
test_params_t* params,
test_op_t* op,
iface_t iface,
num_t datatype,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid
)
{
unsigned int n_repeats = params->n_repeats;
unsigned int i;
double time_min = 1e9;
double time;
dim_t m, b_n;
conj_t conjat, conja, conjw, conjx;
obj_t alpha, at, a, w, x, beta, y, z;
obj_t y_save, z_save;
cntx_t cntx;
// Initialize a context.
bli_dotxaxpyf_cntx_init( &cntx );
// Map the dimension specifier to an actual dimension.
m = libblis_test_get_dim_from_prob_size( op->dim_spec[0], p_cur );
// Query the operation's fusing factor for the current datatype.
b_n = bli_cntx_get_blksz_def_dt( datatype, BLIS_XF, &cntx );
// Store the fusing factor so that the driver can retrieve the value
// later when printing results.
op->dim_aux[0] = b_n;
// Map parameter characters to BLIS constants.
bli_param_map_char_to_blis_conj( pc_str[0], &conjat );
bli_param_map_char_to_blis_conj( pc_str[1], &conja );
bli_param_map_char_to_blis_conj( pc_str[2], &conjw );
bli_param_map_char_to_blis_conj( pc_str[3], &conjx );
// Create test scalars.
bli_obj_scalar_init_detached( datatype, &alpha );
bli_obj_scalar_init_detached( datatype, &beta );
// Create test operands (vectors and/or matrices).
libblis_test_mobj_create( params, datatype, BLIS_NO_TRANSPOSE,
sc_str[0], m, b_n, &a );
libblis_test_vobj_create( params, datatype, sc_str[1], m, &w );
libblis_test_vobj_create( params, datatype, sc_str[2], b_n, &x );
libblis_test_vobj_create( params, datatype, sc_str[3], b_n, &y );
libblis_test_vobj_create( params, datatype, sc_str[3], b_n, &y_save );
libblis_test_vobj_create( params, datatype, sc_str[4], m, &z );
libblis_test_vobj_create( params, datatype, sc_str[4], m, &z_save );
// Set alpha.
if ( bli_obj_is_real( y ) )
{
bli_setsc( 1.2, 0.0, &alpha );
bli_setsc( -1.0, 0.0, &beta );
}
else
{
bli_setsc( 1.2, 0.1, &alpha );
bli_setsc( -1.0, -0.1, &beta );
}
// Randomize A, w, x, y, and z, and save y and z.
libblis_test_mobj_randomize( params, FALSE, &a );
libblis_test_vobj_randomize( params, FALSE, &w );
libblis_test_vobj_randomize( params, FALSE, &x );
libblis_test_vobj_randomize( params, FALSE, &y );
libblis_test_vobj_randomize( params, FALSE, &z );
bli_copyv( &y, &y_save );
bli_copyv( &z, &z_save );
// Create an alias to a for at. (Note that it should NOT actually be
// marked for transposition since the transposition is part of the dotxf
// subproblem.)
bli_obj_alias_to( a, at );
// Apply the parameters.
bli_obj_set_conj( conjat, at );
bli_obj_set_conj( conja, a );
bli_obj_set_conj( conjw, w );
bli_obj_set_conj( conjx, x );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
bli_copyv( &y_save, &y );
bli_copyv( &z_save, &z );
time = bli_clock();
libblis_test_dotxaxpyf_impl( iface,
&alpha, &at, &a, &w, &x, &beta, &y, &z,
&cntx );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 2.0 * m * b_n + 2.0 * m * b_n ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( y ) ) *perf *= 4.0;
// Perform checks.
libblis_test_dotxaxpyf_check( params, &alpha, &at, &a, &w, &x, &beta, &y, &z, &y_save, &z_save, resid );
// Zero out performance and residual if either output vector is empty.
libblis_test_check_empty_problem( &y, perf, resid );
libblis_test_check_empty_problem( &z, perf, resid );
// Free the test objects.
bli_obj_free( &a );
bli_obj_free( &w );
bli_obj_free( &x );
bli_obj_free( &y );
bli_obj_free( &z );
bli_obj_free( &y_save );
bli_obj_free( &z_save );
// Finalize the context.
bli_dotxaxpyf_cntx_finalize( &cntx );
}
void libblis_test_gemm_check
(
test_params_t* params,
obj_t* alpha,
obj_t* a,
obj_t* b,
obj_t* beta,
obj_t* c,
obj_t* c_orig,
double* resid
)
{
num_t dt = bli_obj_dt( c );
num_t dt_real = bli_obj_dt_proj_to_real( c );
dim_t m = bli_obj_length( c );
dim_t n = bli_obj_width( c );
dim_t k = bli_obj_width_after_trans( a );
obj_t norm;
obj_t t, v, w, z;
double junk;
//
// Pre-conditions:
// - a is randomized.
// - b is randomized.
// - c_orig is randomized.
// Note:
// - alpha and beta should have non-zero imaginary components in the
// complex cases in order to more fully exercise the implementation.
//
// Under these conditions, we assume that the implementation for
//
// C := beta * C_orig + alpha * transa(A) * transb(B)
//
// is functioning correctly if
//
// normf( v - z )
//
// is negligible, where
//
// v = C * t
// z = ( beta * C_orig + alpha * transa(A) * transb(B) ) * t
// = beta * C_orig * t + alpha * transa(A) * transb(B) * t
// = beta * C_orig * t + alpha * transa(A) * w
// = beta * C_orig * t + z
//
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, n, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, k, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
libblis_test_vobj_randomize( params, TRUE, &t );
bli_gemv( &BLIS_ONE, c, &t, &BLIS_ZERO, &v );
bli_gemv( &BLIS_ONE, b, &t, &BLIS_ZERO, &w );
bli_gemv( alpha, a, &w, &BLIS_ZERO, &z );
bli_gemv( beta, c_orig, &t, &BLIS_ONE, &z );
bli_subv( &z, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
}
void libblis_test_her2k_check
(
test_params_t* params,
obj_t* alpha,
obj_t* a,
obj_t* b,
obj_t* beta,
obj_t* c,
obj_t* c_orig,
double* resid
)
{
num_t dt = bli_obj_datatype( *c );
num_t dt_real = bli_obj_datatype_proj_to_real( *c );
dim_t m = bli_obj_length( *c );
dim_t k = bli_obj_width_after_trans( *a );
obj_t alphac, ah, bh;
obj_t norm;
obj_t t, v, w1, w2, z;
double junk;
//
// Pre-conditions:
// - a is randomized.
// - b is randomized.
// - c_orig is randomized and Hermitian.
// Note:
// - alpha should have a non-zero imaginary component in the
// complex cases in order to more fully exercise the implementation.
// - beta must be real-valued.
//
// Under these conditions, we assume that the implementation for
//
// C := beta * C_orig + alpha * transa(A) * transb(B)^H + conj(alpha) * transb(B) * transa(A)^H
//
// is functioning correctly if
//
// normf( v - z )
//
// is negligible, where
//
// v = C * t
// z = ( beta * C_orig + alpha * transa(A) * transb(B)^H + conj(alpha) * transb(B) * transa(A)^H ) * t
// = beta * C_orig * t + alpha * transa(A) * transb(B)^H * t + conj(alpha) * transb(B) * transa(A)^H * t
// = beta * C_orig * t + alpha * transa(A) * transb(B)^H * t + conj(alpha) * transb(B) * w2
// = beta * C_orig * t + alpha * transa(A) * w1 + conj(alpha) * transb(B) * w2
// = beta * C_orig * t + alpha * transa(A) * w1 + z
// = beta * C_orig * t + z
//
bli_obj_alias_with_trans( BLIS_CONJ_TRANSPOSE, *a, ah );
bli_obj_alias_with_trans( BLIS_CONJ_TRANSPOSE, *b, bh );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_scalar_init_detached_copy_of( dt, BLIS_CONJUGATE, alpha, &alphac );
bli_obj_create( dt, m, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, k, 1, 0, 0, &w1 );
bli_obj_create( dt, k, 1, 0, 0, &w2 );
bli_obj_create( dt, m, 1, 0, 0, &z );
libblis_test_vobj_randomize( params, TRUE, &t );
bli_hemv( &BLIS_ONE, c, &t, &BLIS_ZERO, &v );
bli_gemv( &BLIS_ONE, &ah, &t, &BLIS_ZERO, &w2 );
bli_gemv( &BLIS_ONE, &bh, &t, &BLIS_ZERO, &w1 );
bli_gemv( alpha, a, &w1, &BLIS_ZERO, &z );
bli_gemv( &alphac, b, &w2, &BLIS_ONE, &z );
bli_hemv( beta, c_orig, &t, &BLIS_ONE, &z );
bli_subv( &z, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w1 );
bli_obj_free( &w2 );
bli_obj_free( &z );
}
void libblis_test_ger_check
(
test_params_t* params,
obj_t* alpha,
obj_t* x,
obj_t* y,
obj_t* a,
obj_t* a_orig,
double* resid
)
{
num_t dt = bli_obj_dt( a );
num_t dt_real = bli_obj_dt_proj_to_real( a );
dim_t m_a = bli_obj_length( a );
dim_t n_a = bli_obj_width( a );
obj_t t, v, w;
obj_t rho, norm;
double junk;
//
// Pre-conditions:
// - x is randomized.
// - y is randomized.
// - a is identity.
// Note:
// - alpha should have a non-zero imaginary component in the
// complex cases in order to more fully exercise the implementation.
//
// Under these conditions, we assume that the implementation for
//
// A := A_orig + alpha * conjx(x) * conjy(y)
//
// is functioning correctly if
//
// normf( v - w )
//
// is negligible, where
//
// v = A * t
// w = ( A_orig + alpha * conjx(x) * conjy(y)^T ) * t
// = A_orig * t + alpha * conjx(x) * conjy(y)^T * t
// = A_orig * t + alpha * conjx(x) * rho
// = A_orig * t + w
//
bli_obj_scalar_init_detached( dt, &rho );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, n_a, 1, 0, 0, &t );
bli_obj_create( dt, m_a, 1, 0, 0, &v );
bli_obj_create( dt, m_a, 1, 0, 0, &w );
libblis_test_vobj_randomize( params, TRUE, &t );
bli_gemv( &BLIS_ONE, a, &t, &BLIS_ZERO, &v );
bli_dotv( y, &t, &rho );
bli_mulsc( alpha, &rho );
bli_scal2v( &rho, x, &w );
bli_gemv( &BLIS_ONE, a_orig, &t, &BLIS_ONE, &w );
bli_subv( &w, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
}
void libblis_test_gemm_md_check
(
test_params_t* params,
obj_t* alpha,
obj_t* a,
obj_t* b,
obj_t* beta,
obj_t* c,
obj_t* c_orig,
double* resid
)
{
num_t dt_real = bli_obj_dt_proj_to_real( c );
num_t dt_comp = bli_obj_dt_proj_to_complex( c );
num_t dt;
dim_t m = bli_obj_length( c );
dim_t n = bli_obj_width( c );
dim_t k = bli_obj_width_after_trans( a );
obj_t norm;
obj_t t, v, w, z;
double junk;
// Compute our reference checksum in the real domain if all operands
// are real, and in the complex domain otherwise. Also implicit in this
// is that we use the storage precision of C to determine the precision
// in which we perform the reference checksum.
if ( bli_obj_is_real( a ) &&
bli_obj_is_real( b ) &&
bli_obj_is_real( c ) ) dt = dt_real;
else dt = dt_comp;
// This function works in a manner similar to that of the function
// libblis_test_gemm_check(), except that we project a, b, and c into
// the complex domain (regardless of their storage datatype), and then
// proceed with the checking accordingly.
obj_t a2, b2, c2, c0;
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, n, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, k, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
libblis_test_vobj_randomize( params, TRUE, &t );
// We need to zero out the imaginary part of t in order for our
// checks to work in all cases. Otherwise, the imaginary parts
// could affect intermediate products, depending on the order that
// they are executed.
bli_setiv( &BLIS_ZERO, &t );
// Create complex equivalents of a, b, c_orig, and c.
bli_obj_create( dt, m, k, 0, 0, &a2 );
bli_obj_create( dt, k, n, 0, 0, &b2 );
bli_obj_create( dt, m, n, 0, 0, &c2 );
bli_obj_create( dt, m, n, 0, 0, &c0 );
// Cast a, b, c_orig, and c into the datatype of our temporary objects.
bli_castm( a, &a2 );
bli_castm( b, &b2 );
bli_castm( c_orig, &c2 );
bli_castm( c, &c0 );
bli_gemv( &BLIS_ONE, &c0, &t, &BLIS_ZERO, &v );
#if 0
if ( bli_obj_is_scomplex( c ) &&
bli_obj_is_float( a ) &&
bli_obj_is_float( b ) )
{
bli_printm( "test_gemm.c: a", a, "%7.3f", "" );
bli_printm( "test_gemm.c: b", b, "%7.3f", "" );
bli_printm( "test_gemm.c: c orig", c_orig, "%7.3f", "" );
bli_printm( "test_gemm.c: c computed", c, "%7.3f", "" );
}
#endif
#if 0
bli_gemm( alpha, &a2, &b2, beta, &c2 );
bli_gemv( &BLIS_ONE, &c2, &t, &BLIS_ZERO, &z );
if ( bli_obj_is_real( c ) ) bli_setiv( &BLIS_ZERO, &z );
#else
bli_gemv( &BLIS_ONE, &b2, &t, &BLIS_ZERO, &w );
bli_gemv( alpha, &a2, &w, &BLIS_ZERO, &z );
bli_gemv( beta, &c2, &t, &BLIS_ONE, &z );
if ( bli_obj_is_real( c ) ) bli_setiv( &BLIS_ZERO, &z );
#endif
bli_subv( &z, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
bli_obj_free( &a2 );
bli_obj_free( &b2 );
bli_obj_free( &c2 );
bli_obj_free( &c0 );
}
void libblis_test_ger_experiment
(
test_params_t* params,
test_op_t* op,
iface_t iface,
num_t datatype,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid
)
{
unsigned int n_repeats = params->n_repeats;
unsigned int i;
double time_min = DBL_MAX;
double time;
dim_t m, n;
conj_t conjx, conjy;
obj_t alpha, x, y, a;
obj_t a_save;
// Map the dimension specifier to actual dimensions.
m = libblis_test_get_dim_from_prob_size( op->dim_spec[0], p_cur );
n = libblis_test_get_dim_from_prob_size( op->dim_spec[1], p_cur );
// Map parameter characters to BLIS constants.
bli_param_map_char_to_blis_conj( pc_str[0], &conjx );
bli_param_map_char_to_blis_conj( pc_str[1], &conjy );
// Create test scalars.
bli_obj_scalar_init_detached( datatype, &alpha );
// Create test operands (vectors and/or matrices).
libblis_test_vobj_create( params, datatype,
sc_str[0], m, &x );
libblis_test_vobj_create( params, datatype,
sc_str[1], n, &y );
libblis_test_mobj_create( params, datatype, BLIS_NO_TRANSPOSE,
sc_str[2], m, n, &a );
libblis_test_mobj_create( params, datatype, BLIS_NO_TRANSPOSE,
sc_str[2], m, n, &a_save );
// Set alpha.
if ( bli_obj_is_real( &a ) )
bli_setsc( -1.0, 1.0, &alpha );
else
bli_setsc( -1.0, 1.0, &alpha );
// Randomize x and y.
libblis_test_vobj_randomize( params, TRUE, &x );
libblis_test_vobj_randomize( params, TRUE, &y );
// Initialize A to identity and save.
bli_setm( &BLIS_ZERO, &a );
bli_setd( &BLIS_ONE, &a );
bli_copym( &a, &a_save );
// Apply the parameters.
bli_obj_set_conj( conjx, &x );
bli_obj_set_conj( conjy, &y );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
bli_copym( &a_save, &a );
time = bli_clock();
libblis_test_ger_impl( iface, &alpha, &x, &y, &a );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 2.0 * m * n ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( &a ) ) *perf *= 4.0;
// Perform checks.
libblis_test_ger_check( params, &alpha, &x, &y, &a, &a_save, resid );
// Zero out performance and residual if output matrix is empty.
libblis_test_check_empty_problem( &a, perf, resid );
// Free the test objects.
bli_obj_free( &x );
bli_obj_free( &y );
bli_obj_free( &a );
bli_obj_free( &a_save );
}
void libblis_test_amaxv_experiment
(
test_params_t* params,
test_op_t* op,
iface_t iface,
num_t datatype,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid
)
{
unsigned int n_repeats = params->n_repeats;
unsigned int i;
double time_min = DBL_MAX;
double time;
dim_t m;
obj_t x;
obj_t index;
// Map the dimension specifier to an actual dimension.
m = libblis_test_get_dim_from_prob_size( op->dim_spec[0], p_cur );
// Map parameter characters to BLIS constants.
// Create test scalars.
bli_obj_scalar_init_detached( BLIS_INT, &index );
// Create test operands (vectors and/or matrices).
libblis_test_vobj_create( params, datatype, sc_str[0], m, &x );
// Randomize x.
libblis_test_vobj_randomize( params, FALSE, &x );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
time = bli_clock();
libblis_test_amaxv_impl( iface, &x, &index );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 1.0 * m ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( x ) ) *perf *= 2.0;
// Perform checks.
libblis_test_amaxv_check( params, &x, &index, resid );
// Zero out performance and residual if input vector is empty.
libblis_test_check_empty_problem( &x, perf, resid );
// Free the test objects.
bli_obj_free( &x );
}
void libblis_test_trsv_experiment
(
test_params_t* params,
test_op_t* op,
iface_t iface,
num_t datatype,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid
)
{
unsigned int n_repeats = params->n_repeats;
unsigned int i;
double time_min = DBL_MAX;
double time;
dim_t m;
uplo_t uploa;
trans_t transa;
diag_t diaga;
obj_t alpha, a, x;
obj_t x_save;
// Map the dimension specifier to an actual dimension.
m = libblis_test_get_dim_from_prob_size( op->dim_spec[0], p_cur );
// Map parameter characters to BLIS constants.
bli_param_map_char_to_blis_uplo( pc_str[0], &uploa );
bli_param_map_char_to_blis_trans( pc_str[1], &transa );
bli_param_map_char_to_blis_diag( pc_str[2], &diaga );
// Create test scalars.
bli_obj_scalar_init_detached( datatype, &alpha );
// Create test operands (vectors and/or matrices).
libblis_test_mobj_create( params, datatype, BLIS_NO_TRANSPOSE,
sc_str[0], m, m, &a );
libblis_test_vobj_create( params, datatype,
sc_str[1], m, &x );
libblis_test_vobj_create( params, datatype,
sc_str[1], m, &x_save );
// Set alpha.
if ( bli_obj_is_real( x ) )
bli_setsc( 2.0, 0.0, &alpha );
else
bli_setsc( 2.0, -1.0, &alpha );
// Set the structure and uplo properties of A.
bli_obj_set_struc( BLIS_TRIANGULAR, a );
bli_obj_set_uplo( uploa, a );
// Randomize A, load the diagonal, make it densely triangular.
libblis_test_mobj_randomize( params, TRUE, &a );
libblis_test_mobj_load_diag( params, &a );
bli_mktrim( &a );
// Randomize x and save.
libblis_test_vobj_randomize( params, TRUE, &x );
bli_copyv( &x, &x_save );
// Apply the remaining parameters.
bli_obj_set_conjtrans( transa, a );
bli_obj_set_diag( diaga, a );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
bli_copym( &x_save, &x );
time = bli_clock();
libblis_test_trsv_impl( iface, &alpha, &a, &x );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 1.0 * m * m ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( x ) ) *perf *= 4.0;
// Perform checks.
libblis_test_trsv_check( params, &alpha, &a, &x, &x_save, resid );
// Zero out performance and residual if output vector is empty.
libblis_test_check_empty_problem( &x, perf, resid );
// Free the test objects.
bli_obj_free( &a );
bli_obj_free( &x );
bli_obj_free( &x_save );
}
void libblis_test_herk_check
(
test_params_t* params,
obj_t* alpha,
obj_t* a,
obj_t* beta,
obj_t* c,
obj_t* c_orig,
double* resid
)
{
num_t dt = bli_obj_datatype( *c );
num_t dt_real = bli_obj_datatype_proj_to_real( *c );
dim_t m = bli_obj_length( *c );
dim_t k = bli_obj_width_after_trans( *a );
obj_t ah;
obj_t norm;
obj_t t, v, w, z;
double junk;
//
// Pre-conditions:
// - a is randomized.
// - c_orig is randomized and Hermitian.
// Note:
// - alpha and beta must be real-valued.
//
// Under these conditions, we assume that the implementation for
//
// C := beta * C_orig + alpha * transa(A) * transa(A)^H
//
// is functioning correctly if
//
// normf( v - z )
//
// is negligible, where
//
// v = C * t
// z = ( beta * C_orig + alpha * transa(A) * transa(A)^H ) * t
// = beta * C_orig * t + alpha * transa(A) * transa(A)^H * t
// = beta * C_orig * t + alpha * transa(A) * w
// = beta * C_orig * t + z
//
bli_obj_alias_with_trans( BLIS_CONJ_TRANSPOSE, *a, ah );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, k, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
libblis_test_vobj_randomize( params, TRUE, &t );
bli_hemv( &BLIS_ONE, c, &t, &BLIS_ZERO, &v );
bli_gemv( &BLIS_ONE, &ah, &t, &BLIS_ZERO, &w );
bli_gemv( alpha, a, &w, &BLIS_ZERO, &z );
bli_hemv( beta, c_orig, &t, &BLIS_ONE, &z );
bli_subv( &z, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
}
void libblis_test_gemv_experiment
(
test_params_t* params,
test_op_t* op,
iface_t iface,
char* dc_str,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid
)
{
unsigned int n_repeats = params->n_repeats;
unsigned int i;
double time_min = DBL_MAX;
double time;
num_t datatype;
dim_t m, n;
trans_t transa;
conj_t conjx;
obj_t kappa;
obj_t alpha, a, x, beta, y;
obj_t y_save;
// Use the datatype of the first char in the datatype combination string.
bli_param_map_char_to_blis_dt( dc_str[0], &datatype );
// Map the dimension specifier to actual dimensions.
m = libblis_test_get_dim_from_prob_size( op->dim_spec[0], p_cur );
n = libblis_test_get_dim_from_prob_size( op->dim_spec[1], p_cur );
// Map parameter characters to BLIS constants.
bli_param_map_char_to_blis_trans( pc_str[0], &transa );
bli_param_map_char_to_blis_conj( pc_str[1], &conjx );
// Create test scalars.
bli_obj_scalar_init_detached( datatype, &kappa );
bli_obj_scalar_init_detached( datatype, &alpha );
bli_obj_scalar_init_detached( datatype, &beta );
// Create test operands (vectors and/or matrices).
libblis_test_mobj_create( params, datatype, transa,
sc_str[0], m, n, &a );
libblis_test_vobj_create( params, datatype,
sc_str[1], n, &x );
libblis_test_vobj_create( params, datatype,
sc_str[2], m, &y );
libblis_test_vobj_create( params, datatype,
sc_str[2], m, &y_save );
// Set alpha and beta.
if ( bli_obj_is_real( &y ) )
{
bli_setsc( 2.0, 0.0, &alpha );
bli_setsc( -1.0, 0.0, &beta );
}
else
{
bli_setsc( 1.0, 2.0, &alpha );
bli_setsc( 1.0, -1.0, &beta );
}
// Initialize diagonal of matrix A.
bli_setsc( 2.0, -1.0, &kappa );
bli_setm( &BLIS_ZERO, &a );
bli_setd( &kappa, &a );
// Randomize x and y, and save y.
libblis_test_vobj_randomize( params, TRUE, &x );
libblis_test_vobj_randomize( params, TRUE, &y );
bli_copyv( &y, &y_save );
// Apply the parameters.
bli_obj_set_conjtrans( transa, &a );
bli_obj_set_conj( conjx, &x );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
bli_copym( &y_save, &y );
time = bli_clock();
libblis_test_gemv_impl( iface, &alpha, &a, &x, &beta, &y );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 2.0 * m * n ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( &y ) ) *perf *= 4.0;
// Perform checks.
libblis_test_gemv_check( params, &kappa, &alpha, &a, &x, &beta, &y, &y_save, resid );
// Zero out performance and residual if output vector is empty.
libblis_test_check_empty_problem( &y, perf, resid );
// Free the test objects.
bli_obj_free( &a );
bli_obj_free( &x );
bli_obj_free( &y );
bli_obj_free( &y_save );
}
