void libblis_test_setv_impl( mt_impl_t impl,
obj_t* beta,
obj_t* x )
{
switch ( impl )
{
case BLIS_TEST_SEQ_FRONT_END:
bli_setv( beta, x );
break;
default:
libblis_test_printf_error( "Invalid implementation type.\n" );
}
}
void libblis_test_setv_impl( iface_t iface,
obj_t* beta,
obj_t* x )
{
switch ( iface )
{
case BLIS_TEST_SEQ_FRONT_END:
bli_setv( beta, x );
break;
default:
libblis_test_printf_error( "Invalid interface type.\n" );
}
}
int main( int argc, char** argv )
{
obj_t alpha, beta, gamma;
obj_t x, y, z, w, a;
num_t dt;
dim_t m, n;
inc_t rs, cs;
//
// This file demonstrates working with vector objects and the level-1v
// operations.
//
//
// Example 1: Create vector objects and then broadcast (copy) scalar
// values to all elements.
//
printf( "\n#\n# -- Example 1 --\n#\n\n" );
// Create a few vectors to work with. We make them all of the same length
// so that we can perform operations between them.
// NOTE: We've chosen to use row vectors here (1x4) instead of column
// vectors (4x1) to allow for easier reading of standard output (less
// scrolling).
dt = BLIS_DOUBLE;
m = 1; n = 4; rs = 0; cs = 0;
bli_obj_create( dt, m, n, rs, cs, &x );
bli_obj_create( dt, m, n, rs, cs, &y );
bli_obj_create( dt, m, n, rs, cs, &z );
bli_obj_create( dt, m, n, rs, cs, &w );
bli_obj_create( dt, m, n, rs, cs, &a );
// Let's also create and initialize some scalar objects.
bli_obj_create_1x1( dt, &alpha );
bli_obj_create_1x1( dt, &beta );
bli_obj_create_1x1( dt, &gamma );
bli_setsc( 2.0, 0.0, &alpha );
bli_setsc( 0.2, 0.0, &beta );
bli_setsc( 3.0, 0.0, &gamma );
bli_printm( "alpha:", &alpha, "%4.1f", "" );
bli_printm( "beta:", &beta, "%4.1f", "" );
bli_printm( "gamma:", &gamma, "%4.1f", "" );
// Vectors can set by "broadcasting" a constant to every element.
bli_setv( &BLIS_ONE, &x );
bli_setv( &alpha, &y );
bli_setv( &BLIS_ZERO, &z );
// Note that we can use printv or printm to print vectors since vectors
// are also matrices. We choose to use printm because it honors the
// orientation of the vector (row or column) when printing, whereas
// printv always prints vectors as column vectors regardless of their
// they are 1 x n or n x 1.
bli_printm( "x := 1.0", &x, "%4.1f", "" );
bli_printm( "y := alpha", &y, "%4.1f", "" );
bli_printm( "z := 0.0", &z, "%4.1f", "" );
//
// Example 2: Randomize a vector object.
//
printf( "\n#\n# -- Example 2 --\n#\n\n" );
// Set a vector to random values.
bli_randv( &w );
bli_printm( "w := randv()", &w, "%4.1f", "" );
//
// Example 3: Perform various element-wise operations on vector objects.
//
printf( "\n#\n# -- Example 3 --\n#\n\n" );
// Copy a vector.
bli_copyv( &w, &a );
bli_printm( "a := w", &a, "%4.1f", "" );
// Add and subtract vectors.
bli_addv( &y, &a );
bli_printm( "a := a + y", &a, "%4.1f", "" );
bli_subv( &w, &a );
bli_printm( "a := a - w", &a, "%4.1f", "" );
// Scale a vector (destructive).
bli_scalv( &beta, &a );
bli_printm( "a := beta * a", &a, "%4.1f", "" );
// Scale a vector (non-destructive).
bli_scal2v( &gamma, &a, &z );
bli_printm( "z := gamma * a", &z, "%4.1f", "" );
// Scale and accumulate between vectors.
bli_axpyv( &alpha, &w, &x );
bli_printm( "x := x + alpha * w", &x, "%4.1f", "" );
bli_xpbyv( &w, &BLIS_MINUS_ONE, &x );
bli_printm( "x := -1.0 * x + w", &x, "%4.1f", "" );
// Invert a vector element-wise.
bli_invertv( &y );
bli_printm( "y := 1 / y", &y, "%4.1f", "" );
// Swap two vectors.
bli_swapv( &x, &y );
bli_printm( "x (after swapping with y)", &x, "%4.1f", "" );
bli_printm( "y (after swapping with x)", &y, "%4.1f", "" );
//
// Example 4: Perform contraction-like operations on vector objects.
//
printf( "\n#\n# -- Example 4 --\n#\n\n" );
// Perform a dot product.
bli_dotv( &a, &z, &gamma );
bli_printm( "gamma := a * z (dot product)", &gamma, "%5.2f", "" );
// Perform an extended dot product.
bli_dotxv( &alpha, &a, &z, &BLIS_ONE, &gamma );
bli_printm( "gamma := 1.0 * gamma + alpha * a * z (accumulate scaled dot product)", &gamma, "%5.2f", "" );
// Free the objects.
bli_obj_free( &alpha );
bli_obj_free( &beta );
bli_obj_free( &gamma );
bli_obj_free( &x );
bli_obj_free( &y );
bli_obj_free( &z );
bli_obj_free( &w );
bli_obj_free( &a );
return 0;
}
void libblis_test_syr2_check( obj_t* alpha,
obj_t* x,
obj_t* y,
obj_t* a,
obj_t* a_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *a );
num_t dt_real = bli_obj_datatype_proj_to_real( *a );
dim_t m_a = bli_obj_length( *a );
obj_t xt, yt;
obj_t t, v, w1, w2;
obj_t tau, rho, norm;
double junk;
//
// Pre-conditions:
// - x is randomized.
// - y is randomized.
// - a is randomized and symmetric.
// 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)^T + alpha * conjy(y) * conjx(x)^T
//
// is functioning correctly if
//
// normf( v - w )
//
// is negligible, where
//
// v = A * t
// w = ( A_orig + alpha * conjx(x) * conjy(y)^T + alpha * conjy(y) * conjx(x)^T ) * t
// = A_orig * t + alpha * conjx(x) * conjy(y)^T * t + alpha * conjy(y) * conjx(x)^T * t
// = A_orig * t + alpha * conjx(x) * conjy(y)^T * t + alpha * conjy(y) * rho
// = A_orig * t + alpha * conjx(x) * conjy(y)^T * t + w1
// = A_orig * t + alpha * conjx(x) * rho + w1
// = A_orig * t + w2 + w1
//
bli_mksymm( a );
bli_mksymm( a_orig );
bli_obj_set_struc( BLIS_GENERAL, *a );
bli_obj_set_struc( BLIS_GENERAL, *a_orig );
bli_obj_set_uplo( BLIS_DENSE, *a );
bli_obj_set_uplo( BLIS_DENSE, *a_orig );
bli_obj_scalar_init_detached( dt, &tau );
bli_obj_scalar_init_detached( dt, &rho );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m_a, 1, 0, 0, &t );
bli_obj_create( dt, m_a, 1, 0, 0, &v );
bli_obj_create( dt, m_a, 1, 0, 0, &w1 );
bli_obj_create( dt, m_a, 1, 0, 0, &w2 );
bli_obj_alias_to( *x, xt );
bli_obj_alias_to( *y, yt );
bli_setsc( 1.0/( double )m_a, -1.0/( double )m_a, &tau );
bli_setv( &tau, &t );
bli_gemv( &BLIS_ONE, a, &t, &BLIS_ZERO, &v );
bli_dotv( &xt, &t, &rho );
bli_mulsc( alpha, &rho );
bli_scal2v( &rho, y, &w1 );
bli_dotv( &yt, &t, &rho );
bli_mulsc( alpha, &rho );
bli_scal2v( &rho, x, &w2 );
bli_addv( &w2, &w1 );
bli_gemv( &BLIS_ONE, a_orig, &t, &BLIS_ONE, &w1 );
bli_subv( &w1, &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 );
}
void libblis_test_fnormv_experiment( test_params_t* params,
test_op_t* op,
mt_impl_t impl,
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;
num_t dt_real = bli_datatype_proj_to_real( datatype );
double time_min = 1e9;
double time;
dim_t m;
obj_t beta, norm;
obj_t x;
// 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( datatype, &beta );
bli_obj_scalar_init_detached( dt_real, &norm );
// Create test operands (vectors and/or matrices).
libblis_test_vobj_create( params, datatype, sc_str[0], m, &x );
// Initialize beta to 2 - 2i.
bli_setsc( 2.0, -2.0, &beta );
// Set all elements of x to beta.
bli_setv( &beta, &x );
// Repeat the experiment n_repeats times and record results.
for ( i = 0; i < n_repeats; ++i )
{
time = bli_clock();
libblis_test_fnormv_impl( impl, &x, &norm );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 2.0 * m ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( x ) ) *perf *= 2.0;
// Perform checks.
libblis_test_fnormv_check( &beta, &x, &norm, 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_addv_experiment( test_params_t* params,
test_op_t* op,
mt_impl_t impl,
num_t datatype,
char* pc_str,
char* sc_str,
unsigned int p_cur,
double* perf,
double* resid )
{
double time_min = 1e9;
double time;
dim_t m;
conj_t conjx;
obj_t alpha, beta;
obj_t x, y;
// 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], &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_vobj_create( params, datatype, sc_str[0], m, &x );
libblis_test_vobj_create( params, datatype, sc_str[1], m, &y );
// Initialize alpha and beta.
bli_setsc( -1.0, -1.0, &alpha );
bli_setsc( 3.0, 3.0, &beta );
// Set x and y to alpha and beta, respectively.
bli_setv( &alpha, &x );
bli_setv( &beta, &y );
// Apply the parameters.
bli_obj_set_conj( conjx, x );
// Disable repeats since bli_copyv() is not yet tested.
//for ( i = 0; i < n_repeats; ++i )
{
time = bli_clock();
libblis_test_addv_impl( impl, &x, &y );
time_min = bli_clock_min_diff( time_min, time );
}
// Estimate the performance of the best experiment repeat.
*perf = ( 2.0 * m ) / time_min / FLOPS_PER_UNIT_PERF;
if ( bli_obj_is_complex( x ) ) *perf *= 2.0;
// Perform checks.
libblis_test_addv_check( &alpha, &beta, &x, &y, 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( &x );
bli_obj_free( &y );
}
void libblis_test_her_check( obj_t* alpha,
obj_t* x,
obj_t* a,
obj_t* a_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *a );
num_t dt_real = bli_obj_datatype_proj_to_real( *a );
dim_t m_a = bli_obj_length( *a );
obj_t xh, t, v, w;
obj_t tau, rho, norm;
double junk;
//
// Pre-conditions:
// - x is randomized.
// - a is randomized and Hermitian.
// Note:
// - alpha must be real-valued.
//
// Under these conditions, we assume that the implementation for
//
// A := A_orig + alpha * conjx(x) * conjx(x)^H
//
// is functioning correctly if
//
// normf( v - w )
//
// is negligible, where
//
// v = A * t
// w = ( A_orig + alpha * conjx(x) * conjx(x)^H ) * t
// = A_orig * t + alpha * conjx(x) * conjx(x)^H * t
// = A_orig * t + alpha * conjx(x) * rho
// = A_orig * t + w
//
bli_mkherm( a );
bli_mkherm( a_orig );
bli_obj_set_struc( BLIS_GENERAL, *a );
bli_obj_set_struc( BLIS_GENERAL, *a_orig );
bli_obj_set_uplo( BLIS_DENSE, *a );
bli_obj_set_uplo( BLIS_DENSE, *a_orig );
bli_obj_scalar_init_detached( dt, &tau );
bli_obj_scalar_init_detached( dt, &rho );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m_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 );
bli_obj_alias_with_conj( BLIS_CONJUGATE, *x, xh );
bli_setsc( 1.0/( double )m_a, -1.0/( double )m_a, &tau );
bli_setv( &tau, &t );
bli_gemv( &BLIS_ONE, a, &t, &BLIS_ZERO, &v );
bli_dotv( &xh, &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_ger_check( obj_t* alpha,
obj_t* x,
obj_t* y,
obj_t* a,
obj_t* a_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *a );
num_t dt_real = bli_obj_datatype_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 tau, 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, &tau );
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 );
bli_setsc( 1.0/( double )n_a, -1.0/( double )n_a, &tau );
bli_setv( &tau, &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 );
}
