自学教程：C++ FLA_Init函数代码示例

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {  int attr[NINT];  FLA_Obj obj[NOBJ];  double *dtime;  FLA_Init();  /* Check if the number of arguments supplied is correct */  FLA_M2C_CheckNumArgs(NRHS, nrhs);  /* Convert Matlab arguments into the appropriate FLAME C arguments */  FLA_M2C_ConvertArgs(NRHS, prhs, NINT, attr, obj);  /* If an extra argument is supplied, collect timing informaion in it. */  if (nrhs == NRHS+1)    dtime = FLA_M2C_ConvertDoublePtr(prhs[NRHS]);  /* Now call the C FLAME function, timing it if the extra argument is given. */  if (nrhs == NRHS+1)    *dtime = FLA_Clock();  FLA_Axpyt_external(attr[0], obj[0], obj[1], obj[2]);  if (nrhs == NRHS+1)    *dtime = FLA_Clock() - *dtime;  FLA_Finalize();}

int main(int argc, char* argv[]){	dim_t order;	dim_t nA;	dim_t permutation[FLA_MAX_ORDER];	FLA_Init();	//Parse input	if(parse_input(argc, argv, &order, &nA, permutation) == FLA_FAILURE){		Usage();		FLA_Finalize();		return 0;	}	if(check_errors(order, nA, permutation) == FLA_FAILURE){		Usage();		FLA_Finalize();		return 0;	}	test_permute_tensor(order, nA, permutation);	FLA_Finalize();	return 0;}

int phonopy_pinv_libflame(double *matrix,			  double *eigvals,			  const int size,			  const double cutoff){  FLA_Obj A, B, l;  /* FLA_Obj C; */  double *inv_eigvals;  int i;  inv_eigvals = (double*)malloc(sizeof(double) * size);    FLA_Init();  FLA_Obj_create_without_buffer(FLA_DOUBLE, size, size, &A);  FLA_Obj_attach_buffer(matrix, 0, 0, &A);    FLA_Obj_create_without_buffer(FLA_DOUBLE, size, 1, &l);  FLA_Obj_attach_buffer(eigvals, 0, 0, &l);  /* Eigensolver */  FLA_Obj_create_copy_of(FLA_NO_TRANSPOSE, A, &B);  FLA_Hevd(FLA_EVD_WITH_VECTORS, FLA_LOWER_TRIANGULAR, B, l);  /* SVD */  /* FLA_Obj_create(FLA_DOUBLE, size, size, 0, 0, &B); */  /* use U */  /* FLA_Svd(FLA_SVD_VECTORS_ALL, FLA_SVD_VECTORS_NONE, A, l, B, C); */  /* use V */  /* FLA_Svd(FLA_SVD_VECTORS_NONE, FLA_SVD_VECTORS_ALL, A, l, C, B); */    FLA_Obj_free_without_buffer(&l);    for (i = 0; i < size; i++) {    if (eigvals[i] < cutoff) {      inv_eigvals[i] = 0;    } else {      inv_eigvals[i] = 1.0 / sqrt(eigvals[i]);    }  }    FLA_Obj_create_without_buffer(FLA_DOUBLE, size, 1, &l);  FLA_Obj_attach_buffer(inv_eigvals, 0, 0, &l);    FLA_Apply_diag_matrix(FLA_RIGHT, FLA_NO_CONJUGATE, l, B);  FLA_Syrk(FLA_LOWER_TRIANGULAR, FLA_NO_TRANSPOSE, FLA_ONE, B, FLA_ZERO, A);  FLA_Symmetrize(FLA_LOWER_TRIANGULAR, A);    FLA_Obj_free_without_buffer(&A);  FLA_Obj_free_without_buffer(&l);  FLA_Obj_free(&B);  FLA_Finalize();  free(inv_eigvals);    return 0;}

void FLA_Init_safe( FLA_Error* init_result ){  if ( FLA_Initialized() )  {    *init_result = FLA_FAILURE;  }  else  {    FLA_Init();    *init_result = FLA_SUCCESS;  }}

int main(int argc, char* argv[]){	dim_t order;	TLA_sym sym;	dim_t n[FLA_MAX_ORDER];	dim_t b[FLA_MAX_ORDER];	dim_t permutation[FLA_MAX_ORDER];	FLA_Obj T;	FLA_Init();	//Parse inputs	if(parse_input(argc, argv, &order, &sym, n, b, permutation) == FLA_FAILURE){	    Usage();	    FLA_Finalize();	    return 0;	}	//Error check	if(check_errors(order, sym, n, b, permutation) == FLA_FAILURE){		Usage();	    FLA_Finalize();	    return 0;	}	//Perform test	create_psym_tensor(order, sym, n, b, &T);	FLA_Obj_print_matlab("T", T);		test_permute_tensor(permutation, T);    FLA_Obj_blocked_psym_tensor_free_buffer(&T);    FLA_Obj_free_without_buffer(&T);    FLA_Finalize();	return 0;}

void mexFunction(int nargout, mxArray * pargout[],                 int nargin, const mxArray * pargin[]){    if (nargin > 1)    {        mexErrMsgTxt("Too many input arguments.");    }    FLA_Init();    int i;    //Parse input    FLA_Obj A;    mexPrintf("Creating tensor/n");    TLA_mxa_to_tensor(pargin[0], &A);    FLA_Obj_print_matlab("A", A);    //Pass output    mexPrintf("Passing C back/n");    TLA_tensor_to_mxa(A, &(pargout[0]));    //DELETE EVERYTHING    mexPrintf("finalizing/n");    FLA_Finalize();}

int main(int argc, char *argv[]){  int     datatype,    precision,    nb_alg, bm, bn,    m_input, n_input,    m, n,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;    char *colors = "brkgmcbrkgmcbrkgmc";  char *ticks  = "o+*xso+*xso+*xso+*xs";  char m_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, A_save, A_flat, B, B_ref, T, T_flat, W, t;    FLA_Init( );  fprintf( stdout, "%c number of repeats: ", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter FLASH blocksize: ", '%' );  scanf( "%d", &nb_alg );  fprintf( stdout, "%c %d/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc: ", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m n (-1 means bind to problem size): ", '%' );  scanf( "%d%d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );    sprintf( n_dim_tag,  "n%dc", n_input);  }  else if( n_input <  -1 ) {    sprintf( n_dim_desc, "n = p/%d", -n_input );    sprintf( n_dim_tag,  "n%dp", -n_input );  }  else if( n_input == -1 ) {    sprintf( n_dim_desc, "n = p" );    sprintf( n_dim_tag,  "n%dp", 1 );  }  //precision = FLA_SINGLE_PRECISION;  precision = FLA_DOUBLE_PRECISION;  FLASH_Queue_disable();  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    n = n_input;    if( m < 0 ) m = p / abs(m_input);    if( n < 0 ) n = p / abs(n_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){      // Determine datatype based on trans argument.      if ( pc_str[param_combo][1] == 'c' )      {        if ( precision == FLA_SINGLE_PRECISION )          datatype = FLA_COMPLEX;//.........这里部分代码省略.........

int main( int argc, char *argv[] ) {    int      i, j,      n_threads,      n_repeats,      n_trials,      increment,      begin,      sorting,      caching,      work_stealing,      data_affinity;   dim_t      size,      nb_alg;   FLA_Datatype      datatype = FLA_DOUBLE;   FLA_Inv          inv = FLA_NO_INVERSE;   FLA_Uplo      uplo = FLA_LOWER_TRIANGULAR;   FLA_Obj       A, B, x, b, b_norm,      AH, BH;      double       length,      b_norm_value = 0.0,      dtime,       *dtimes,      *flops;#ifndef FLA_ENABLE_WINDOWS_BUILD   char      output_file_m[100];      FILE      *fpp;#endif   fprintf( stdout, "%c Enter number of repeats: ", '%' );   scanf( "%d", &n_repeats );   fprintf( stdout, "%c %d/n", '%', n_repeats );   fprintf( stdout, "%c Enter blocksize: ", '%' );   scanf( "%u", &nb_alg );   fprintf( stdout, "%c %u/n", '%', nb_alg );   fprintf( stdout, "%c Enter problem size parameters: first, inc, num: ", '%' );   scanf( "%d%d%d", &begin, &increment, &n_trials );   fprintf( stdout, "%c %d %d %d/n", '%', begin, increment, n_trials );   fprintf( stdout, "%c Enter number of threads: ", '%' );   scanf( "%d", &n_threads );   fprintf( stdout, "%c %d/n", '%', n_threads );   fprintf( stdout, "%c Enter SuperMatrix parameters: sorting, caching, work stealing, data affinity: ", '%' );   scanf( "%d%d%d%d", &sorting, &caching, &work_stealing, &data_affinity );   fprintf( stdout, "%c %s %s %s %s/n/n", '%', ( sorting ? "TRUE" : "FALSE" ), ( caching ? "TRUE" : "FALSE" ), ( work_stealing ? "TRUE" : "FALSE" ), ( data_affinity ? ( data_affinity == 1 ? "FLASH_QUEUE_AFFINITY_2D_BLOCK_CYCLIC" : "FLASH_QUEUE_AFFINITY_OTHER" ) : "FLASH_QUEUE_AFFINITY_NONE" ) );#ifdef FLA_ENABLE_WINDOWS_BUILD   fprintf( stdout, "%s_%u = [/n", OUTPUT_FILE, nb_alg );#else   sprintf( output_file_m, "%s/%s_output.m", OUTPUT_PATH, OUTPUT_FILE );   fpp = fopen( output_file_m, "a" );   fprintf( fpp, "%%/n" );   fprintf( fpp, "%% | Matrix Size |    FLASH    |/n" );   fprintf( fpp, "%% |    n x n    |    GFlops   |/n" );   fprintf( fpp, "%% -----------------------------/n" );   fprintf( fpp, "%s_%u = [/n", OUTPUT_FILE, nb_alg );#endif   FLA_Init();   dtimes = ( double * ) FLA_malloc( n_repeats * sizeof( double ) );   flops  = ( double * ) FLA_malloc( n_trials  * sizeof( double ) );      FLASH_Queue_set_num_threads( n_threads );   FLASH_Queue_set_sorting( sorting );   FLASH_Queue_set_caching( caching );   FLASH_Queue_set_work_stealing( work_stealing );   FLASH_Queue_set_data_affinity( data_affinity );   for ( i = 0; i < n_trials; i++ )   {      size = begin + i * increment;            FLA_Obj_create( datatype, size, size, 0, 0, &A );       FLA_Obj_create( datatype, size, size, 0, 0, &B );       FLA_Obj_create( datatype, size, 1,    0, 0, &x );       FLA_Obj_create( datatype, size, 1,    0, 0, &b );       FLA_Obj_create( datatype, 1,    1,    0, 0, &b_norm );       //.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    m_input, k_input,    m, k,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;    char *colors = "brkgmcbrkgmcbrkgmc";  char *ticks  = "o+*xso+*xso+*xso+*xs";  char m_dim_desc[14];  char k_dim_desc[14];  char m_dim_tag[10];  char k_dim_tag[10];  dim_t nb_alg, n_threads;  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, B, C, C_ref;    FLA_Init( );  fprintf( stdout, "%c number of repeats: ", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter FLASH blocksize: ", '%' );  scanf( "%d", &nb_alg );  fprintf( stdout, "%c %d/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc: ", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m k (-1 means bind to problem size): ", '%' );  scanf( "%d%d", &m_input, &k_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, k_input );  fprintf( stdout, "%c enter the number of SuperMatrix threads: ", '%' );  scanf( "%d", &n_threads );  fprintf( stdout, "%c %d/n", '%', n_threads );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( k_input >  0 ) {    sprintf( k_dim_desc, "k = %d", k_input );    sprintf( k_dim_tag,  "k%dc", k_input);  }  else if( k_input <  -1 ) {    sprintf( k_dim_desc, "k = p/%d", -k_input );    sprintf( k_dim_tag,  "k%dp", -k_input );  }  else if( k_input == -1 ) {    sprintf( k_dim_desc, "k = p" );    sprintf( k_dim_tag,  "k%dp", 1 );  }  //datatype = FLA_COMPLEX;  datatype = FLA_DOUBLE_COMPLEX;  FLASH_Queue_set_num_threads( n_threads );  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    k = k_input;    if( m < 0 ) m = p / abs(m_input);    if( k < 0 ) k = p / abs(k_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){      //.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    m_input,    m,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i, j,    n_param_combos = N_PARAM_COMBOS;  int sign;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, C, C_ref, scale, isgn, norm;    FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c Enter sign (-1 or 1):", '%' );  scanf( "%d", &sign );  fprintf( stdout, "%c %d/n", '%', sign );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m (-1 means bind to problem size): ", '%' );  scanf( "%d", &m_input );  fprintf( stdout, "%c %d/n", '%', m_input );  fprintf( stdout, "/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if ( 0 < sign )    isgn = FLA_ONE;  else    isgn = FLA_MINUS_ONE;  //datatype = FLA_FLOAT;  datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  //datatype = FLA_DOUBLE_COMPLEX;  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    if( m < 0 ) m = p / abs(m_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){      FLA_Obj_create( datatype, m, m, 0, 0, &A );      FLA_Obj_create( datatype, m, m, 0, 0, &C );      FLA_Obj_create( datatype, m, m, 0, 0, &C_ref );      FLA_Obj_create( FLA_Obj_datatype_proj_to_real( A ), 1, 1, 0, 0, &scale );      FLA_Obj_create( FLA_Obj_datatype_proj_to_real( A ), 1, 1, 0, 0, &norm );      FLA_Random_tri_matrix( FLA_UPPER_TRIANGULAR, FLA_NONUNIT_DIAG, A );      FLA_Triangularize( FLA_UPPER_TRIANGULAR, FLA_NONUNIT_DIAG, A );      FLA_Norm1( A, norm );      FLA_Shift_diag( FLA_NO_CONJUGATE, norm, A );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    m_input,    m,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;  dim_t nb_alg;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char m_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, A_ref;    FLA_Init();  fprintf( stdout, "%c number of repeats: ", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter FLASH blocksize: ", '%' );  scanf( "%u", &nb_alg );  fprintf( stdout, "%c %u/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc: ", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m (-1 means bind to problem size): ", '%' );  scanf( "%d", &m_input );  fprintf( stdout, "%c %d/n", '%', m_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  //datatype = FLA_FLOAT;  datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  //datatype = FLA_DOUBLE_COMPLEX;  FLASH_Queue_disable();  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    if( m < 0 ) m = p / abs(m_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){      FLASH_Obj_create( datatype, m, m, 1, &nb_alg, &A );      FLASH_Obj_create( datatype, m, m, 1, &nb_alg, &A_ref );      if ( pc_str[param_combo][0] == 'l' )        FLASH_Random_spd_matrix( FLA_LOWER_TRIANGULAR, A );      else        FLASH_Random_spd_matrix( FLA_UPPER_TRIANGULAR, A );            FLASH_Copy( A, A_ref );      fprintf( stdout, "data_chol_%s( %d, 1:5 ) = [ %d  ", pc_str[param_combo], i, p );      fflush( stdout );      time_Chol( param_combo, FLA_ALG_REFERENCE, n_repeats, m,                 A, A_ref, &dtime, &diff, &gflops );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    m_input,    m,    p_first, p_last, p_inc,    p,    nb_alg,    variant,    n_repeats,    i, j,    n_variants = N_VARIANTS;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char m_dim_tag[10];  double max_gflops=6.0;    double    dtime,    gflops,    diff;  FLA_Obj    A, b, b_orig, norm;    FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c Enter blocking size:", '%' );  scanf( "%d", &nb_alg );  fprintf( stdout, "%c %d/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m (-1 means bind to problem size): ", '%' );  scanf( "%d", &m_input );  fprintf( stdout, "%c %d/n", '%', m_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  //datatype = FLA_FLOAT;  //datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  datatype = FLA_DOUBLE_COMPLEX;  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    if( m < 0 ) m = p / f2c_abs(m_input);    FLA_Obj_create( datatype, m, m, 0, 0, &A );    FLA_Obj_create( datatype, m, 1, 0, 0, &b );    FLA_Obj_create( datatype, m, 1, 0, 0, &b_orig );/*    FLA_Obj_create( datatype, m, m, m, 1, &A );    FLA_Obj_create( datatype, m, 1, 1, 1, &b );    FLA_Obj_create( datatype, m, 1, 1, 1, &b_orig );*/    if ( FLA_Obj_is_single_precision( A ) )      FLA_Obj_create( FLA_FLOAT, 1, 1, 0, 0, &norm );    else      FLA_Obj_create( FLA_DOUBLE, 1, 1, 0, 0, &norm );    FLA_Random_tri_matrix( FLA_UPPER_TRIANGULAR, FLA_NONUNIT_DIAG, A );    FLA_Random_matrix( b );    FLA_Copy_external( b, b_orig );/*    time_Trinv_un( 0, FLA_ALG_REFERENCE, n_repeats, m, nb_alg,                   A, b, b_orig, norm, &dtime, &diff, &gflops );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     m_input,    m,    p_first, p_last, p_inc,    p,    k_accum,    b_alg,    n_iter_max,    variant,    n_repeats,    i,    n_variants = 2;  char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char m_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff1, diff2;  FLA_Datatype datatype, dt_real;  FLA_Obj    A, l, Q, Ql, TT, r, d, e, A_orig, G, R, W2, de, alpha;  FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter n_iter_max (per eigenvalue): ", '%' );  scanf( "%d", &n_iter_max );  fprintf( stdout, "%c %d/n", '%', n_iter_max );  fprintf( stdout, "%c enter number of sets of Givens rotations to accumulate:", '%' );  scanf( "%d", &k_accum );  fprintf( stdout, "%c %d/n", '%', k_accum );  fprintf( stdout, "%c enter blocking size for application of G:", '%' );  scanf( "%d", &b_alg );  fprintf( stdout, "%c %d/n", '%', b_alg );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m (-1 means bind to problem size): ", '%' );  scanf( "%d", &m_input );  fprintf( stdout, "%c %d/n", '%', m_input );  fprintf( stdout, "/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    if( m < 0 ) m = p / abs(m_input);    //datatype = FLA_FLOAT;    //datatype = FLA_DOUBLE;    //datatype = FLA_COMPLEX;    datatype = FLA_DOUBLE_COMPLEX;    FLA_Obj_create( datatype,  m,         m, 0, 0, &A );    FLA_Obj_create( datatype,  m,         m, 0, 0, &A_orig );    FLA_Obj_create( datatype,  m,         m, 0, 0, &Q );    FLA_Obj_create( datatype,  m,         m, 0, 0, &Ql );    FLA_Obj_create( datatype,  m,         1, 0, 0, &r );    FLA_Obj_create( datatype,  m,         m, 0, 0, &W2 );    FLA_Obj_create( datatype,  m-1, k_accum, 0, 0, &G );	dt_real = FLA_Obj_datatype_proj_to_real( A );    FLA_Obj_create( dt_real, m,      1, 0, 0, &l );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    n_threads,    m_input,    m,    n_input,    n,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;  dim_t    b_flash,    b_alg;  char *colors = "brkgmcbrkgmcbrkgmc";  char *ticks  = "o+*xso+*xso+*xso+*xs";  char m_dim_desc[14];  char m_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj A, TW, b, x;  FLA_Obj A_flat, b_flat, x_flat;    FLA_Init( );  fprintf( stdout, "%c number of repeats: ", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter FLASH blocksize: ", '%' );  scanf( "%u", &b_flash );  fprintf( stdout, "%c %u/n", '%', b_flash );  fprintf( stdout, "%c enter problem size first, last, inc: ", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m n (-1 means bind to problem size): ", '%' );  scanf( "%d %d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  fprintf( stdout, "%c enter the number of SuperMatrix threads: ", '%' );  scanf( "%d", &n_threads );  fprintf( stdout, "%c %d/n", '%', n_threads );  fprintf( stdout, "/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  //datatype = FLA_FLOAT;  datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  //datatype = FLA_DOUBLE_COMPLEX;  FLASH_Queue_set_num_threads( n_threads );  //FLASH_Queue_set_verbose_output( TRUE );  //FLA_Check_error_level_set( FLA_NO_ERROR_CHECKING );  //FLASH_Queue_disable();  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    n = n_input;    if ( m < 0 ) m = p * abs(m_input);    if ( n < 0 ) n = p * abs(n_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ )    {      FLA_Obj_create( datatype, m, n, 0, 0, &A_flat );      FLA_Obj_create( datatype, n, 1, 0, 0, &x_flat );      FLA_Obj_create( datatype, m, 1, 0, 0, &b_flat );      FLA_Random_matrix( A_flat );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    m_input,    m,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;  FLA_Uplo uplo;  FLA_Diag diag;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char m_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, b, b_orig, norm;    FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m (-1 means bind to problem size): ", '%' );  scanf( "%d", &m_input );  fprintf( stdout, "%c %d/n", '%', m_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  //datatype = FLA_FLOAT;  //datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  datatype = FLA_DOUBLE_COMPLEX;  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    if( m < 0 ) m = p / abs(m_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){            //FLA_Obj_create( datatype, m, m, 0, 0, &A );      FLA_Obj_create( datatype, m, m, m, 1, &A );      FLA_Obj_create( datatype, m, 1, 0, 0, &b );      FLA_Obj_create( datatype, m, 1, 0, 0, &b_orig );      if ( FLA_Obj_is_single_precision( A ) )        FLA_Obj_create( FLA_FLOAT, 1, 1, 0, 0, &norm );      else        FLA_Obj_create( FLA_DOUBLE, 1, 1, 0, 0, &norm );      FLA_Param_map_netlib_to_flame_uplo( &pc_str[param_combo][0], &uplo );      FLA_Param_map_netlib_to_flame_diag( &pc_str[param_combo][1], &diag );      FLA_Random_tri_matrix( uplo, diag, A );      FLA_Random_matrix( b );      FLA_Copy_external( b, b_orig );      fprintf( stdout, "data_trinv_%s( %d, 1:5 ) = [ %d  ", pc_str[param_combo], i, p );      fflush( stdout );/*      time_Trinv( param_combo, FLA_ALG_REFERENCE, n_repeats, m, uplo, diag,                  A, b, b_orig, norm, &dtime, &diff, &gflops );//.........这里部分代码省略.........

int main( int argc, char *argv[] ){  int    m_input, n_input,    m, n, rs, cs,    i,    datatype;  int blocksize[3];  int depth;  double buffer[64];  double buffer2[64];  FLA_Obj Af, Ah, Bh;  FLA_Init();  fprintf( stdout, "%c Enter hierarchy depth:", '%' );  scanf( "%d", &depth );  fprintf( stdout, "%c %d/n", '%', depth );  for ( i = 0; i < depth; ++i )  {    fprintf( stdout, "%c Enter blocksize %d:", '%', i );    scanf( "%d", &blocksize[i] );    fprintf( stdout, "%c %d/n", '%', blocksize[i] );  }  fprintf( stdout, "%c enter m n: ", '%' );  scanf( "%d%d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  datatype      = FLA_DOUBLE;  m             = m_input;  n             = n_input;  rs            = 1;  cs            = m_input;  for( i = 0; i < 64; i++ ) buffer[i] = ( double ) i;  for( i = 0; i < 64; i++ ) buffer2[i] = ( double ) 0;  //FLASH_Obj_create( datatype, m, n, depth, blocksize, &Ah );  FLASH_Obj_create_without_buffer( datatype, m, n, depth, blocksize, &Ah );  FLASH_Obj_attach_buffer( buffer, rs, cs, &Ah );  //FLASH_Obj_create_flat_conf_to_hier( FLA_NO_TRANSPOSE, Ah, &Af );  //FLASH_Obj_create_hier_conf_to_flat( FLA_NO_TRANSPOSE, Af, depth, blocksize, &Bh );  //FLASH_Obj_create_flat_copy_of_hier( Ah, &Af );  //FLASH_Obj_create_hier_copy_of_flat( Af, depth, blocksize, &Bh );  FLASH_Obj_create_conf_to( FLA_NO_TRANSPOSE, Ah, &Bh );  //FLASH_Axpy( FLA_TWO, Ah, Bh );  FLASH_Copy( Ah, Bh );  //FLA_Obj_create_without_buffer( datatype, 4, 4, &Af );  //FLA_Obj_attach_buffer( buffer2, 4, &Af );  //FLASH_Axpy_flat_to_hier( FLA_TWO, Af, 1, 1, Ah );  //FLASH_Axpy_hier_to_flat( FLA_TWO, 1, 1, Ah, Af );  //FLASH_Axpy_buffer_to_hier( FLA_ONE, 4, 4, buffer, 4, 1, 1, Ah );  //FLASH_Axpy_hier_to_buffer( FLA_ONE, 2, 2, Ah, 4, 4, buffer2, 4 );  //fprintf( stderr, "T: Am An = %d %d/n", FLASH_Obj_scalar_length( Ah ),   //                                       FLASH_Obj_scalar_width( Ah ) );  //FLASH_Random_matrix( Ah );  //fprintf( stderr, "depth = %d/n", FLASH_Obj_depth( Ah ) );;/*  {    int depth;    int b_m[4];    int b_n[4];    depth = FLASH_Obj_blocksizes( Bh, b_m, b_n );    fprintf( stderr, "depth = %d/n", depth );;    fprintf( stderr, "b_m[0] = %d/n", b_m[0] );;    fprintf( stderr, "b_n[0] = %d/n", b_n[0] );;  }*/  FLASH_Obj_show( "", Ah, "%11.4e", "" );  FLASH_Obj_show( "", Bh, "%11.4e", "" );  //FLA_Obj_show( "", Af, "%11.4e", "" );  //FLASH_print_struct( Ah );  //fprintf( stderr, "max_diff = %e/n", FLASH_Max_elemwise_diff( Ah, Bh ) );;  //FLASH_Obj_free_without_buffer( &Ah );  //FLASH_Obj_free( &Af );  //FLA_Obj_free( &Af );  FLA_Finalize();  return 0;}

int main(int argc, char *argv[]){  int     m_input,    m,    p_first, p_last, p_inc,    p,    b_alg,    variant,    n_repeats,    i, j,    datatype,    n_variants = 5;    int  blocksize[16];  char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char m_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, Y, B, norm;  FLA_Inv  inv  = FLA_NO_INVERSE;  FLA_Uplo uplo = FLA_UPPER_TRIANGULAR;    /* Initialize FLAME */  FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c Enter blocking size:", '%' );  scanf( "%d", &b_alg );  fprintf( stdout, "%c %d/n", '%', b_alg );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m (-1 means bind to problem size): ", '%' );  scanf( "%d", &m_input );  fprintf( stdout, "%c %d/n", '%', m_input );  fprintf( stdout, "/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    if( m < 0 ) m = p / f2c_abs(m_input);    //datatype = FLA_FLOAT;    //datatype = FLA_DOUBLE;    //datatype = FLA_COMPLEX;    datatype = FLA_DOUBLE_COMPLEX;    FLA_Obj_create( datatype, m, m, 0, 0, &A );    FLA_Obj_create( datatype, m, m, 0, 0, &Y );    FLA_Obj_create( datatype, m, m, 0, 0, &B );    FLA_Random_spd_matrix( uplo, A );    FLA_Hermitianize( uplo, A );    FLA_Random_spd_matrix( uplo, B );    FLA_Chol( uplo, B );/*    time_Eig_gest_nu( 0, FLA_ALG_REFERENCE, n_repeats, p, b_alg,                      inv, uplo, A, B, &dtime, &diff, &gflops );    fprintf( stdout, "data_REF( %d, 1:2 ) = [ %d  %6.3lf ]; /n", i, p, gflops );    fflush( stdout );*///.........这里部分代码省略.........

int main(int argc, char *argv[]){  int m, n, k, nfirst, nlast, ninc, i, irep,    nrepeats, nb_alg, check;;  double    dtime,    dtime_best,    gflops,    max_gflops,    diff,    d_n;  FLA_Obj    A, B, C, Cref, Cold;    /* Initialize FLAME */  FLA_Init( );  /* Every time trial is repeated "repeat" times */  printf( "%% number of repeats:" );  scanf( "%d", &nrepeats );  printf( "%% %d/n", nrepeats );  /* Enter the max GFLOPS attainable */  printf( "%% enter max GFLOPS:" );  scanf( "%lf", &max_gflops );  printf( "%% %lf/n", max_gflops );  /* Enter the algorithmic block size */  printf( "%% enter nb_alg:" );  scanf( "%d", &nb_alg );  printf( "%% %d/n", nb_alg );  /* Timing trials for matrix sizes n=nfirst to nlast in increments      of ninc will be performed */  printf( "%% enter nfirst, nlast, ninc:" );  scanf( "%d%d%d", &nfirst, &nlast, &ninc );  printf( "%% %d %d %d/n", nfirst, nlast, ninc );  i = 1;  for ( n=nfirst; n<= nlast; n+=ninc ){       /* Allocate space for the matrices */    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &A );    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &B );    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &C );    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &Cref );    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &Cold );    /* Generate random matrices L and B */    FLA_Random_matrix( A );    FLA_Random_matrix( B );    FLA_Random_matrix( Cold );    gflops = 2.0 * n * n * n * 1.0e-09;    /* Time FLA_Symm */    for ( irep=0; irep<nrepeats; irep++ ){      FLA_Copy( Cold, Cref );      dtime = FLA_Clock();      FLA_Symm( FLA_LEFT, FLA_LOWER_TRIANGULAR, 		FLA_ONE, A, B, FLA_ONE, Cref );      dtime = FLA_Clock() - dtime;      if ( irep == 0 ) 	dtime_best = dtime;      else	dtime_best = ( dtime < dtime_best ? dtime : dtime_best );    }    printf( "data_FLAME( %d, 1:2 ) = [ %d %le ];/n", i, n,            gflops / dtime_best );    fflush( stdout );    /* Time the your implementations */#if TEST_UNB_VAR1==TRUE    /* Variant 1 unblocked */    for ( irep=0; irep<nrepeats; irep++ ){      FLA_Copy( Cold, C );          dtime = FLA_Clock();      Symm_unb_var1( A, B, C );      dtime = FLA_Clock() - dtime;      if ( irep == 0 ) 	dtime_best = dtime;      else//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    nb_alg,    m_input, n_input,    m, n,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i, j,    n_param_combos = N_PARAM_COMBOS;  int sign;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, B, C, C_ref, scale, isgn, norm;    FLA_Init();  fprintf( stdout, "%c number of repeats: ", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter FLASH blocksize: ", '%' );  scanf( "%d", &nb_alg );  fprintf( stdout, "%c %d/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc: ", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c Enter sign (-1 or 1):", '%' );  scanf( "%d", &sign );  fprintf( stdout, "%c %d/n", '%', sign );  fprintf( stdout, "%c enter m n (-1 means bind to problem size): ", '%' );  scanf( "%d %d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );    sprintf( n_dim_tag,  "n%dc", n_input);  }  else if( n_input <  -1 ) {    sprintf( n_dim_desc, "n = p/%d", -n_input );    sprintf( n_dim_tag,  "n%dp", -n_input );  }  else if( n_input == -1 ) {    sprintf( n_dim_desc, "n = p" );    sprintf( n_dim_tag,  "n%dp", 1 );  }  if ( 0 < sign )    isgn = FLA_ONE;  else    isgn = FLA_MINUS_ONE;  //datatype = FLA_FLOAT;  datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  //datatype = FLA_DOUBLE_COMPLEX;  if ( datatype == FLA_DOUBLE || datatype == FLA_DOUBLE_COMPLEX )  {    FLA_Obj_create( FLA_DOUBLE, 1, 1, &scale );    FLA_Obj_create( FLA_DOUBLE, 1, 1, &norm );//.........这里部分代码省略.........

void F77_fla_init(){    FLA_Init();}

int main(int argc, char *argv[]){  int     m_input,    m,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;  dim_t b_flash;  dim_t n_threads;  FLA_Datatype datatype;  FLA_Uplo     uplo;  FLA_Inv      inv;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char m_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, B, norm;    FLA_Init();  fprintf( stdout, "%c number of repeats: ", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter FLASH blocksize: ", '%' );  scanf( "%u", &b_flash );  fprintf( stdout, "%c %u/n", '%', b_flash );  fprintf( stdout, "%c enter problem size first, last, inc: ", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m (-1 means bind to problem size): ", '%' );  scanf( "%d", &m_input );  fprintf( stdout, "%c %d/n", '%', m_input );  fprintf( stdout, "%c enter the number of SuperMatrix threads: ", '%' );  scanf( "%d", &n_threads );  fprintf( stdout, "%c %d/n", '%', n_threads );  fprintf( stdout, "/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  //datatype = FLA_FLOAT;  //datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  datatype = FLA_DOUBLE_COMPLEX;  FLASH_Queue_set_num_threads( n_threads );  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    if( m < 0 ) m = p / abs(m_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){      if ( pc_str[param_combo][0] == 'i' ) inv = FLA_INVERSE;      else                                 inv = FLA_NO_INVERSE;      if ( pc_str[param_combo][1] == 'l' ) uplo = FLA_LOWER_TRIANGULAR;      else                                 uplo = FLA_UPPER_TRIANGULAR;      FLASH_Obj_create( datatype, m, m, 1, &b_flash, &A );      FLASH_Obj_create( datatype, m, m, 1, &b_flash, &B );      FLA_Obj_create( FLA_Obj_datatype_proj_to_real( A ), 1, 1, 0, 0, &norm );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     m_input, k_input, n_input,    m, n, k,    p_first, p_last, p_inc,    p,    nb_alg,    n_repeats,    variant,    n_threads,    n_thread_experiments,    i, j;  int n_threads_exp[64];  char *colors = "brkgmckkk";  char *ticks =  "o+*xso+*x";  char m_dim_desc[14];  char k_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[5];  char k_dim_tag[5];  char n_dim_tag[5];  char nth_str[32];  double max_gflops=6.0;  double    dtime,    gflops,    diff,    d_n;  FLA_Obj    A, B, C, C_ref;    /* Initialize FLAME */  FLA_Init( );  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c Enter blocking size:", '%' );  scanf( "%d", &nb_alg );  fprintf( stdout, "%c %d/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m k n (-1 means bind to problem size: ", '%' );  scanf( "%d%d%d", &m_input, &k_input, &n_input );  fprintf( stdout, "%c %d %d %d/n", '%', m_input, k_input, n_input );    fprintf( stdout, "%c enter number of thread experiments: ", '%' );  scanf( "%d", &n_thread_experiments );  fprintf( stdout, "%c %d/n", '%', n_thread_experiments );  fprintf( stdout, "%c enter number of threads for each experiment (separated by spaces): ", '%' );  for( i = 0; i < n_thread_experiments; ++i )    scanf( "%d", &n_threads_exp[i] );  fprintf( stdout, "%c", '%' );  for( i = 0; i < n_thread_experiments; ++i )    fprintf( stdout, " %d", n_threads_exp[i] );  /* Delete all existing data structures */  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( k_input >  0 ) {    sprintf( k_dim_desc, "k = %d", k_input );    sprintf( k_dim_tag,  "k%dc", k_input);  }  else if( k_input <  -1 ) {    sprintf( k_dim_desc, "k = p/%d", -k_input );    sprintf( k_dim_tag,  "k%dp", -k_input );  }  else if( k_input == -1 ) {    sprintf( k_dim_desc, "k = p" );    sprintf( k_dim_tag,  "k%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    m_input, n_input,    m, n, min_m_n,    p_first, p_last, p_inc,    pp,    pivot_combo,    n_repeats,    i,    n_pivot_combos = N_PIVOT_COMBOS;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    C, b, b_orig, b_norm;    FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m n (-1 means bind to problem size): ", '%' );  scanf( "%d %d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );    sprintf( n_dim_tag,  "n%dc", n_input);  }  else if( n_input <  -1 ) {    sprintf( n_dim_desc, "n = p/%d", -n_input );    sprintf( n_dim_tag,  "n%dp", -n_input );  }  else if( n_input == -1 ) {    sprintf( n_dim_desc, "n = p" );    sprintf( n_dim_tag,  "n%dp", 1 );  }  //datatype = FLA_FLOAT;  //datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  datatype = FLA_DOUBLE_COMPLEX;  for ( pp = p_first, i = 1; pp <= p_last; pp += p_inc, i += 1 )  {    m = m_input;    n = n_input;    if( m < 0 ) m = pp / abs(m_input);    if( n < 0 ) n = pp / abs(n_input);    min_m_n = min( m, n );    for ( pivot_combo = 0; pivot_combo < n_pivot_combos; pivot_combo++ ){            FLA_Obj_create( datatype, m, n, 0, 0, &C );      FLA_Obj_create( datatype, m, 1, 0, 0, &b );      FLA_Obj_create( datatype, m, 1, 0, 0, &b_orig );      if ( FLA_Obj_is_single_precision( C ) )        FLA_Obj_create( FLA_FLOAT, 1, 1, 0, 0, &b_norm );      else        FLA_Obj_create( FLA_DOUBLE, 1, 1, 0, 0, &b_norm );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    m_input, n_input,    m, n,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;    char *colors = "brkgmcbrkgmcbrkgmc";  char *ticks  = "o+*xso+*xso+*xso+*xs";  char m_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, B, C, C_ref;    FLA_Init( );  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m n (-1 means bind to problem size): ", '%' );  scanf( "%d%d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );    sprintf( n_dim_tag,  "n%dc", n_input);  }  else if( n_input <  -1 ) {    sprintf( n_dim_desc, "n = p/%d", -n_input );    sprintf( n_dim_tag,  "n%dp", -n_input );  }  else if( n_input == -1 ) {    sprintf( n_dim_desc, "n = p" );    sprintf( n_dim_tag,  "n%dp", 1 );  }  //datatype = FLA_FLOAT;  //datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  datatype = FLA_DOUBLE_COMPLEX;  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    n = n_input;    if( m < 0 ) m = p / abs(m_input);    if( n < 0 ) n = p / abs(n_input);    for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){            // If multiplying A on the left, A is m x m; ...on the right, A is n x n.      if ( pc_str[param_combo][0] == 'l' )        FLA_Obj_create( datatype, m, m, 0, 0, &A );      else        FLA_Obj_create( datatype, n, n, 0, 0, &A );      FLA_Obj_create( datatype, m, n, 0, 0, &B );      FLA_Obj_create( datatype, m, n, 0, 0, &C );      FLA_Obj_create( datatype, m, n, 0, 0, &C_ref );//.........这里部分代码省略.........

int main( int argc, char *argv[] ) {    int      i, j,      n_threads,      n_repeats,      n_trials,      increment,      begin,      sorting,      caching,      work_stealing,      data_affinity;   dim_t      size,      nb_alg;   FLA_Datatype      datatype = FLA_DOUBLE;   FLA_Obj       A, x, b, b_norm,      AH, pH, bH;      double       b_norm_value,      dtime,       *dtimes,      *flops;#ifndef FLA_ENABLE_WINDOWS_BUILD   char      output_file_m[100];      FILE      *fpp;#endif   fprintf( stdout, "%c Enter number of repeats: ", '%' );   scanf( "%d", &n_repeats );   fprintf( stdout, "%c %d/n", '%', n_repeats );   fprintf( stdout, "%c Enter blocksize: ", '%' );   scanf( "%u", &nb_alg );   fprintf( stdout, "%c %u/n", '%', nb_alg );   fprintf( stdout, "%c Enter problem size parameters: first, inc, num: ", '%' );   scanf( "%d%d%d", &begin, &increment, &n_trials );   fprintf( stdout, "%c %d %d %d/n", '%', begin, increment, n_trials );   fprintf( stdout, "%c Enter number of threads: ", '%' );   scanf( "%d", &n_threads );   fprintf( stdout, "%c %d/n", '%', n_threads );   fprintf( stdout, "%c Enter SuperMatrix parameters: sorting, caching, work stealing, data affinity: ", '%' );   scanf( "%d%d%d%d", &sorting, &caching, &work_stealing, &data_affinity );   fprintf( stdout, "%c %s %s %s %s/n/n", '%', ( sorting ? "TRUE" : "FALSE" ), ( caching ? "TRUE" : "FALSE" ), ( work_stealing ? "TRUE" : "FALSE" ), ( data_affinity ? ( data_affinity == 1 ? "FLASH_QUEUE_AFFINITY_2D_BLOCK_CYCLIC" : "FLASH_QUEUE_AFFINITY_OTHER" ) : "FLASH_QUEUE_AFFINITY_NONE" ) );#ifdef FLA_ENABLE_WINDOWS_BUILD   fprintf( stdout, "%s_%u = [/n", OUTPUT_FILE, nb_alg );#else   sprintf( output_file_m, "%s/%s_output.m", OUTPUT_PATH, OUTPUT_FILE );   fpp = fopen( output_file_m, "a" );   fprintf( fpp, "%%/n" );   fprintf( fpp, "%% | Matrix Size |    FLASH    |/n" );   fprintf( fpp, "%% |    n x n    |    GFlops   |/n" );   fprintf( fpp, "%% -----------------------------/n" );   fprintf( fpp, "%s_%u = [/n", OUTPUT_FILE, nb_alg );#endif   FLA_Init();   dtimes = ( double * ) FLA_malloc( n_repeats * sizeof( double ) );   flops  = ( double * ) FLA_malloc( n_trials  * sizeof( double ) );      FLASH_Queue_set_num_threads( n_threads );   FLASH_Queue_set_sorting( sorting );   FLASH_Queue_set_caching( caching );   FLASH_Queue_set_work_stealing( work_stealing );   FLASH_Queue_set_data_affinity( data_affinity );   for ( i = 0; i < n_trials; i++ )   {      size = begin + i * increment;            FLA_Obj_create( datatype, size, size, 0, 0, &A );      FLA_Obj_create( datatype, size, 1,    0, 0, &x );      FLA_Obj_create( datatype, size, 1,    0, 0, &b );      FLA_Obj_create( datatype, 1,    1,    0, 0, &b_norm );      for ( j = 0; j < n_repeats; j++ )      {         FLA_Random_matrix( A );         FLA_Random_matrix( b );         FLASH_Obj_create_hier_copy_of_flat( A, 1, &nb_alg, &AH );         FLASH_Obj_create( FLA_INT,    size, 1, 1, &nb_alg, &pH );         FLASH_Obj_create_hier_copy_of_flat( b, 1, &nb_alg, &bH );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    precision,    m_input, k_input, n_input,    m, k, n,    p_first, p_last, p_inc,    p,    n_repeats,    param_combo,    i,    n_param_combos = N_PARAM_COMBOS;    char *colors = "brkgmcbrkgmcbrkgmc";  char *ticks  = "o+*xso+*xso+*xso+*xs";  char m_dim_desc[14];  char k_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char k_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, Ad, Az, B, Bd, Bz, C, Cd, Cz, C_ref, indexd, indexz;  FLA_Obj alpha0d, alpha0z, alpha1d, alpha1z, normd, normz;  FLA_Obj alphad, alphaz, betad, betaz, rhod, rhoz;  FLA_Obj xd, xz, yd, yz;    FLA_Init( );  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m k n (-1 means bind to problem size): ", '%' );  scanf( "%d%d%d", &m_input, &k_input, &n_input );  fprintf( stdout, "%c %d %d %d/n", '%', m_input, k_input, n_input );  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( k_input >  0 ) {    sprintf( k_dim_desc, "k = %d", k_input );    sprintf( k_dim_tag,  "k%dc", k_input);  }  else if( k_input <  -1 ) {    sprintf( k_dim_desc, "k = p/%d", -k_input );    sprintf( k_dim_tag,  "k%dp", -k_input );  }  else if( k_input == -1 ) {    sprintf( k_dim_desc, "k = p" );    sprintf( k_dim_tag,  "k%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );    sprintf( n_dim_tag,  "n%dc", n_input);  }  else if( n_input <  -1 ) {    sprintf( n_dim_desc, "n = p/%d", -n_input );    sprintf( n_dim_tag,  "n%dp", -n_input );  }  else if( n_input == -1 ) {    sprintf( n_dim_desc, "n = p" );    sprintf( n_dim_tag,  "n%dp", 1 );  }  //precision = FLA_SINGLE_PRECISION;  precision = FLA_DOUBLE_PRECISION;  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    k = k_input;//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     datatype,    n_input,    mB_input, mC_input, mD_input,    mB, mC, mD, n,    p_first, p_last, p_inc,    p,    b_alg,    variant,    n_repeats,    i,    n_variants = 1;    double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    B, C, D, T, R, E;    FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c enter algorithmic blocksize:", '%' );  scanf( "%d", &b_alg );  fprintf( stdout, "%c %d/n", '%', b_alg );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter n (-1 means bind to problem size): ", '%' );  scanf( "%d", &n_input );  fprintf( stdout, "%c %d/n", '%', n_input );  fprintf( stdout, "%c enter mB mC mD (-1 means bind to problem size): ", '%' );  scanf( "%d %d %d", &mB_input, &mC_input, &mD_input );  fprintf( stdout, "%c %d %d %d/n", '%', mB_input, mC_input, mD_input );  fprintf( stdout, "/nclear all;/n/n" );  //datatype = FLA_FLOAT;  //datatype = FLA_DOUBLE;  //datatype = FLA_COMPLEX;  datatype = FLA_DOUBLE_COMPLEX;  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    mB = mB_input;    mC = mC_input;    mD = mD_input;    n  = n_input;    if( mB < 0 ) mB = p / abs(mB_input);    if( mC < 0 ) mC = p / abs(mC_input);    if( mD < 0 ) mD = p / abs(mD_input);    if( n  < 0 ) n  = p / abs(n_input);    for ( variant = 0; variant < n_variants; variant++ ){            FLA_Obj_create( datatype, mB, n, 0, 0, &B );      FLA_Obj_create( datatype, mC, n, 0, 0, &C );      FLA_Obj_create( datatype, mD, n, 0, 0, &D );      FLA_Obj_create( datatype, b_alg, n, 0, 0, &T );      FLA_Obj_create( datatype, n,  n, 0, 0, &R );      FLA_Obj_create( datatype, n,  n, 0, 0, &E );      FLA_Random_matrix( B );      FLA_Random_matrix( C );      FLA_Random_matrix( D );      FLA_Set( FLA_ZERO, R );      FLA_Herk_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE, FLA_ONE, B, FLA_ONE, R );      FLA_Herk_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE, FLA_ONE, D, FLA_ONE, R );      FLA_Chol( FLA_UPPER_TRIANGULAR, R );      FLA_Set( FLA_ZERO, E );      FLA_Herk_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE, FLA_ONE, B, FLA_ONE, E );      FLA_Herk_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE, FLA_ONE, C, FLA_ONE, E );      FLA_Chol( FLA_UPPER_TRIANGULAR, E );      fprintf( stdout, "data_uddate_ut( %d, 1:5 ) = [ %d  ", i, p );      fflush( stdout );      time_UDdate_UT( variant, FLA_ALG_FRONT, n_repeats, mB, mC, mD, n,                      B, C, D, T, R, E, &dtime, &diff, &gflops );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     m_input, n_input,    m, n,    p_first, p_last, p_inc,    p,    nb_alg,    variant,    n_repeats,    i, j,    datatype,    n_variants = 18;  int  sign;    int  blocksize[16];  char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, B, C, C_ref, scale, isgn, norm;    /* Initialize FLAME */  FLA_Init();  fprintf( stdout, "%c number of repeats:", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c Enter blocking size:", '%' );  scanf( "%d", &nb_alg );  fprintf( stdout, "%c %d/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc:", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c Enter sign (-1 or 1):", '%' );  scanf( "%d", &sign );  fprintf( stdout, "%c %d/n", '%', sign );  fprintf( stdout, "%c enter m n (-1 means bind to problem size): ", '%' );  scanf( "%d %d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  /* Delete all existing data structures */  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );    sprintf( n_dim_tag,  "n%dc", n_input);  }  else if( n_input <  -1 ) {    sprintf( n_dim_desc, "n = p/%d", -n_input );    sprintf( n_dim_tag,  "n%dp", -n_input );  }  else if( n_input == -1 ) {    sprintf( n_dim_desc, "n = p" );    sprintf( n_dim_tag,  "n%dp", 1 );  }  if ( 0 < sign )    isgn = FLA_ONE;  else    isgn = FLA_MINUS_ONE;  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int     m_input, n_input,    m, n,    p_first, p_last, p_inc,    p,    nb_alg,    n_repeats,    variant,    i, j,    datatype,    n_variants = N_VARIANTS;    char *colors = "brkgmcbrkg";  char *ticks  = "o+*xso+*xs";  char m_dim_desc[14];  char n_dim_desc[14];  char m_dim_tag[10];  char n_dim_tag[10];  double max_gflops=6.0;  double    dtime,    gflops,    diff;  FLA_Obj    A, B, C, C_ref;    /* Initialize FLAME */  FLA_Init( );  fprintf( stdout, "%c number of repeats: ", '%' );  scanf( "%d", &n_repeats );  fprintf( stdout, "%c %d/n", '%', n_repeats );  fprintf( stdout, "%c Enter blocking size: ", '%' );  scanf( "%d", &nb_alg );  fprintf( stdout, "%c %d/n", '%', nb_alg );  fprintf( stdout, "%c enter problem size first, last, inc: ", '%' );  scanf( "%d%d%d", &p_first, &p_last, &p_inc );  fprintf( stdout, "%c %d %d %d/n", '%', p_first, p_last, p_inc );  fprintf( stdout, "%c enter m n (-1 means bind to problem size): ", '%' );  scanf( "%d%d", &m_input, &n_input );  fprintf( stdout, "%c %d %d/n", '%', m_input, n_input );  /* Delete all existing data structures */  fprintf( stdout, "/nclear all;/n/n" );  if     ( m_input >  0 ) {    sprintf( m_dim_desc, "m = %d", m_input );    sprintf( m_dim_tag,  "m%dc", m_input);  }  else if( m_input <  -1 ) {    sprintf( m_dim_desc, "m = p/%d", -m_input );    sprintf( m_dim_tag,  "m%dp", -m_input );  }  else if( m_input == -1 ) {    sprintf( m_dim_desc, "m = p" );    sprintf( m_dim_tag,  "m%dp", 1 );  }  if     ( n_input >  0 ) {    sprintf( n_dim_desc, "n = %d", n_input );    sprintf( n_dim_tag,  "n%dc", n_input);  }  else if( n_input <  -1 ) {    sprintf( n_dim_desc, "n = p/%d", -n_input );    sprintf( n_dim_tag,  "n%dp", -n_input );  }  else if( n_input == -1 ) {    sprintf( n_dim_desc, "n = p" );    sprintf( n_dim_tag,  "n%dp", 1 );  }  for ( p = p_first, i = 1; p <= p_last; p += p_inc, i += 1 )  {    m = m_input;    n = n_input;    if( m < 0 ) m = p / abs(m_input);    if( n < 0 ) n = p / abs(n_input);    //datatype = FLA_COMPLEX;    datatype = FLA_DOUBLE_COMPLEX;    /* Allocate space for the matrices */    FLA_Obj_create( datatype, m, m, &A );    FLA_Obj_create( datatype, m, n, &C );    FLA_Obj_create( datatype, m, n, &C_ref );//.........这里部分代码省略.........

int main(int argc, char *argv[]){  int n, nfirst, nlast, ninc, nlast_unb, i, irep,    nrepeats, nb_alg;  double    dtime, dtime_best,     gflops, max_gflops,    diff, d_n;  FLA_Obj    A, Aref, Aold, delta;    /* Initialize FLAME */  FLA_Init( );  /* Every time trial is repeated "repeat" times and the fastest run in recorded */  printf( "%% number of repeats:" );  scanf( "%d", &nrepeats );  printf( "%% %d/n", nrepeats );  /* Enter the max GFLOPS attainable      This is used to set the y-axis range for the graphs. Here is how     you figure out what to enter (on Linux machines):     1) more /proc/cpuinfo   (this lists the contents of this file).     2) read through this and figure out the clock rate of the machine (in GHz).     3) Find out (from an expert of from the web) the number of floating point        instructions that can be performed per core per clock cycle.     4) Figure out if you are using "multithreaded BLAS" which automatically        parallelize calls to the Basic Linear Algebra Subprograms.  If so,        check how many cores are available.     5) Multiply 2) x 3) x 4) and enter this in response to the below.     If you enter a value for max GFLOPS that is lower that the maximum that     is observed in the experiments, then the top of the graph is set to the      observed maximum.  Thus, one possibility is to simply set this to 0.0.  */  printf( "%% enter max GFLOPS:" );  scanf( "%lf", &max_gflops );  printf( "%% %lf/n", max_gflops );  /* Enter the algorithmic block size */  printf( "%% enter nb_alg:" );  scanf( "%d", &nb_alg );  printf( "%% %d/n", nb_alg );  /* Timing trials for matrix sizes n=nfirst to nlast in increments      of ninc will be performed.  Unblocked versions are only tested to     nlast_unb */  printf( "%% enter nfirst, nlast, ninc, nlast_unb:" );  scanf( "%d%d%d%d", &nfirst, &nlast, &ninc, &nlast_unb );  printf( "%% %d %d %d %d/n", nfirst, nlast, ninc, nlast_unb );  i = 1;  for ( n=nfirst; n<= nlast; n+=ninc ){       /* Allocate space for the matrices */    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &A );    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &Aref );    FLA_Obj_create( FLA_DOUBLE, n, n, 1, n, &Aold );    FLA_Obj_create( FLA_DOUBLE, 1, 1, 1, 1, &delta );    /* Generate random matrix A and save in Aold */    FLA_Random_matrix( Aold );    /* Add something large to the diagonal to make sure it isn't ill-conditionsed */    d_n = ( double ) n;    *( ( double * ) FLA_Obj_buffer_at_view( delta ) ) = d_n;    FLA_Shift_diag( FLA_NO_CONJUGATE, delta, Aold );        /* Set gflops = billions of floating point operations that will be performed */    gflops = 1.0/3.0 * n * n * n * 1.0e-09;    /* Time the reference implementation */#if TIME_LAPACK == TRUE#else    //    if ( n <= nlast_unb )#endif    {      for ( irep=0; irep<nrepeats; irep++ ){	FLA_Copy( Aold, Aref );    	dtime = FLA_Clock();    	REF_Chol( TIME_LAPACK, Aref, nb_alg );    	dtime = FLA_Clock() - dtime;    	if ( irep == 0 ) 	  dtime_best = dtime;	else	  dtime_best = ( dtime < dtime_best ? dtime : dtime_best );      }        printf( "data_REF( %d, 1:2 ) = [ %d %le ];/n", i, n,	      gflops / dtime_best );      fflush( stdout );    }  //.........这里部分代码省略.........