void bli_unpackv_unb_var1( obj_t* p,
obj_t* c,
unpackv_t* cntl )
{
num_t dt_pc = bli_obj_datatype( *p );
dim_t dim_c = bli_obj_vector_dim( *c );
void* buf_p = bli_obj_buffer_at_off( *p );
inc_t incp = bli_obj_vector_inc( *p );
void* buf_c = bli_obj_buffer_at_off( *c );
inc_t incc = bli_obj_vector_inc( *c );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_pc];
// Invoke the function.
f( dim_c,
buf_p, incp,
buf_c, incc );
}
void bli_norm1m_unb_var1( obj_t* x,
obj_t* norm )
{
num_t dt_x = bli_obj_datatype( *x );
doff_t diagoffx = bli_obj_diag_offset( *x );
uplo_t diagx = bli_obj_diag( *x );
uplo_t uplox = bli_obj_uplo( *x );
dim_t m = bli_obj_length( *x );
dim_t n = bli_obj_width( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t rs_x = bli_obj_row_stride( *x );
inc_t cs_x = bli_obj_col_stride( *x );
void* buf_norm = bli_obj_buffer_at_off( *norm );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x];
// Invoke the function.
f( diagoffx,
diagx,
uplox,
m,
n,
buf_x, rs_x, cs_x,
buf_norm );
}
void bli_dotv_opt_var1( obj_t* x,
obj_t* y,
obj_t* rho )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
num_t dt_rho = bli_obj_datatype( *rho );
conj_t conjx = bli_obj_conj_status( *x );
conj_t conjy = bli_obj_conj_status( *y );
dim_t n = bli_obj_vector_dim( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
void* buf_rho = bli_obj_buffer_at_off( *rho );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x][dt_y][dt_rho];
// Invoke the function.
f( conjx,
conjy,
n,
buf_x, inc_x,
buf_y, inc_y,
buf_rho );
}
void bli_unzipsc_unb_var1( obj_t* beta,
obj_t* chi_r,
obj_t* chi_i )
{
num_t dt_beta;
num_t dt_chi_c = bli_obj_datatype_proj_to_complex( *chi_r );
void* buf_beta;
void* buf_chi_r = bli_obj_buffer_at_off( *chi_r );
void* buf_chi_i = bli_obj_buffer_at_off( *chi_i );
FUNCPTR_T f;
// If beta is a scalar constant, use dt_chi_c to extract the address of the
// corresponding constant value; otherwise, use the datatype encoded
// within the beta object and extract the buffer at the beta offset.
bli_set_scalar_dt_buffer( beta, dt_chi_c, dt_beta, buf_beta );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_beta];
// Invoke the function.
f( buf_beta,
buf_chi_r,
buf_chi_i );
}
//
// Define object-based interface.
//
void bli_addv( obj_t* x,
obj_t* y )
{
num_t dt = bli_obj_datatype( *x );
conj_t conjx = bli_obj_conj_status( *x );
dim_t n = bli_obj_vector_dim( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
FUNCPTR_T f = ftypes[dt];
if ( bli_error_checking_is_enabled() )
bli_addv_check( x, y );
// Invoke the void pointer-based function.
f( conjx,
n,
buf_x, inc_x,
buf_y, inc_y );
}
void bli_packv_unb_var1( obj_t* c,
obj_t* p,
cntx_t* cntx,
packv_t* cntl )
{
num_t dt_cp = bli_obj_dt( c );
dim_t dim_p = bli_obj_vector_dim( p );
void* buf_c = bli_obj_buffer_at_off( c );
inc_t incc = bli_obj_vector_inc( c );
void* buf_p = bli_obj_buffer_at_off( p );
inc_t incp = bli_obj_vector_inc( p );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_cp];
// Invoke the function.
f
(
dim_p,
buf_c, incc,
buf_p, incp,
cntx
);
}
void bli_gemv_unb_var2( obj_t* alpha,
obj_t* a,
obj_t* x,
obj_t* beta,
obj_t* y,
gemv_t* cntl )
{
num_t dt_a = bli_obj_datatype( *a );
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
conj_t transa = bli_obj_conjtrans_status( *a );
conj_t conjx = bli_obj_conj_status( *x );
dim_t m = bli_obj_length( *a );
dim_t n = bli_obj_width( *a );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t incx = bli_obj_vector_inc( *x );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t incy = bli_obj_vector_inc( *y );
num_t dt_alpha;
void* buf_alpha;
num_t dt_beta;
void* buf_beta;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of a and x. This is to
// prevent any unnecessary loss of information during computation.
dt_alpha = bli_datatype_union( dt_a, dt_x );
buf_alpha = bli_obj_scalar_buffer( dt_alpha, *alpha );
// The datatype of beta MUST be the same as the datatype of y.
dt_beta = dt_y;
buf_beta = bli_obj_scalar_buffer( dt_beta, *beta );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_a][dt_x][dt_y];
// Invoke the function.
f( transa,
conjx,
m,
n,
buf_alpha,
buf_a, rs_a, cs_a,
buf_x, incx,
buf_beta,
buf_y, incy );
}
void bli_gemmtrsm_ukr( obj_t* alpha,
obj_t* a1x,
obj_t* a11,
obj_t* bx1,
obj_t* b11,
obj_t* c11 )
{
dim_t k = bli_obj_width( *a1x );
num_t dt = bli_obj_datatype( *c11 );
void* buf_a1x = bli_obj_buffer_at_off( *a1x );
void* buf_a11 = bli_obj_buffer_at_off( *a11 );
void* buf_bx1 = bli_obj_buffer_at_off( *bx1 );
void* buf_b11 = bli_obj_buffer_at_off( *b11 );
void* buf_c11 = bli_obj_buffer_at_off( *c11 );
inc_t rs_c = bli_obj_row_stride( *c11 );
inc_t cs_c = bli_obj_col_stride( *c11 );
void* buf_alpha = bli_obj_buffer_for_1x1( dt, *alpha );
inc_t ps_a = bli_obj_panel_stride( *a1x );
inc_t ps_b = bli_obj_panel_stride( *bx1 );
FUNCPTR_T f;
auxinfo_t data;
// Fill the auxinfo_t struct in case the micro-kernel uses it.
if ( bli_obj_is_lower( *a11 ) )
{ bli_auxinfo_set_next_a( buf_a1x, data ); }
else
{ bli_auxinfo_set_next_a( buf_a11, data ); }
bli_auxinfo_set_next_b( buf_bx1, data );
bli_auxinfo_set_ps_a( ps_a, data );
bli_auxinfo_set_ps_b( ps_b, data );
// Index into the type combination array to extract the correct
// function pointer.
if ( bli_obj_is_lower( *a11 ) ) f = ftypes_l[dt];
else f = ftypes_u[dt];
// Invoke the function.
f( k,
buf_alpha,
buf_a1x,
buf_a11,
buf_bx1,
buf_b11,
buf_c11, rs_c, cs_c,
&data );
}
void bli_dotxf_kernel( obj_t* alpha,
obj_t* a,
obj_t* x,
obj_t* beta,
obj_t* y )
{
num_t dt_a = bli_obj_datatype( *a );
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
conj_t conjat = bli_obj_conj_status( *a );
conj_t conjx = bli_obj_conj_status( *x );
dim_t m = bli_obj_vector_dim( *x );
dim_t b_n = bli_obj_vector_dim( *y );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
num_t dt_alpha;
void* buf_alpha;
num_t dt_beta;
void* buf_beta;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of a and x. This is to
// prevent any unnecessary loss of information during computation.
dt_alpha = bli_datatype_union( dt_a, dt_x );
buf_alpha = bli_obj_buffer_for_1x1( dt_alpha, *alpha );
// The datatype of beta MUST be the same as the datatype of y.
dt_beta = dt_y;
buf_beta = bli_obj_buffer_for_1x1( dt_beta, *beta );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_a][dt_x][dt_y];
// Invoke the function.
f( conjat,
conjx,
m,
b_n,
buf_alpha,
buf_a, rs_a, cs_a,
buf_x, inc_x,
buf_beta,
buf_y, inc_y );
}
void bli_packm_unb_var1( obj_t* c,
obj_t* p,
packm_thrinfo_t* thread )
{
num_t dt_cp = bli_obj_datatype( *c );
struc_t strucc = bli_obj_struc( *c );
doff_t diagoffc = bli_obj_diag_offset( *c );
diag_t diagc = bli_obj_diag( *c );
uplo_t uploc = bli_obj_uplo( *c );
trans_t transc = bli_obj_conjtrans_status( *c );
dim_t m_p = bli_obj_length( *p );
dim_t n_p = bli_obj_width( *p );
dim_t m_max_p = bli_obj_padded_length( *p );
dim_t n_max_p = bli_obj_padded_width( *p );
void* buf_c = bli_obj_buffer_at_off( *c );
inc_t rs_c = bli_obj_row_stride( *c );
inc_t cs_c = bli_obj_col_stride( *c );
void* buf_p = bli_obj_buffer_at_off( *p );
inc_t rs_p = bli_obj_row_stride( *p );
inc_t cs_p = bli_obj_col_stride( *p );
void* buf_kappa;
FUNCPTR_T f;
// This variant assumes that the computational kernel will always apply
// the alpha scalar of the higher-level operation. Thus, we use BLIS_ONE
// for kappa so that the underlying packm implementation does not scale
// during packing.
buf_kappa = bli_obj_buffer_for_const( dt_cp, BLIS_ONE );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_cp];
if( thread_am_ochief( thread ) ) {
// Invoke the function.
f( strucc,
diagoffc,
diagc,
uploc,
transc,
m_p,
n_p,
m_max_p,
n_max_p,
buf_kappa,
buf_c, rs_c, cs_c,
buf_p, rs_p, cs_p );
}
}
void bli_dotxv_unb_var1( obj_t* alpha,
obj_t* x,
obj_t* y,
obj_t* beta,
obj_t* rho )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
num_t dt_rho = bli_obj_datatype( *rho );
conj_t conjx = bli_obj_conj_status( *x );
conj_t conjy = bli_obj_conj_status( *y );
dim_t n = bli_obj_vector_dim( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
void* buf_rho = bli_obj_buffer_at_off( *rho );
num_t dt_alpha;
void* buf_alpha;
num_t dt_beta;
void* buf_beta;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of x and y. This is to
// prevent any unnecessary loss of information during computation.
dt_alpha = bli_datatype_union( dt_x, dt_y );
buf_alpha = bli_obj_scalar_buffer( dt_alpha, *alpha );
// The datatype of beta MUST be the same as the datatype of rho.
dt_beta = dt_rho;
buf_beta = bli_obj_scalar_buffer( dt_beta, *beta );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x][dt_y][dt_rho];
// Invoke the function.
f( conjx,
conjy,
n,
buf_alpha,
buf_x, inc_x,
buf_y, inc_y,
buf_beta,
buf_rho );
}
void bli_trsm_rl_ker_var2( obj_t* alpha,
obj_t* a,
obj_t* b,
obj_t* beta,
obj_t* c,
trsm_t* cntl )
{
num_t dt_exec = bli_obj_execution_datatype( *c );
doff_t diagoffb = bli_obj_diag_offset( *b );
dim_t m = bli_obj_length( *c );
dim_t n = bli_obj_width( *c );
dim_t k = bli_obj_width( *a );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
inc_t ps_a = bli_obj_panel_stride( *a );
void* buf_b = bli_obj_buffer_at_off( *b );
inc_t rs_b = bli_obj_row_stride( *b );
inc_t cs_b = bli_obj_col_stride( *b );
inc_t ps_b = bli_obj_panel_stride( *b );
void* buf_c = bli_obj_buffer_at_off( *c );
inc_t rs_c = bli_obj_row_stride( *c );
inc_t cs_c = bli_obj_col_stride( *c );
num_t dt_alpha;
void* buf_alpha;
FUNCPTR_T f;
// If alpha is a scalar constant, use dt_exec to extract the address of the
// corresponding constant value; otherwise, use the datatype encoded
// within the alpha object and extract the buffer at the alpha offset.
bli_set_scalar_dt_buffer( alpha, dt_exec, dt_alpha, buf_alpha );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_exec];
// Invoke the function.
f( diagoffb,
m,
n,
k,
buf_alpha,
buf_a, rs_a, cs_a, ps_a,
buf_b, rs_b, cs_b, ps_b,
buf_c, rs_c, cs_c );
}
void bli_dotaxpyv_kernel( obj_t* alpha,
obj_t* xt,
obj_t* x,
obj_t* y,
obj_t* rho,
obj_t* z )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
num_t dt_z = bli_obj_datatype( *z );
conj_t conjxt = bli_obj_conj_status( *xt );
conj_t conjx = bli_obj_conj_status( *x );
conj_t conjy = bli_obj_conj_status( *y );
dim_t n = bli_obj_vector_dim( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t inc_z = bli_obj_vector_inc( *z );
void* buf_z = bli_obj_buffer_at_off( *z );
void* buf_rho = bli_obj_buffer_at_off( *rho );
num_t dt_alpha;
void* buf_alpha;
FUNCPTR_T f;
// If alpha is a scalar constant, use dt_x to extract the address of the
// corresponding constant value; otherwise, use the datatype encoded
// within the alpha object and extract the buffer at the alpha offset.
bli_set_scalar_dt_buffer( alpha, dt_x, dt_alpha, buf_alpha );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x][dt_y][dt_z];
// Invoke the function.
f( conjxt,
conjx,
conjy,
n,
buf_alpha,
buf_x, inc_x,
buf_y, inc_y,
buf_rho,
buf_z, inc_z );
}
void bli_her2_unb_var1( conj_t conjh,
obj_t* alpha,
obj_t* alpha_conj,
obj_t* x,
obj_t* y,
obj_t* c,
her2_t* cntl )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
num_t dt_c = bli_obj_datatype( *c );
uplo_t uplo = bli_obj_uplo( *c );
conj_t conjx = bli_obj_conj_status( *x );
conj_t conjy = bli_obj_conj_status( *y );
dim_t m = bli_obj_length( *c );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t incx = bli_obj_vector_inc( *x );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t incy = bli_obj_vector_inc( *y );
void* buf_c = bli_obj_buffer_at_off( *c );
inc_t rs_c = bli_obj_row_stride( *c );
inc_t cs_c = bli_obj_col_stride( *c );
num_t dt_alpha;
void* buf_alpha;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of the datatypes of x and y.
dt_alpha = bli_datatype_union( dt_x, dt_y );
buf_alpha = bli_obj_buffer_for_1x1( dt_alpha, *alpha );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x][dt_y][dt_c];
// Invoke the function.
f( uplo,
conjx,
conjy,
conjh,
m,
buf_alpha,
buf_x, incx,
buf_y, incy,
buf_c, rs_c, cs_c );
}
void bli_ger_unb_var2( obj_t* alpha,
obj_t* x,
obj_t* y,
obj_t* a,
cntx_t* cntx,
ger_t* cntl )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
num_t dt_a = bli_obj_datatype( *a );
conj_t conjx = bli_obj_conj_status( *x );
conj_t conjy = bli_obj_conj_status( *y );
dim_t m = bli_obj_length( *a );
dim_t n = bli_obj_width( *a );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t incx = bli_obj_vector_inc( *x );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t incy = bli_obj_vector_inc( *y );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
num_t dt_alpha;
void* buf_alpha;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of x and y. This is to
// prevent any unnecessary loss of information during computation.
dt_alpha = bli_datatype_union( dt_x, dt_y );
buf_alpha = bli_obj_buffer_for_1x1( dt_alpha, *alpha );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_a];
// Invoke the function.
f( conjx,
conjy,
m,
n,
buf_alpha,
buf_x, incx,
buf_y, incy,
buf_a, rs_a, cs_a,
cntx );
}
void bli_axpym_unb_var1( obj_t* alpha,
obj_t* x,
obj_t* y,
cntx_t* cntx )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
doff_t diagoffx = bli_obj_diag_offset( *x );
diag_t diagx = bli_obj_diag( *x );
uplo_t uplox = bli_obj_uplo( *x );
trans_t transx = bli_obj_conjtrans_status( *x );
dim_t m = bli_obj_length( *y );
dim_t n = bli_obj_width( *y );
inc_t rs_x = bli_obj_row_stride( *x );
inc_t cs_x = bli_obj_col_stride( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t rs_y = bli_obj_row_stride( *y );
inc_t cs_y = bli_obj_col_stride( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
num_t dt_alpha;
void* buf_alpha;
FUNCPTR_T f;
// If alpha is a scalar constant, use dt_x to extract the address of the
// corresponding constant value; otherwise, use the datatype encoded
// within the alpha object and extract the buffer at the alpha offset.
bli_set_scalar_dt_buffer( alpha, dt_x, dt_alpha, buf_alpha );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_alpha][dt_x][dt_y];
// Invoke the function.
f( diagoffx,
diagx,
uplox,
transx,
m,
n,
buf_alpha,
buf_x, rs_x, cs_x,
buf_y, rs_y, cs_y );
}
//
// Define object-based interface.
//
void bli_scalv( obj_t* alpha,
obj_t* x )
{
num_t dt = bli_obj_datatype( *x );
dim_t n = bli_obj_vector_dim( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
obj_t alpha_local;
void* buf_alpha;
FUNCPTR_T f = ftypes[dt];
if ( bli_error_checking_is_enabled() )
bli_scalv_check( alpha, x );
// Create a local copy-cast of alpha (and apply internal conjugation
// if needed).
bli_obj_scalar_init_detached_copy_of( dt,
BLIS_NO_CONJUGATE,
alpha,
&alpha_local );
// Extract the scalar buffer.
buf_alpha = bli_obj_buffer_for_1x1( dt, alpha_local );
// Invoke the void pointer-based function.
f( BLIS_NO_CONJUGATE, // conjugation applied during copy-cast.
n,
buf_alpha,
buf_x, inc_x );
}
void bli_normfsc_unb_var1( obj_t* chi,
obj_t* norm )
{
num_t dt_chi;
num_t dt_norm_c = bli_obj_datatype_proj_to_complex( *norm );
void* buf_chi;
void* buf_norm = bli_obj_buffer_at_off( *norm );
FUNCPTR_T f;
// If chi is a scalar constant, use dt_norm_c to extract the address of the
// corresponding constant value; otherwise, use the datatype encoded
// within the chi object and extract the buffer at the chi offset.
bli_set_scalar_dt_buffer( chi, dt_norm_c, dt_chi, buf_chi );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_chi];
// Invoke the function.
f( buf_chi,
buf_norm );
}
void bli_copysc_unb_var1( obj_t* chi,
obj_t* psi )
{
conj_t conjchi = bli_obj_conj_status( *chi );
num_t dt_psi = bli_obj_datatype( *psi );
void* buf_psi = bli_obj_buffer_at_off( *psi );
num_t dt_chi;
void* buf_chi;
FUNCPTR_T f;
// If chi is a scalar constant, use dt_psi to extract the address of the
// corresponding constant value; otherwise, use the datatype encoded
// within the chi object and extract the buffer at the chi offset.
bli_set_scalar_dt_buffer( chi, dt_psi, dt_chi, buf_chi );
//printf( "copysc_unb_var1(): datatypes of chi (%u) and psi (%u)\n", dt_chi, dt_psi );
//return;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_chi][dt_psi];
// Invoke the function.
f( conjchi,
buf_chi,
buf_psi );
}
void bli_setid_unb_var1( obj_t* beta,
obj_t* x )
{
num_t dt_xr = bli_obj_datatype_proj_to_real( *x );
num_t dt_x = bli_obj_datatype( *x );
doff_t diagoffx = bli_obj_diag_offset( *x );
dim_t m = bli_obj_length( *x );
dim_t n = bli_obj_width( *x );
void* buf_beta = bli_obj_buffer_for_1x1( dt_xr, *beta );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t rs_x = bli_obj_row_stride( *x );
inc_t cs_x = bli_obj_col_stride( *x );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x];
// Invoke the function.
f( diagoffx,
m,
n,
buf_beta,
buf_x, rs_x, cs_x );
}
void bli_trmv_unf_var2( obj_t* alpha,
obj_t* a,
obj_t* x,
cntx_t* cntx,
trmv_t* cntl )
{
num_t dt_a = bli_obj_datatype( *a );
num_t dt_x = bli_obj_datatype( *x );
uplo_t uplo = bli_obj_uplo( *a );
trans_t trans = bli_obj_conjtrans_status( *a );
diag_t diag = bli_obj_diag( *a );
dim_t m = bli_obj_length( *a );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t incx = bli_obj_vector_inc( *x );
num_t dt_alpha;
void* buf_alpha;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of a and x. This is to
// prevent any unnecessary loss of information during computation.
dt_alpha = bli_datatype_union( dt_a, dt_x );
buf_alpha = bli_obj_buffer_for_1x1( dt_alpha, *alpha );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_a][dt_x];
// Invoke the function.
f( uplo,
trans,
diag,
m,
buf_alpha,
buf_a, rs_a, cs_a,
buf_x, incx );
}
void bli_unpackm_unb_var1
(
obj_t* p,
obj_t* c,
cntx_t* cntx,
cntl_t* cntl,
thrinfo_t* thread
)
{
num_t dt_pc = bli_obj_datatype( *p );
doff_t diagoffp = bli_obj_diag_offset( *p );
uplo_t uplop = bli_obj_uplo( *p );
trans_t transc = bli_obj_onlytrans_status( *c );
dim_t m_c = bli_obj_length( *c );
dim_t n_c = bli_obj_width( *c );
void* buf_p = bli_obj_buffer_at_off( *p );
inc_t rs_p = bli_obj_row_stride( *p );
inc_t cs_p = bli_obj_col_stride( *p );
void* buf_c = bli_obj_buffer_at_off( *c );
inc_t rs_c = bli_obj_row_stride( *c );
inc_t cs_c = bli_obj_col_stride( *c );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_pc];
// Invoke the function.
f( diagoffp,
uplop,
transc,
m_c,
n_c,
buf_p, rs_p, cs_p,
buf_c, rs_c, cs_c,
cntx
);
}
void bli_scalm_unb_var1( obj_t* alpha,
obj_t* x,
cntx_t* cntx )
{
num_t dt_x = bli_obj_datatype( *x );
doff_t diagoffx = bli_obj_diag_offset( *x );
uplo_t diagx = bli_obj_diag( *x );
uplo_t uplox = bli_obj_uplo( *x );
dim_t m = bli_obj_length( *x );
dim_t n = bli_obj_width( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t rs_x = bli_obj_row_stride( *x );
inc_t cs_x = bli_obj_col_stride( *x );
void* buf_alpha;
obj_t x_local;
FUNCPTR_T f;
// Alias x to x_local so we can apply alpha if it is non-unit.
bli_obj_alias_to( *x, x_local );
// If alpha is non-unit, apply it to the scalar attached to x.
if ( !bli_obj_equals( alpha, &BLIS_ONE ) )
{
bli_obj_scalar_apply_scalar( alpha, &x_local );
}
// Grab the address of the internal scalar buffer for the scalar
// attached to x.
buf_alpha_x = bli_obj_internal_scalar_buffer( *x );
// Index into the type combination array to extract the correct
// function pointer.
// NOTE: We use dt_x for both alpha and x because alpha was obtained
// from the attached scalar of x, which is guaranteed to be of the
// same datatype as x.
f = ftypes[dt_x][dt_x];
// Invoke the function.
// NOTE: We unconditionally pass in BLIS_NO_CONJUGATE for alpha
// because it would have already been conjugated by the front-end.
f( BLIS_NO_CONJUGATE,
diagoffx,
diagx,
uplox,
m,
n,
buf_alpha,
buf_x, rs_x, cs_x );
}
void bli_axpy2v_ker( obj_t* alpha1,
obj_t* alpha2,
obj_t* x,
obj_t* y,
obj_t* z )
{
num_t dt = bli_obj_datatype( *z );
conj_t conjx = bli_obj_conj_status( *x );
conj_t conjy = bli_obj_conj_status( *y );
dim_t n = bli_obj_vector_dim( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t inc_z = bli_obj_vector_inc( *z );
void* buf_z = bli_obj_buffer_at_off( *z );
void* buf_alpha1 = bli_obj_buffer_for_1x1( dt, *alpha1 );
void* buf_alpha2 = bli_obj_buffer_for_1x1( dt, *alpha2 );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt];
// Invoke the function.
f( conjx,
conjy,
n,
buf_alpha1,
buf_alpha2,
buf_x, inc_x,
buf_y, inc_y,
buf_z, inc_z );
}
void bli_obj_create_const_copy_of( obj_t* a, obj_t* b )
{
gint_t* temp_i;
float* temp_s;
double* temp_d;
scomplex* temp_c;
dcomplex* temp_z;
void* buf_a;
dcomplex value;
if ( bli_error_checking_is_enabled() )
bli_obj_create_const_copy_of_check( a, b );
bli_obj_create( BLIS_CONSTANT, 1, 1, 1, 1, b );
temp_s = bli_obj_buffer_for_const( BLIS_FLOAT, *b );
temp_d = bli_obj_buffer_for_const( BLIS_DOUBLE, *b );
temp_c = bli_obj_buffer_for_const( BLIS_SCOMPLEX, *b );
temp_z = bli_obj_buffer_for_const( BLIS_DCOMPLEX, *b );
temp_i = bli_obj_buffer_for_const( BLIS_INT, *b );
buf_a = bli_obj_buffer_at_off( *a );
bli_zzsets( 0.0, 0.0, value );
if ( bli_obj_is_float( *a ) )
{
bli_szcopys( *(( float* )buf_a), value );
}
else if ( bli_obj_is_double( *a ) )
{
bli_dzcopys( *(( double* )buf_a), value );
}
else if ( bli_obj_is_scomplex( *a ) )
{
bli_czcopys( *(( scomplex* )buf_a), value );
}
else if ( bli_obj_is_dcomplex( *a ) )
{
bli_zzcopys( *(( dcomplex* )buf_a), value );
}
else
{
bli_check_error_code( BLIS_NOT_YET_IMPLEMENTED );
}
bli_zscopys( value, *temp_s );
bli_zdcopys( value, *temp_d );
bli_zccopys( value, *temp_c );
bli_zzcopys( value, *temp_z );
*temp_i = ( gint_t ) bli_zreal( value );
}
void libblis_test_randv_check
(
test_params_t* params,
obj_t* x,
double* resid
)
{
num_t dt_real = bli_obj_datatype_proj_to_real( *x );
dim_t m_x = bli_obj_vector_dim( *x );
obj_t sum;
*resid = 0.0;
//
// The two most likely ways that randv would fail is if all elements
// were zero, or if all elements were greater than or equal to one.
// We check both of these conditions by computing the sum of the
// absolute values of the elements of x.
//
bli_obj_scalar_init_detached( dt_real, &sum );
bli_norm1v( x, &sum );
if ( bli_is_float( dt_real ) )
{
float* sum_x = bli_obj_buffer_at_off( sum );
if ( *sum_x == *bli_d0 ) *resid = 1.0;
else if ( *sum_x >= 2.0 * m_x ) *resid = 2.0;
}
else // if ( bli_is_double( dt_real ) )
{
double* sum_x = bli_obj_buffer_at_off( sum );
if ( *sum_x == *bli_d0 ) *resid = 1.0;
else if ( *sum_x >= 2.0 * m_x ) *resid = 2.0;
}
}
void bli_addm_unb_var1( obj_t* x,
obj_t* y,
cntx_t* cntx )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
doff_t diagoffx = bli_obj_diag_offset( *x );
diag_t diagx = bli_obj_diag( *x );
uplo_t uplox = bli_obj_uplo( *x );
trans_t transx = bli_obj_conjtrans_status( *x );
dim_t m = bli_obj_length( *y );
dim_t n = bli_obj_width( *y );
inc_t rs_x = bli_obj_row_stride( *x );
inc_t cs_x = bli_obj_col_stride( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t rs_y = bli_obj_row_stride( *y );
inc_t cs_y = bli_obj_col_stride( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x][dt_y];
// Invoke the function.
f( diagoffx,
diagx,
uplox,
transx,
m,
n,
buf_x, rs_x, cs_x,
buf_y, rs_y, cs_y );
}
void bli_normfv_unb_var1( obj_t* x,
obj_t* norm )
{
num_t dt_x = bli_obj_datatype( *x );
dim_t m = bli_obj_vector_dim( *x );
inc_t incx = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
void* buf_norm = bli_obj_buffer_at_off( *norm );
FUNCPTR_T f;
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x];
// Invoke the function.
f( m,
buf_x, incx,
buf_norm );
}
void bli_scal2v_unb_var1( obj_t* beta,
obj_t* x,
obj_t* y )
{
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
conj_t conjx = bli_obj_conj_status( *x );
dim_t n = bli_obj_vector_dim( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
num_t dt_beta;
void* buf_beta;
FUNCPTR_T f;
// If beta is a scalar constant, use dt_x to extract the address of the
// corresponding constant value; otherwise, use the datatype encoded
// within the beta object and extract the buffer at the beta offset.
bli_set_scalar_dt_buffer( beta, dt_x, dt_beta, buf_beta );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_beta][dt_x][dt_y];
// Invoke the function.
f( conjx,
n,
buf_beta,
buf_x, inc_x,
buf_y, inc_y );
}
void bli_fprintm( FILE* file, char* s1, obj_t* x, char* format, char* s2 )
{
num_t dt_x = bli_obj_datatype( *x );
dim_t m = bli_obj_length( *x );
dim_t n = bli_obj_width( *x );
inc_t rs_x = bli_obj_row_stride( *x );
inc_t cs_x = bli_obj_col_stride( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
FUNCPTR_T f;
if ( bli_error_checking_is_enabled() )
bli_fprintm_check( file, s1, x, format, s2 );
// Handle constants up front.
if ( dt_x == BLIS_CONSTANT )
{
float* sp = bli_obj_buffer_for_const( BLIS_FLOAT, *x );
double* dp = bli_obj_buffer_for_const( BLIS_DOUBLE, *x );
scomplex* cp = bli_obj_buffer_for_const( BLIS_SCOMPLEX, *x );
dcomplex* zp = bli_obj_buffer_for_const( BLIS_DCOMPLEX, *x );
gint_t* ip = bli_obj_buffer_for_const( BLIS_INT, *x );
fprintf( file, "%s\n", s1 );
fprintf( file, " float: %9.2e\n", bli_sreal( *sp ) );
fprintf( file, " double: %9.2e\n", bli_dreal( *dp ) );
fprintf( file, " scomplex: %9.2e + %9.2e\n", bli_creal( *cp ), bli_cimag( *cp ) );
fprintf( file, " dcomplex: %9.2e + %9.2e\n", bli_zreal( *zp ), bli_zimag( *zp ) );
fprintf( file, " int: %ld\n", *ip );
fprintf( file, "\n" );
return;
}
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_x];
// Invoke the function.
f( file,
s1,
m,
n,
buf_x, rs_x, cs_x,
format,
s2 );
}