void time_Her2k_ln(
int variant, int type, int nrepeats, int n, int nb_alg,
FLA_Obj A, FLA_Obj B, FLA_Obj C, FLA_Obj C_ref,
double *dtime, double *diff, double *gflops )
{
int
irep;
double
dtime_old = 1.0e9;
FLA_Obj
C_old;
fla_blocksize_t*
bp;
fla_gemm_t*
cntl_gemm_blas;
fla_her2k_t*
cntl_her2k_blas;
fla_her2k_t*
cntl_her2k_var;
bp = FLA_Blocksize_create( nb_alg, nb_alg, nb_alg, nb_alg );
cntl_gemm_blas = FLA_Cntl_gemm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL );
cntl_her2k_blas = FLA_Cntl_her2k_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL, NULL, NULL );
cntl_her2k_var = FLA_Cntl_her2k_obj_create( FLA_FLAT, variant, bp, cntl_her2k_blas, cntl_gemm_blas, cntl_gemm_blas );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, C, &C_old );
FLA_Copy_external( C, C_old );
for ( irep = 0 ; irep < nrepeats; irep++ )
{
FLA_Copy_external( C_old, C );
*dtime = FLA_Clock();
switch( variant ){
case 0:
// Time reference implementation
REF_Her2k( FLA_LOWER_TRIANGULAR, FLA_NO_TRANSPOSE, FLA_ONE, A, B, FLA_ONE, C );
break;
case 1:{
// Time variant 1
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var1( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var1( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 2:{
// Time variant 2
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var2( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var2( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 3:{
// Time variant 3
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var3( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var3( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 4:{
// Time variant 4
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var4( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var4( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 5:{
// Time variant 5
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var5( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var5( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 6:{
// Time variant 6
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var6( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var6( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 7:{
// Time variant 7
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var7( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var7( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 8:{
// Time variant 8
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var8( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var8( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 9:{
// Time variant 9
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var9( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var9( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
case 10:{
// Time variant 10
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Her2k_ln_unb_var10( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Her2k_ln_blk_var10( FLA_ONE, A, B, FLA_ONE, C, cntl_her2k_var );
break;
default:
printf("trouble\n");
}
break;
}
}
*dtime = FLA_Clock() - *dtime;
dtime_old = min( *dtime, dtime_old );
}
FLA_Cntl_obj_free( cntl_her2k_var );
FLA_Cntl_obj_free( cntl_her2k_blas );
FLA_Cntl_obj_free( cntl_gemm_blas );
FLA_Blocksize_free( bp );
if ( variant == 0 )
{
FLA_Copy_external( C, C_ref );
*diff = 0.0;
}
else
{
*diff = FLA_Max_elemwise_diff( C, C_ref );
}
*gflops = 2.0 *
FLA_Obj_length( C ) *
FLA_Obj_width( C ) *
FLA_Obj_width( A ) /
dtime_old /
1e9;
*dtime = dtime_old;
FLA_Copy_external( C_old, C );
FLA_Obj_free( &C_old );
}
void time_Sylv_nn(
int variant, int type, int n_repeats, int m, int n, int nb_alg,
FLA_Obj isgn, FLA_Obj A, FLA_Obj B, FLA_Obj C, FLA_Obj C_ref, FLA_Obj scale,
double *dtime, double *diff, double *gflops )
{
int
irep;
double
dtime_old = 1.0e9;
FLA_Obj
C_old;
fla_blocksize_t*
bp;
fla_sylv_t*
cntl_sylv_var;
fla_sylv_t*
cntl_sylv_unb;
fla_gemm_t*
cntl_gemm_blas;
/*
if( type == FLA_ALG_UNBLOCKED && n > 400 )
{
*gflops = 0.0;
*diff = 0.0;
return;
}
*/
bp = FLA_Blocksize_create( nb_alg, nb_alg, nb_alg, nb_alg );
cntl_sylv_unb = FLA_Cntl_sylv_obj_create( FLA_FLAT, FLA_UNB_OPT_VARIANT1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL );
cntl_gemm_blas = FLA_Cntl_gemm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL, NULL );
cntl_sylv_var = FLA_Cntl_sylv_obj_create( FLA_FLAT, variant, bp, cntl_sylv_unb, cntl_sylv_unb, cntl_sylv_unb, cntl_gemm_blas, cntl_gemm_blas, cntl_gemm_blas, cntl_gemm_blas, cntl_gemm_blas, cntl_gemm_blas, cntl_gemm_blas, cntl_gemm_blas );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, C, &C_old );
FLA_Copy_external( C, C_old );
for ( irep = 0 ; irep < n_repeats; irep++ ){
FLA_Copy_external( C_old, C );
*dtime = FLA_Clock();
switch( variant ){
case 0:
/* Time reference implementation */
REF_Sylv_nn( isgn, A, B, C, scale );
break;
case 1:{
/* Time variant 1 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var1( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var1( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 2:{
/* Time variant 2 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var2( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var2( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 3:{
/* Time variant 3 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var3( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var3( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 4:{
/* Time variant 4 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var4( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var4( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 5:{
/* Time variant 5 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var5( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var5( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 6:{
/* Time variant 6 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var6( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var6( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 7:{
/* Time variant 7 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var7( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var7( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 8:{
/* Time variant 8 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var8( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var8( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 9:{
/* Time variant 9 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var9( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var9( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 10:{
/* Time variant 10 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var10( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var10( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 11:{
/* Time variant 11 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var11( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var11( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 12:{
/* Time variant 12 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var12( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var12( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 13:{
/* Time variant 13 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var13( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var13( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 14:{
/* Time variant 14 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var14( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var14( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 15:{
/* Time variant 15 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var15( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var15( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 16:{
/* Time variant 16 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var16( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var16( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 17:{
/* Time variant 17 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var17( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var17( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
case 18:{
/* Time variant 18 */
switch( type ){
case FLA_ALG_UNB_OPT:
FLA_Sylv_nn_opt_var18( isgn, A, B, C, scale );
break;
case FLA_ALG_BLOCKED:
FLA_Sylv_nn_blk_var18( isgn, A, B, C, scale, cntl_sylv_var );
break;
default:
printf("trouble\n");
}
break;
}
}
*dtime = FLA_Clock() - *dtime;
dtime_old = min( *dtime, dtime_old );
}
FLA_Cntl_obj_free( cntl_sylv_var );
FLA_Cntl_obj_free( cntl_sylv_unb );
FLA_Cntl_obj_free( cntl_gemm_blas );
FLA_Blocksize_free( bp );
if ( variant == 0 ){
FLA_Copy_external( C, C_ref );
*diff = 0.0;
}
else{
*diff = FLA_Max_elemwise_diff( C, C_ref );
}
*gflops = ( m * m * n + n * n * m ) /
dtime_old / 1e9;
if ( FLA_Obj_is_complex( C ) )
*gflops *= 4.0;
*dtime = dtime_old;
FLA_Copy_external( C_old, C );
FLA_Obj_free( &C_old );
}
void time_Gemm_hh(
int variant, int type, int nrepeats, int n, int nb_alg,
FLA_Obj A, FLA_Obj B, FLA_Obj C, FLA_Obj C_ref,
double *dtime, double *diff, double *gflops )
{
int
irep;
double
dtime_old = 1.0e9;
FLA_Obj
C_old;
fla_blocksize_t*
bp;
fla_gemm_t*
cntl_gemm_blas;
fla_gemm_t*
cntl_gemm_var;
bp = FLA_Blocksize_create( nb_alg, nb_alg, nb_alg, nb_alg );
cntl_gemm_blas = FLA_Cntl_gemm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL );
cntl_gemm_var = FLA_Cntl_gemm_obj_create( FLA_FLAT, variant, bp, cntl_gemm_blas );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, C, &C_old );
FLA_Copy_external( C, C_old );
for ( irep = 0 ; irep < nrepeats; irep++ ){
FLA_Copy_external( C_old, C );
*dtime = FLA_Clock();
switch( variant ){
// Time reference implementation
case 0:
REF_Gemm( FLA_CONJ_TRANSPOSE, FLA_CONJ_TRANSPOSE,
FLA_ONE, A, B, FLA_ONE, C );
break;
// Time variant 1
case 1:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Gemm_hh_unb_var1( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Gemm_hh_blk_var1( FLA_ONE, A, B, FLA_ONE, C, cntl_gemm_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 2
case 2:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Gemm_hh_unb_var2( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Gemm_hh_blk_var2( FLA_ONE, A, B, FLA_ONE, C, cntl_gemm_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 3
case 3:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Gemm_hh_unb_var3( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Gemm_hh_blk_var3( FLA_ONE, A, B, FLA_ONE, C, cntl_gemm_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 4
case 4:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Gemm_hh_unb_var4( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Gemm_hh_blk_var4( FLA_ONE, A, B, FLA_ONE, C, cntl_gemm_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 5
case 5:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Gemm_hh_unb_var5( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Gemm_hh_blk_var5( FLA_ONE, A, B, FLA_ONE, C, cntl_gemm_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 6
case 6:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Gemm_hh_unb_var6( FLA_ONE, A, B, FLA_ONE, C );
break;
case FLA_ALG_BLOCKED:
FLA_Gemm_hh_blk_var6( FLA_ONE, A, B, FLA_ONE, C, cntl_gemm_var );
break;
default:
printf("trouble\n");
}
break;
}
}
*dtime = FLA_Clock() - *dtime;
dtime_old = min( *dtime, dtime_old );
}
FLA_Cntl_obj_free( cntl_gemm_var );
FLA_Cntl_obj_free( cntl_gemm_blas );
FLA_Blocksize_free( bp );
if ( variant == 0 )
{
FLA_Copy_external( C, C_ref );
*diff = 0.0;
}
else
{
*diff = FLA_Max_elemwise_diff( C, C_ref );
}
*gflops = 2.0 *
FLA_Obj_length( C ) *
FLA_Obj_width( C ) *
FLA_Obj_width( A ) /
dtime_old /
1.0e9;
if ( FLA_Obj_is_complex( C ) )
*gflops *= 4.0;
*dtime = dtime_old;
FLA_Copy_external( C_old, C );
FLA_Obj_free( &C_old );
}
void FLASH_Gemm_cntl_init()
{
// Set gemm blocksize for hierarchical storage.
flash_gemm_bsize = FLA_Blocksize_create( 1, 1, 1, 1 );
// Create a control tree node that executes a gemm subproblem.
flash_gemm_cntl_blas = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_SUBPROBLEM,
NULL,
NULL,
NULL );
// Create control trees for situations where one dimension is large.
flash_gemm_cntl_pb_bb = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT1,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_blas );
flash_gemm_cntl_bp_bb = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT3,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_blas );
flash_gemm_cntl_ip_bb = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT5,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_blas );
// Create control trees for situations where two dimensions are large.
flash_gemm_cntl_mp_ip = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT1,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_ip_bb );
flash_gemm_cntl_op_bp = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT1,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_bp_bb );
flash_gemm_cntl_pm_ip = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT3,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_ip_bb );
flash_gemm_cntl_op_pb = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT3,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_pb_bb );
flash_gemm_cntl_mp_pb = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT5,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_pb_bb );
flash_gemm_cntl_pm_bp = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT5,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_bp_bb );
// Create control trees for situations where all dimensions are large.
flash_gemm_cntl_mm_pm = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT1,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_pm_ip );
flash_gemm_cntl_mm_mp = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT3,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_mp_ip );
flash_gemm_cntl_mm_op = FLA_Cntl_gemm_obj_create( FLA_HIER,
FLA_BLOCKED_VARIANT5,
flash_gemm_bsize,
flash_scal_cntl,
flash_gemm_cntl_op_bp );
// Alias select control trees for convenience, when the caller doesn't
// care (as he usually doesn't when partitioning hierarchical matricies)
// which order the matrix is partitioned into blocks
flash_gemm_cntl_mm = flash_gemm_cntl_mm_op;
flash_gemm_cntl_mp = flash_gemm_cntl_mp_pb;
flash_gemm_cntl_pm = flash_gemm_cntl_pm_bp;
flash_gemm_cntl_op = flash_gemm_cntl_op_pb;
flash_gemm_cntl_pb = flash_gemm_cntl_pb_bb;
flash_gemm_cntl_bp = flash_gemm_cntl_bp_bb;
flash_gemm_cntl_ip = flash_gemm_cntl_ip_bb;
}
void time_Chol_u(
int variant, int type, int nrepeats, int n, int nb_alg,
FLA_Obj A, FLA_Obj b, FLA_Obj b_orig, FLA_Obj norm,
double *dtime, double *diff, double *gflops )
{
int
irep;
double
dtime_save = 1.0e9;
FLA_Obj
A_save, b_save, b_orig_save;
fla_blocksize_t*
bp;
fla_chol_t*
cntl_chol_var;
fla_chol_t*
cntl_chol_unb;
fla_syrk_t*
cntl_syrk_blas;
fla_herk_t*
cntl_herk_blas;
fla_trsm_t*
cntl_trsm_blas;
fla_gemm_t*
cntl_gemm_blas;
/*
if( type == FLA_ALG_UNBLOCKED && n > 400 )
{
*gflops = 0.0;
*diff = 0.0;
return;
}
*/
bp = FLA_Blocksize_create( nb_alg, nb_alg, nb_alg, nb_alg );
cntl_chol_unb = FLA_Cntl_chol_obj_create( FLA_FLAT, FLA_UNB_OPT_VARIANT2, NULL, NULL, NULL, NULL, NULL, NULL );
cntl_syrk_blas = FLA_Cntl_syrk_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL, NULL );
cntl_herk_blas = FLA_Cntl_herk_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL, NULL );
cntl_trsm_blas = FLA_Cntl_trsm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL, NULL );
cntl_gemm_blas = FLA_Cntl_gemm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL );
cntl_chol_var = FLA_Cntl_chol_obj_create( FLA_FLAT, variant, bp,
cntl_chol_unb,
cntl_syrk_blas,
cntl_herk_blas,
cntl_trsm_blas,
cntl_gemm_blas );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, A, &A_save );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, b, &b_save );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, b_orig, &b_orig_save );
FLA_Copy_external( A, A_save );
FLA_Copy_external( b, b_save );
FLA_Copy_external( b_orig, b_orig_save );
for ( irep = 0 ; irep < nrepeats; irep++ ){
FLA_Copy_external( A_save, A );
*dtime = FLA_Clock();
switch( variant ){
case 0:
REF_Chol_u( A );
break;
case 1:{
// Time variant 1
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Chol_u_unb_var1( A );
break;
case FLA_ALG_UNB_OPT:
FLA_Chol_u_opt_var1( A );
break;
case FLA_ALG_BLOCKED:
FLA_Chol_u_blk_var1( A, cntl_chol_var );
break;
default:
printf("trouble\n");
}
break;
}
case 2:{
// Time variant 2
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Chol_u_unb_var2( A );
break;
case FLA_ALG_UNB_OPT:
FLA_Chol_u_opt_var2( A );
break;
case FLA_ALG_BLOCKED:
FLA_Chol_u_blk_var2( A, cntl_chol_var );
break;
default:
printf("trouble\n");
}
break;
}
case 3:{
// Time variant 3
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Chol_u_unb_var3( A );
break;
case FLA_ALG_UNB_OPT:
FLA_Chol_u_opt_var3( A );
break;
case FLA_ALG_BLOCKED:
FLA_Chol_u_blk_var3( A, cntl_chol_var );
break;
default:
printf("trouble\n");
}
break;
}
}
*dtime = FLA_Clock() - *dtime;
dtime_save = min( *dtime, dtime_save );
}
FLA_Cntl_obj_free( cntl_chol_var );
FLA_Cntl_obj_free( cntl_chol_unb );
FLA_Cntl_obj_free( cntl_syrk_blas );
FLA_Cntl_obj_free( cntl_herk_blas );
FLA_Cntl_obj_free( cntl_trsm_blas );
FLA_Cntl_obj_free( cntl_gemm_blas );
FLA_Blocksize_free( bp );
if ( type == FLA_ALG_REFERENCE )
{
FLA_Trsv_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
FLA_UNIT_DIAG, A, b );
FLA_Trsv_external( FLA_UPPER_TRIANGULAR, FLA_NO_TRANSPOSE,
FLA_NONUNIT_DIAG, A, b );
FLA_Hemv_external( FLA_UPPER_TRIANGULAR,
FLA_ONE, A_save, b, FLA_MINUS_ONE, b_orig );
FLA_Nrm2_external( b_orig, norm );
FLA_Copy_object_to_buffer( FLA_NO_TRANSPOSE, 0, 0, norm,
1, 1, diff, 1, 1 );
}
else
{
FLA_Trsv_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
FLA_UNIT_DIAG, A, b );
FLA_Trsv_external( FLA_UPPER_TRIANGULAR, FLA_NO_TRANSPOSE,
FLA_NONUNIT_DIAG, A, b );
FLA_Hemv_external( FLA_UPPER_TRIANGULAR,
FLA_ONE, A_save, b, FLA_MINUS_ONE, b_orig );
FLA_Nrm2_external( b_orig, norm );
FLA_Copy_object_to_buffer( FLA_NO_TRANSPOSE, 0, 0, norm,
1, 1, diff, 1, 1 );
}
*gflops = 1.0 / 3.0 *
FLA_Obj_length( A ) *
FLA_Obj_length( A ) *
FLA_Obj_length( A ) /
dtime_save / 1e9;
if ( FLA_Obj_is_complex( A ) )
*gflops *= 4.0;
*dtime = dtime_save;
FLA_Copy_external( A_save, A );
FLA_Copy_external( b_save, b );
FLA_Copy_external( b_orig_save, b_orig );
FLA_Obj_free( &A_save );
FLA_Obj_free( &b_save );
FLA_Obj_free( &b_orig_save );
}
void time_Trinv_un(
int variant, int type, int nrepeats, int m, int nb_alg,
FLA_Obj A, FLA_Obj b, FLA_Obj b_orig, FLA_Obj norm,
double *dtime, double *diff, double *gflops )
{
int
irep;
double
dtime_old = 1.0e9;
FLA_Obj
A_save, b_save, b_orig_save;
fla_blocksize_t*
bp;
fla_trinv_t*
cntl_trinv_var;
fla_trinv_t*
cntl_trinv_unb;
fla_gemm_t*
cntl_gemm_blas;
fla_trmm_t*
cntl_trmm_blas;
fla_trsm_t*
cntl_trsm_blas;
bp = FLA_Blocksize_create( nb_alg, nb_alg, nb_alg, nb_alg );
cntl_trinv_unb = FLA_Cntl_trinv_obj_create( FLA_FLAT, FLA_UNB_OPT_VARIANT3, NULL, NULL, NULL, NULL, NULL, NULL );
cntl_trmm_blas = FLA_Cntl_trmm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL, NULL );
cntl_trsm_blas = FLA_Cntl_trsm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL, NULL );
cntl_gemm_blas = FLA_Cntl_gemm_obj_create( FLA_FLAT, FLA_SUBPROBLEM, NULL, NULL );
cntl_trinv_var = FLA_Cntl_trinv_obj_create( FLA_FLAT, variant, bp, cntl_trinv_unb, cntl_trmm_blas, cntl_trsm_blas, cntl_trsm_blas, cntl_gemm_blas );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, A, &A_save );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, b, &b_save );
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, b_orig, &b_orig_save );
FLA_Copy_external( A, A_save );
FLA_Copy_external( b, b_save );
FLA_Copy_external( b_orig, b_orig_save );
for ( irep = 0 ; irep < nrepeats; irep++ )
{
FLA_Copy_external( A_save, A );
*dtime = FLA_Clock();
switch( variant ){
// Time reference
case 0:
REF_Trinv_un( A );
break;
// Time variant 1
case 1:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Trinv_un_unb_var1( A );
break;
case FLA_ALG_UNB_OPT:
FLA_Trinv_un_opt_var1( A );
break;
case FLA_ALG_BLOCKED:
FLA_Trinv_un_blk_var1( A, cntl_trinv_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 2
case 2:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Trinv_un_unb_var2( A );
break;
case FLA_ALG_UNB_OPT:
FLA_Trinv_un_opt_var2( A );
break;
case FLA_ALG_BLOCKED:
FLA_Trinv_un_blk_var2( A, cntl_trinv_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 3
case 3:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Trinv_un_unb_var3( A );
break;
case FLA_ALG_UNB_OPT:
FLA_Trinv_un_opt_var3( A );
break;
case FLA_ALG_BLOCKED:
FLA_Trinv_un_blk_var3( A, cntl_trinv_var );
break;
default:
printf("trouble\n");
}
break;
}
// Time variant 4
case 4:{
switch( type ){
case FLA_ALG_UNBLOCKED:
FLA_Trinv_un_unb_var4( A );
break;
case FLA_ALG_UNB_OPT:
FLA_Trinv_un_opt_var4( A );
break;
case FLA_ALG_BLOCKED:
FLA_Trinv_un_blk_var4( A, cntl_trinv_var );
break;
default:
printf("trouble\n");
}
break;
}
}
*dtime = FLA_Clock() - *dtime;
dtime_old = min( *dtime, dtime_old );
}
FLA_Cntl_obj_free( cntl_trinv_var );
FLA_Cntl_obj_free( cntl_trinv_unb );
FLA_Cntl_obj_free( cntl_gemm_blas );
FLA_Cntl_obj_free( cntl_trmm_blas );
FLA_Cntl_obj_free( cntl_trsm_blas );
FLA_Blocksize_free( bp );
{
FLA_Trmv_external( FLA_UPPER_TRIANGULAR, FLA_NO_TRANSPOSE,
FLA_NONUNIT_DIAG, A, b );
FLA_Trmv_external( FLA_UPPER_TRIANGULAR, FLA_NO_TRANSPOSE,
FLA_NONUNIT_DIAG, A_save, b );
FLA_Axpy_external( FLA_MINUS_ONE, b_orig, b );
FLA_Nrm2_external( b, norm );
FLA_Copy_object_to_buffer( FLA_NO_TRANSPOSE, 0, 0, norm,
1, 1, diff, 1, 1 );
}
*gflops = 1.0 / 3.0 *
FLA_Obj_length( A ) *
FLA_Obj_length( A ) *
FLA_Obj_length( A ) /
dtime_old / 1e9;
if ( FLA_Obj_is_complex( A ) )
*gflops *= 4.0;
*dtime = dtime_old;
FLA_Copy_external( A_save, A );
FLA_Copy_external( b_save, b );
FLA_Copy_external( b_orig_save, b_orig );
FLA_Obj_free( &A_save );
FLA_Obj_free( &b_save );
FLA_Obj_free( &b_orig_save );
}
