evaluate_defaults_action_t Struct Reference

Inheritance diagram for evaluate_defaults_action_t:

Classes
struct	results_entry_t

Public Member Functions
virtual const char *	invokation_name () const override
void	show_usage_and_exit () const
virtual void	run (const vector< string > &input_filenames) const override
Public Member Functions inherited from action_t
virtual	~action_t ()
virtual void	run () const
virtual	~action_t ()

Static Public Member Functions
static bool	lower_efficiency (const results_entry_t &e1, const results_entry_t &e2)

Friends
ostream &	operator<< (ostream &s, const results_entry_t &entry)

Member Function Documentation

invokation_name()

virtual const char* evaluate_defaults_action_t::invokation_name ( ) const

inlineoverridevirtual

Reimplemented from action_t.

{ return "evaluate-defaults"; }

lower_efficiency()

static bool evaluate_defaults_action_t::lower_efficiency ( const results_entry_t &  e1, const results_entry_t &  e2  )

inlinestatic

                                                                                     {
    return e1.default_efficiency < e2.default_efficiency;
  }

References evaluate_defaults_action_t::results_entry_t::default_efficiency.

run()

virtual void evaluate_defaults_action_t::run ( const vector< string > &  input_filenames ) const

inlineoverridevirtual

Reimplemented from action_t.

                                                                         {
    if (input_filenames.size() != 2) {
      show_usage_and_exit();
    }
    inputfile_t inputfile_default_sizes(input_filenames[0]);
    inputfile_t inputfile_all_pot_sizes(input_filenames[1]);
    if (inputfile_default_sizes.type != inputfile_t::type_t::default_sizes) {
      cerr << inputfile_default_sizes.filename << " is not an input file with default sizes." << endl;
      show_usage_and_exit();
    }
    if (inputfile_all_pot_sizes.type != inputfile_t::type_t::all_pot_sizes) {
      cerr << inputfile_all_pot_sizes.filename << " is not an input file with all POT sizes." << endl;
      show_usage_and_exit();
    }
    vector<results_entry_t> results;
    vector<results_entry_t> cubic_results;
 
    uint16_t product_size = 0;
    auto it_all_pot_sizes = inputfile_all_pot_sizes.entries.begin();
    for (auto it_default_sizes = inputfile_default_sizes.entries.begin();
         it_default_sizes != inputfile_default_sizes.entries.end(); ++it_default_sizes) {
      if (it_default_sizes->product_size == product_size) {
        continue;
      }
      product_size = it_default_sizes->product_size;
      while (it_all_pot_sizes != inputfile_all_pot_sizes.entries.end() &&
             it_all_pot_sizes->product_size != product_size) {
        ++it_all_pot_sizes;
      }
      if (it_all_pot_sizes == inputfile_all_pot_sizes.entries.end()) {
        break;
      }
      uint16_t best_pot_block_size = 0;
      float best_pot_gflops = 0;
      for (auto it = it_all_pot_sizes; it != inputfile_all_pot_sizes.entries.end() && it->product_size == product_size;
           ++it) {
        if (it->gflops > best_pot_gflops) {
          best_pot_gflops = it->gflops;
          best_pot_block_size = it->pot_block_size;
        }
      }
      results_entry_t entry;
      entry.product_size = product_size;
      entry.default_block_size = it_default_sizes->nonpot_block_size;
      entry.best_pot_block_size = best_pot_block_size;
      entry.default_gflops = it_default_sizes->gflops;
      entry.best_pot_gflops = best_pot_gflops;
      entry.default_efficiency = entry.default_gflops / entry.best_pot_gflops;
      results.push_back(entry);
 
      size_triple_t t(product_size);
      if (t.k == t.m && t.m == t.n) {
        cubic_results.push_back(entry);
      }
    }
 
    cout << "All results:" << endl;
    for (auto it = results.begin(); it != results.end(); ++it) {
      cout << *it << endl;
    }
    cout << endl;
 
    sort(results.begin(), results.end(), lower_efficiency);
 
    const size_t n = min<size_t>(20, results.size());
    cout << n << " worst results:" << endl;
    for (size_t i = 0; i < n; i++) {
      cout << results[i] << endl;
    }
    cout << endl;
 
    cout << "cubic results:" << endl;
    for (auto it = cubic_results.begin(); it != cubic_results.end(); ++it) {
      cout << *it << endl;
    }
    cout << endl;
 
    sort(cubic_results.begin(), cubic_results.end(), lower_efficiency);
 
    cout.precision(2);
    vector<float> a = {0.5f, 0.20f, 0.10f, 0.05f, 0.02f, 0.01f};
    for (auto it = a.begin(); it != a.end(); ++it) {
      size_t n = min(results.size() - 1, size_t(*it * results.size()));
      cout << (100.0f * n / (results.size() - 1))
           << " % of product sizes have default efficiency <= " << 100.0f * results[n].default_efficiency << " %"
           << endl;
    }
    cout.precision(default_precision);
  }

References a, inputfile_t::all_pot_sizes, evaluate_defaults_action_t::results_entry_t::best_pot_block_size, evaluate_defaults_action_t::results_entry_t::best_pot_gflops, evaluate_defaults_action_t::results_entry_t::default_block_size, evaluate_defaults_action_t::results_entry_t::default_efficiency, evaluate_defaults_action_t::results_entry_t::default_gflops, default_precision, inputfile_t::default_sizes, inputfile_t::entries, inputfile_t::filename, i, lower_efficiency(), min, n, evaluate_defaults_action_t::results_entry_t::product_size, results, show_usage_and_exit(), plotPSD::t, and inputfile_t::type.

show_usage_and_exit()

void evaluate_defaults_action_t::show_usage_and_exit ( ) const

inline

                                   {
    cerr << "usage: " << invokation_name() << " default-sizes-data all-pot-sizes-data" << endl;
    cerr << "checks how well the performance with default sizes compares to the best "
         << "performance measured over all POT sizes." << endl;
    exit(1);
  }

Friends And Related Function Documentation

operator<<

ostream& operator<< ( ostream &  s, const results_entry_t &  entry  )

friend

                                                                       {
    return s << "Product size " << size_triple_t(entry.product_size) << ": default block size "
             << entry.default_block_size << " -> " << entry.default_gflops
             << " GFlop/s = " << entry.default_efficiency * 100.0f << " %"
             << " of best POT block size " << size_triple_t(entry.best_pot_block_size) << " -> "
             << entry.best_pot_gflops << " GFlop/s" << dec;
  }

---

The documentation for this struct was generated from the following file:

• analyze-blocking-sizes.cpp