void bli_axpy2v_kernel( obj_t* alpha1, obj_t* alpha2, obj_t* x, obj_t* y, obj_t* z ) { num_t dt_x = bli_obj_datatype( *x ); num_t dt_y = bli_obj_datatype( *y ); 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 ); num_t dt_alpha1; void* buf_alpha1; num_t dt_alpha2; void* buf_alpha2; 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( alpha1, dt_x, dt_alpha1, buf_alpha1 ); bli_set_scalar_dt_buffer( alpha2, dt_x, dt_alpha2, buf_alpha2 ); // Index into the type combination array to extract the correct // function pointer. f = ftypes[dt_alpha1][dt_x][dt_y]; // 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_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_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 ); }
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_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 ); }
void bli_scald_unb_var1( obj_t* beta, obj_t* x ) { num_t dt_x = bli_obj_datatype( *x ); conj_t conjbeta = bli_obj_conj_status( *beta ); doff_t diagoffx = bli_obj_diag_offset( *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_beta; num_t dt_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]; // Invoke the function. f( conjbeta, diagoffx, m, n, buf_beta, buf_x, rs_x, cs_x ); }
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 ); }