text: /*
  
      Copyright (C) 2014, The University of Texas at Austin
  
      This file is part of libflame and is available under the 3-Clause
      BSD license, which can be found in the LICENSE file at the top-level
      directory, or at http://opensource.org/licenses/BSD-3-Clause
  
  */
  
  #include "FLAME.h"
  
  
  #define N_PARAM_COMBOS    4
  
  #define FLA_ALG_REFERENCE 0
  #define FLA_ALG_FRONT     1
  
  char* pc_str[N_PARAM_COMBOS] = { "ln", "lt",
                                   "un", "ut" };
  
  void time_Syrk(
                 int param_combo, int type, int n_repeats, int m, int k,
                 FLA_Obj A, FLA_Obj B, FLA_Obj C, FLA_Obj C_ref,
                 double *dtime, double *diff, double *gflops );
  
  
  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( "%lu", &nb_alg );
    fprintf( stdout, "%c %lu\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( "%lu", &n_threads );
    fprintf( stdout, "%c %lu\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_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;
      k = k_input;
  
      if( m < 0 ) m = p / f2c_abs(m_input);
      if( k < 0 ) k = p / f2c_abs(k_input);
  
      for ( param_combo = 0; param_combo < n_param_combos; param_combo++ ){
  
        // If transposing A, switch dimensions.
        if ( pc_str[param_combo][1] == 'n' )
          FLASH_Obj_create( datatype, m, k, 1, &nb_alg, &A );
        else
          FLASH_Obj_create( datatype, k, m, 1, &nb_alg, &A );
  
        FLASH_Obj_create( datatype, m, m, 1, &nb_alg, &C );
        FLASH_Obj_create( datatype, m, m, 1, &nb_alg, &C_ref );
  
        FLASH_Random_matrix( A );
        FLASH_Random_matrix( C );
  
        FLASH_Copy( C, C_ref );
        
        fprintf( stdout, "data_syrk_%s( %d, 1:5 ) = [ %d  ", pc_str[param_combo], i, p );
        fflush( stdout );
  
        time_Syrk( param_combo, FLA_ALG_REFERENCE, n_repeats, m, k,
                   A, B, C, C_ref, &dtime, &diff, &gflops );
  
        fprintf( stdout, "%6.3lf %6.2le ", gflops, diff );
        fflush( stdout );
  
        time_Syrk( param_combo, FLA_ALG_FRONT, n_repeats, m, k,
                   A, B, C, C_ref, &dtime, &diff, &gflops );
  
        fprintf( stdout, "%6.3lf %6.2le ", gflops, diff );
        fflush( stdout );
  
  
        fprintf( stdout, " ]; \n" );
        fflush( stdout );
  
        FLASH_Obj_free( &A );
        FLASH_Obj_free( &C );
        FLASH_Obj_free( &C_ref );
      }
  
      fprintf( stdout, "\n" );
    }
  
  /*
    fprintf( stdout, "figure;\n" );
  
    fprintf( stdout, "hold on;\n" );
  
    for ( i = 0; i < n_param_combos; i++ ) {
      fprintf( stdout, "plot( data_syrk_%s( :,1 ), data_syrk_%s( :, 2 ), '%c:%c' ); \n",
              pc_str[i], pc_str[i], colors[ i ], ticks[ i ] );
      fprintf( stdout, "plot( data_syrk_%s( :,1 ), data_syrk_%s( :, 4 ), '%c-.%c' ); \n",
              pc_str[i], pc_str[i], colors[ i ], ticks[ i ] );
    }
  
    fprintf( stdout, "legend( ... \n" );
  
    for ( i = 0; i < n_param_combos; i++ )
      fprintf( stdout, "'ref\\_syrk\\_%s', 'fla\\_syrk\\_%s', ... \n", pc_str[i], pc_str[i] );
  
    fprintf( stdout, "'Location', 'SouthEast' ); \n" );
  
  
    fprintf( stdout, "xlabel( 'problem size p' );\n" );
    fprintf( stdout, "ylabel( 'GFLOPS/sec.' );\n" );
    fprintf( stdout, "axis( [ 0 %d 0 %.2f ] ); \n", p_last, max_gflops );
    fprintf( stdout, "title( 'FLAME syrk front-end performance (%s, %s)' );\n",
             m_dim_desc, k_dim_desc );
    fprintf( stdout, "print -depsc syrk_front_%s_%s.eps\n", m_dim_tag, k_dim_tag );
    fprintf( stdout, "hold off;\n");
    fflush( stdout );
  */
  
    FLA_Finalize( );
  
    return 0;
  }
  
  