| // This file is part of Eigen, a lightweight C++ template library |
| // for linear algebra. |
| // |
| // Copyright (C) 2015 Benoit Jacob <benoitjacob@google.com> |
| // |
| // This Source Code Form is subject to the terms of the Mozilla |
| // Public License v. 2.0. If a copy of the MPL was not distributed |
| // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. |
| |
| #include <iostream> |
| #include <cstdint> |
| #include <cstdlib> |
| #include <vector> |
| #include <algorithm> |
| #include <fstream> |
| #include <string> |
| #include <cmath> |
| #include <cassert> |
| #include <cstring> |
| #include <memory> |
| |
| #include <Eigen/Core> |
| |
| using namespace std; |
| |
| const int default_precision = 4; |
| |
| // see --only-cubic-sizes |
| bool only_cubic_sizes = false; |
| |
| // see --dump-tables |
| bool dump_tables = false; |
| |
| uint8_t log2_pot(size_t x) { |
| size_t l = 0; |
| while (x >>= 1) l++; |
| return l; |
| } |
| |
| uint16_t compact_size_triple(size_t k, size_t m, size_t n) |
| { |
| return (log2_pot(k) << 8) | (log2_pot(m) << 4) | log2_pot(n); |
| } |
| |
| // just a helper to store a triple of K,M,N sizes for matrix product |
| struct size_triple_t |
| { |
| uint16_t k, m, n; |
| size_triple_t() : k(0), m(0), n(0) {} |
| size_triple_t(size_t _k, size_t _m, size_t _n) : k(_k), m(_m), n(_n) {} |
| size_triple_t(const size_triple_t& o) : k(o.k), m(o.m), n(o.n) {} |
| size_triple_t(uint16_t compact) |
| { |
| k = 1 << ((compact & 0xf00) >> 8); |
| m = 1 << ((compact & 0x0f0) >> 4); |
| n = 1 << ((compact & 0x00f) >> 0); |
| } |
| bool is_cubic() const { return k == m && m == n; } |
| }; |
| |
| ostream& operator<<(ostream& s, const size_triple_t& t) |
| { |
| return s << "(" << t.k << ", " << t.m << ", " << t.n << ")"; |
| } |
| |
| struct inputfile_entry_t |
| { |
| uint16_t product_size; |
| uint16_t pot_block_size; |
| size_triple_t nonpot_block_size; |
| float gflops; |
| }; |
| |
| struct inputfile_t |
| { |
| enum class type_t { |
| unknown, |
| all_pot_sizes, |
| default_sizes |
| }; |
| |
| string filename; |
| vector<inputfile_entry_t> entries; |
| type_t type; |
| |
| inputfile_t(const string& fname) |
| : filename(fname) |
| , type(type_t::unknown) |
| { |
| ifstream stream(filename); |
| if (!stream.is_open()) { |
| cerr << "couldn't open input file: " << filename << endl; |
| exit(1); |
| } |
| string line; |
| while (getline(stream, line)) { |
| if (line.empty()) continue; |
| if (line.find("BEGIN MEASUREMENTS ALL POT SIZES") == 0) { |
| if (type != type_t::unknown) { |
| cerr << "Input file " << filename << " contains redundant BEGIN MEASUREMENTS lines"; |
| exit(1); |
| } |
| type = type_t::all_pot_sizes; |
| continue; |
| } |
| if (line.find("BEGIN MEASUREMENTS DEFAULT SIZES") == 0) { |
| if (type != type_t::unknown) { |
| cerr << "Input file " << filename << " contains redundant BEGIN MEASUREMENTS lines"; |
| exit(1); |
| } |
| type = type_t::default_sizes; |
| continue; |
| } |
| |
| |
| if (type == type_t::unknown) { |
| continue; |
| } |
| switch(type) { |
| case type_t::all_pot_sizes: { |
| unsigned int product_size, block_size; |
| float gflops; |
| int sscanf_result = |
| sscanf(line.c_str(), "%x %x %f", |
| &product_size, |
| &block_size, |
| &gflops); |
| if (3 != sscanf_result || |
| !product_size || |
| product_size > 0xfff || |
| !block_size || |
| block_size > 0xfff || |
| !isfinite(gflops)) |
| { |
| cerr << "ill-formed input file: " << filename << endl; |
| cerr << "offending line:" << endl << line << endl; |
| exit(1); |
| } |
| if (only_cubic_sizes && !size_triple_t(product_size).is_cubic()) { |
| continue; |
| } |
| inputfile_entry_t entry; |
| entry.product_size = uint16_t(product_size); |
| entry.pot_block_size = uint16_t(block_size); |
| entry.gflops = gflops; |
| entries.push_back(entry); |
| break; |
| } |
| case type_t::default_sizes: { |
| unsigned int product_size; |
| float gflops; |
| int bk, bm, bn; |
| int sscanf_result = |
| sscanf(line.c_str(), "%x default(%d, %d, %d) %f", |
| &product_size, |
| &bk, &bm, &bn, |
| &gflops); |
| if (5 != sscanf_result || |
| !product_size || |
| product_size > 0xfff || |
| !isfinite(gflops)) |
| { |
| cerr << "ill-formed input file: " << filename << endl; |
| cerr << "offending line:" << endl << line << endl; |
| exit(1); |
| } |
| if (only_cubic_sizes && !size_triple_t(product_size).is_cubic()) { |
| continue; |
| } |
| inputfile_entry_t entry; |
| entry.product_size = uint16_t(product_size); |
| entry.pot_block_size = 0; |
| entry.nonpot_block_size = size_triple_t(bk, bm, bn); |
| entry.gflops = gflops; |
| entries.push_back(entry); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| } |
| stream.close(); |
| if (type == type_t::unknown) { |
| cerr << "Unrecognized input file " << filename << endl; |
| exit(1); |
| } |
| if (entries.empty()) { |
| cerr << "didn't find any measurements in input file: " << filename << endl; |
| exit(1); |
| } |
| } |
| }; |
| |
| struct preprocessed_inputfile_entry_t |
| { |
| uint16_t product_size; |
| uint16_t block_size; |
| |
| float efficiency; |
| }; |
| |
| bool lower_efficiency(const preprocessed_inputfile_entry_t& e1, const preprocessed_inputfile_entry_t& e2) |
| { |
| return e1.efficiency < e2.efficiency; |
| } |
| |
| struct preprocessed_inputfile_t |
| { |
| string filename; |
| vector<preprocessed_inputfile_entry_t> entries; |
| |
| preprocessed_inputfile_t(const inputfile_t& inputfile) |
| : filename(inputfile.filename) |
| { |
| if (inputfile.type != inputfile_t::type_t::all_pot_sizes) { |
| abort(); |
| } |
| auto it = inputfile.entries.begin(); |
| auto it_first_with_given_product_size = it; |
| while (it != inputfile.entries.end()) { |
| ++it; |
| if (it == inputfile.entries.end() || |
| it->product_size != it_first_with_given_product_size->product_size) |
| { |
| import_input_file_range_one_product_size(it_first_with_given_product_size, it); |
| it_first_with_given_product_size = it; |
| } |
| } |
| } |
| |
| private: |
| void import_input_file_range_one_product_size( |
| const vector<inputfile_entry_t>::const_iterator& begin, |
| const vector<inputfile_entry_t>::const_iterator& end) |
| { |
| uint16_t product_size = begin->product_size; |
| float max_gflops = 0.0f; |
| for (auto it = begin; it != end; ++it) { |
| if (it->product_size != product_size) { |
| cerr << "Unexpected ordering of entries in " << filename << endl; |
| cerr << "(Expected all entries for product size " << hex << product_size << dec << " to be grouped)" << endl; |
| exit(1); |
| } |
| max_gflops = max(max_gflops, it->gflops); |
| } |
| for (auto it = begin; it != end; ++it) { |
| preprocessed_inputfile_entry_t entry; |
| entry.product_size = it->product_size; |
| entry.block_size = it->pot_block_size; |
| entry.efficiency = it->gflops / max_gflops; |
| entries.push_back(entry); |
| } |
| } |
| }; |
| |
| void check_all_files_in_same_exact_order( |
| const vector<preprocessed_inputfile_t>& preprocessed_inputfiles) |
| { |
| if (preprocessed_inputfiles.empty()) { |
| return; |
| } |
| |
| const preprocessed_inputfile_t& first_file = preprocessed_inputfiles[0]; |
| const size_t num_entries = first_file.entries.size(); |
| |
| for (size_t i = 0; i < preprocessed_inputfiles.size(); i++) { |
| if (preprocessed_inputfiles[i].entries.size() != num_entries) { |
| cerr << "these files have different number of entries: " |
| << preprocessed_inputfiles[i].filename |
| << " and " |
| << first_file.filename |
| << endl; |
| exit(1); |
| } |
| } |
| |
| for (size_t entry_index = 0; entry_index < num_entries; entry_index++) { |
| const uint16_t entry_product_size = first_file.entries[entry_index].product_size; |
| const uint16_t entry_block_size = first_file.entries[entry_index].block_size; |
| for (size_t file_index = 0; file_index < preprocessed_inputfiles.size(); file_index++) { |
| const preprocessed_inputfile_t& cur_file = preprocessed_inputfiles[file_index]; |
| if (cur_file.entries[entry_index].product_size != entry_product_size || |
| cur_file.entries[entry_index].block_size != entry_block_size) |
| { |
| cerr << "entries not in same order between these files: " |
| << first_file.filename |
| << " and " |
| << cur_file.filename |
| << endl; |
| exit(1); |
| } |
| } |
| } |
| } |
| |
| float efficiency_of_subset( |
| const vector<preprocessed_inputfile_t>& preprocessed_inputfiles, |
| const vector<size_t>& subset) |
| { |
| if (subset.size() <= 1) { |
| return 1.0f; |
| } |
| const preprocessed_inputfile_t& first_file = preprocessed_inputfiles[subset[0]]; |
| const size_t num_entries = first_file.entries.size(); |
| float efficiency = 1.0f; |
| size_t entry_index = 0; |
| size_t first_entry_index_with_this_product_size = 0; |
| uint16_t product_size = first_file.entries[0].product_size; |
| while (entry_index < num_entries) { |
| ++entry_index; |
| if (entry_index == num_entries || |
| first_file.entries[entry_index].product_size != product_size) |
| { |
| float efficiency_this_product_size = 0.0f; |
| for (size_t e = first_entry_index_with_this_product_size; e < entry_index; e++) { |
| float efficiency_this_entry = 1.0f; |
| for (auto i = subset.begin(); i != subset.end(); ++i) { |
| efficiency_this_entry = min(efficiency_this_entry, preprocessed_inputfiles[*i].entries[e].efficiency); |
| } |
| efficiency_this_product_size = max(efficiency_this_product_size, efficiency_this_entry); |
| } |
| efficiency = min(efficiency, efficiency_this_product_size); |
| if (entry_index < num_entries) { |
| first_entry_index_with_this_product_size = entry_index; |
| product_size = first_file.entries[entry_index].product_size; |
| } |
| } |
| } |
| |
| return efficiency; |
| } |
| |
| void dump_table_for_subset( |
| const vector<preprocessed_inputfile_t>& preprocessed_inputfiles, |
| const vector<size_t>& subset) |
| { |
| const preprocessed_inputfile_t& first_file = preprocessed_inputfiles[subset[0]]; |
| const size_t num_entries = first_file.entries.size(); |
| size_t entry_index = 0; |
| size_t first_entry_index_with_this_product_size = 0; |
| uint16_t product_size = first_file.entries[0].product_size; |
| size_t i = 0; |
| size_triple_t min_product_size(first_file.entries.front().product_size); |
| size_triple_t max_product_size(first_file.entries.back().product_size); |
| if (!min_product_size.is_cubic() || !max_product_size.is_cubic()) { |
| abort(); |
| } |
| if (only_cubic_sizes) { |
| cerr << "Can't generate tables with --only-cubic-sizes." << endl; |
| abort(); |
| } |
| cout << "struct LookupTable {" << endl; |
| cout << " static const size_t BaseSize = " << min_product_size.k << ";" << endl; |
| const size_t NumSizes = log2_pot(max_product_size.k / min_product_size.k) + 1; |
| const size_t TableSize = NumSizes * NumSizes * NumSizes; |
| cout << " static const size_t NumSizes = " << NumSizes << ";" << endl; |
| cout << " static const unsigned short* Data() {" << endl; |
| cout << " static const unsigned short data[" << TableSize << "] = {"; |
| while (entry_index < num_entries) { |
| ++entry_index; |
| if (entry_index == num_entries || |
| first_file.entries[entry_index].product_size != product_size) |
| { |
| float best_efficiency_this_product_size = 0.0f; |
| uint16_t best_block_size_this_product_size = 0; |
| for (size_t e = first_entry_index_with_this_product_size; e < entry_index; e++) { |
| float efficiency_this_entry = 1.0f; |
| for (auto i = subset.begin(); i != subset.end(); ++i) { |
| efficiency_this_entry = min(efficiency_this_entry, preprocessed_inputfiles[*i].entries[e].efficiency); |
| } |
| if (efficiency_this_entry > best_efficiency_this_product_size) { |
| best_efficiency_this_product_size = efficiency_this_entry; |
| best_block_size_this_product_size = first_file.entries[e].block_size; |
| } |
| } |
| if ((i++) % NumSizes) { |
| cout << " "; |
| } else { |
| cout << endl << " "; |
| } |
| cout << "0x" << hex << best_block_size_this_product_size << dec; |
| if (entry_index < num_entries) { |
| cout << ","; |
| first_entry_index_with_this_product_size = entry_index; |
| product_size = first_file.entries[entry_index].product_size; |
| } |
| } |
| } |
| if (i != TableSize) { |
| cerr << endl << "Wrote " << i << " table entries, expected " << TableSize << endl; |
| abort(); |
| } |
| cout << endl << " };" << endl; |
| cout << " return data;" << endl; |
| cout << " }" << endl; |
| cout << "};" << endl; |
| } |
| |
| float efficiency_of_partition( |
| const vector<preprocessed_inputfile_t>& preprocessed_inputfiles, |
| const vector<vector<size_t>>& partition) |
| { |
| float efficiency = 1.0f; |
| for (auto s = partition.begin(); s != partition.end(); ++s) { |
| efficiency = min(efficiency, efficiency_of_subset(preprocessed_inputfiles, *s)); |
| } |
| return efficiency; |
| } |
| |
| void make_first_subset(size_t subset_size, vector<size_t>& out_subset, size_t set_size) |
| { |
| assert(subset_size >= 1 && subset_size <= set_size); |
| out_subset.resize(subset_size); |
| for (size_t i = 0; i < subset_size; i++) { |
| out_subset[i] = i; |
| } |
| } |
| |
| bool is_last_subset(const vector<size_t>& subset, size_t set_size) |
| { |
| return subset[0] == set_size - subset.size(); |
| } |
| |
| void next_subset(vector<size_t>& inout_subset, size_t set_size) |
| { |
| if (is_last_subset(inout_subset, set_size)) { |
| cerr << "iterating past the last subset" << endl; |
| abort(); |
| } |
| size_t i = 1; |
| while (inout_subset[inout_subset.size() - i] == set_size - i) { |
| i++; |
| assert(i <= inout_subset.size()); |
| } |
| size_t first_index_to_change = inout_subset.size() - i; |
| inout_subset[first_index_to_change]++; |
| size_t p = inout_subset[first_index_to_change]; |
| for (size_t j = first_index_to_change + 1; j < inout_subset.size(); j++) { |
| inout_subset[j] = ++p; |
| } |
| } |
| |
| const size_t number_of_subsets_limit = 100; |
| const size_t always_search_subsets_of_size_at_least = 2; |
| |
| bool is_number_of_subsets_feasible(size_t n, size_t p) |
| { |
| assert(n>0 && p>0 && p<=n); |
| uint64_t numerator = 1, denominator = 1; |
| for (size_t i = 0; i < p; i++) { |
| numerator *= n - i; |
| denominator *= i + 1; |
| if (numerator > denominator * number_of_subsets_limit) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| size_t max_feasible_subset_size(size_t n) |
| { |
| assert(n > 0); |
| const size_t minresult = min<size_t>(n-1, always_search_subsets_of_size_at_least); |
| for (size_t p = 1; p <= n - 1; p++) { |
| if (!is_number_of_subsets_feasible(n, p+1)) { |
| return max(p, minresult); |
| } |
| } |
| return n - 1; |
| } |
| |
| void find_subset_with_efficiency_higher_than( |
| const vector<preprocessed_inputfile_t>& preprocessed_inputfiles, |
| float required_efficiency_to_beat, |
| vector<size_t>& inout_remainder, |
| vector<size_t>& out_subset) |
| { |
| out_subset.resize(0); |
| |
| if (required_efficiency_to_beat >= 1.0f) { |
| cerr << "can't beat efficiency 1." << endl; |
| abort(); |
| } |
| |
| while (!inout_remainder.empty()) { |
| |
| vector<size_t> candidate_indices(inout_remainder.size()); |
| for (size_t i = 0; i < candidate_indices.size(); i++) { |
| candidate_indices[i] = i; |
| } |
| |
| size_t candidate_indices_subset_size = max_feasible_subset_size(candidate_indices.size()); |
| while (candidate_indices_subset_size >= 1) { |
| vector<size_t> candidate_indices_subset; |
| make_first_subset(candidate_indices_subset_size, |
| candidate_indices_subset, |
| candidate_indices.size()); |
| |
| vector<size_t> best_candidate_indices_subset; |
| float best_efficiency = 0.0f; |
| vector<size_t> trial_subset = out_subset; |
| trial_subset.resize(out_subset.size() + candidate_indices_subset_size); |
| while (true) |
| { |
| for (size_t i = 0; i < candidate_indices_subset_size; i++) { |
| trial_subset[out_subset.size() + i] = inout_remainder[candidate_indices_subset[i]]; |
| } |
| |
| float trial_efficiency = efficiency_of_subset(preprocessed_inputfiles, trial_subset); |
| if (trial_efficiency > best_efficiency) { |
| best_efficiency = trial_efficiency; |
| best_candidate_indices_subset = candidate_indices_subset; |
| } |
| if (is_last_subset(candidate_indices_subset, candidate_indices.size())) { |
| break; |
| } |
| next_subset(candidate_indices_subset, candidate_indices.size()); |
| } |
| |
| if (best_efficiency > required_efficiency_to_beat) { |
| for (size_t i = 0; i < best_candidate_indices_subset.size(); i++) { |
| candidate_indices[i] = candidate_indices[best_candidate_indices_subset[i]]; |
| } |
| candidate_indices.resize(best_candidate_indices_subset.size()); |
| } |
| candidate_indices_subset_size--; |
| } |
| |
| size_t candidate_index = candidate_indices[0]; |
| auto candidate_iterator = inout_remainder.begin() + candidate_index; |
| vector<size_t> trial_subset = out_subset; |
| |
| trial_subset.push_back(*candidate_iterator); |
| float trial_efficiency = efficiency_of_subset(preprocessed_inputfiles, trial_subset); |
| if (trial_efficiency > required_efficiency_to_beat) { |
| out_subset.push_back(*candidate_iterator); |
| inout_remainder.erase(candidate_iterator); |
| } else { |
| break; |
| } |
| } |
| } |
| |
| void find_partition_with_efficiency_higher_than( |
| const vector<preprocessed_inputfile_t>& preprocessed_inputfiles, |
| float required_efficiency_to_beat, |
| vector<vector<size_t>>& out_partition) |
| { |
| out_partition.resize(0); |
| |
| vector<size_t> remainder; |
| for (size_t i = 0; i < preprocessed_inputfiles.size(); i++) { |
| remainder.push_back(i); |
| } |
| |
| while (!remainder.empty()) { |
| vector<size_t> new_subset; |
| find_subset_with_efficiency_higher_than( |
| preprocessed_inputfiles, |
| required_efficiency_to_beat, |
| remainder, |
| new_subset); |
| out_partition.push_back(new_subset); |
| } |
| } |
| |
| void print_partition( |
| const vector<preprocessed_inputfile_t>& preprocessed_inputfiles, |
| const vector<vector<size_t>>& partition) |
| { |
| float efficiency = efficiency_of_partition(preprocessed_inputfiles, partition); |
| cout << "Partition into " << partition.size() << " subsets for " << efficiency * 100.0f << "% efficiency" << endl; |
| for (auto subset = partition.begin(); subset != partition.end(); ++subset) { |
| cout << " Subset " << (subset - partition.begin()) |
| << ", efficiency " << efficiency_of_subset(preprocessed_inputfiles, *subset) * 100.0f << "%:" |
| << endl; |
| for (auto file = subset->begin(); file != subset->end(); ++file) { |
| cout << " " << preprocessed_inputfiles[*file].filename << endl; |
| } |
| if (dump_tables) { |
| cout << " Table:" << endl; |
| dump_table_for_subset(preprocessed_inputfiles, *subset); |
| } |
| } |
| cout << endl; |
| } |
| |
| struct action_t |
| { |
| virtual const char* invokation_name() const { abort(); return nullptr; } |
| virtual void run(const vector<string>&) const { abort(); } |
| virtual ~action_t() {} |
| }; |
| |
| struct partition_action_t : action_t |
| { |
| virtual const char* invokation_name() const override { return "partition"; } |
| virtual void run(const vector<string>& input_filenames) const override |
| { |
| vector<preprocessed_inputfile_t> preprocessed_inputfiles; |
| |
| if (input_filenames.empty()) { |
| cerr << "The " << invokation_name() << " action needs a list of input files." << endl; |
| exit(1); |
| } |
| |
| for (auto it = input_filenames.begin(); it != input_filenames.end(); ++it) { |
| inputfile_t inputfile(*it); |
| switch (inputfile.type) { |
| case inputfile_t::type_t::all_pot_sizes: |
| preprocessed_inputfiles.emplace_back(inputfile); |
| break; |
| case inputfile_t::type_t::default_sizes: |
| cerr << "The " << invokation_name() << " action only uses measurements for all pot sizes, and " |
| << "has no use for " << *it << " which contains measurements for default sizes." << endl; |
| exit(1); |
| break; |
| default: |
| cerr << "Unrecognized input file: " << *it << endl; |
| exit(1); |
| } |
| } |
| |
| check_all_files_in_same_exact_order(preprocessed_inputfiles); |
| |
| float required_efficiency_to_beat = 0.0f; |
| vector<vector<vector<size_t>>> partitions; |
| cerr << "searching for partitions...\r" << flush; |
| while (true) |
| { |
| vector<vector<size_t>> partition; |
| find_partition_with_efficiency_higher_than( |
| preprocessed_inputfiles, |
| required_efficiency_to_beat, |
| partition); |
| float actual_efficiency = efficiency_of_partition(preprocessed_inputfiles, partition); |
| cerr << "partition " << preprocessed_inputfiles.size() << " files into " << partition.size() |
| << " subsets for " << 100.0f * actual_efficiency |
| << " % efficiency" |
| << " \r" << flush; |
| partitions.push_back(partition); |
| if (partition.size() == preprocessed_inputfiles.size() || actual_efficiency == 1.0f) { |
| break; |
| } |
| required_efficiency_to_beat = actual_efficiency; |
| } |
| cerr << " " << endl; |
| while (true) { |
| bool repeat = false; |
| for (size_t i = 0; i < partitions.size() - 1; i++) { |
| if (partitions[i].size() >= partitions[i+1].size()) { |
| partitions.erase(partitions.begin() + i); |
| repeat = true; |
| break; |
| } |
| } |
| if (!repeat) { |
| break; |
| } |
| } |
| for (auto it = partitions.begin(); it != partitions.end(); ++it) { |
| print_partition(preprocessed_inputfiles, *it); |
| } |
| } |
| }; |
| |
| struct evaluate_defaults_action_t : action_t |
| { |
| struct results_entry_t { |
| uint16_t product_size; |
| size_triple_t default_block_size; |
| uint16_t best_pot_block_size; |
| float default_gflops; |
| float best_pot_gflops; |
| float default_efficiency; |
| }; |
| friend ostream& operator<<(ostream& s, const results_entry_t& entry) |
| { |
| 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; |
| } |
| static bool lower_efficiency(const results_entry_t& e1, const results_entry_t& e2) { |
| return e1.default_efficiency < e2.default_efficiency; |
| } |
| virtual const char* invokation_name() const override { return "evaluate-defaults"; } |
| void show_usage_and_exit() const |
| { |
| 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); |
| } |
| virtual void run(const vector<string>& input_filenames) const override |
| { |
| 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); |
| } |
| }; |
| |
| |
| void show_usage_and_exit(int argc, char* argv[], |
| const vector<unique_ptr<action_t>>& available_actions) |
| { |
| cerr << "usage: " << argv[0] << " <action> [options...] <input files...>" << endl; |
| cerr << "available actions:" << endl; |
| for (auto it = available_actions.begin(); it != available_actions.end(); ++it) { |
| cerr << " " << (*it)->invokation_name() << endl; |
| } |
| cerr << "the input files should each contain an output of benchmark-blocking-sizes" << endl; |
| exit(1); |
| } |
| |
| int main(int argc, char* argv[]) |
| { |
| cout.precision(default_precision); |
| cerr.precision(default_precision); |
| |
| vector<unique_ptr<action_t>> available_actions; |
| available_actions.emplace_back(new partition_action_t); |
| available_actions.emplace_back(new evaluate_defaults_action_t); |
| |
| vector<string> input_filenames; |
| |
| action_t* action = nullptr; |
| |
| if (argc < 2) { |
| show_usage_and_exit(argc, argv, available_actions); |
| } |
| for (int i = 1; i < argc; i++) { |
| bool arg_handled = false; |
| // Step 1. Try to match action invocation names. |
| for (auto it = available_actions.begin(); it != available_actions.end(); ++it) { |
| if (!strcmp(argv[i], (*it)->invokation_name())) { |
| if (!action) { |
| action = it->get(); |
| arg_handled = true; |
| break; |
| } else { |
| cerr << "can't specify more than one action!" << endl; |
| show_usage_and_exit(argc, argv, available_actions); |
| } |
| } |
| } |
| if (arg_handled) { |
| continue; |
| } |
| // Step 2. Try to match option names. |
| if (argv[i][0] == '-') { |
| if (!strcmp(argv[i], "--only-cubic-sizes")) { |
| only_cubic_sizes = true; |
| arg_handled = true; |
| } |
| if (!strcmp(argv[i], "--dump-tables")) { |
| dump_tables = true; |
| arg_handled = true; |
| } |
| if (!arg_handled) { |
| cerr << "Unrecognized option: " << argv[i] << endl; |
| show_usage_and_exit(argc, argv, available_actions); |
| } |
| } |
| if (arg_handled) { |
| continue; |
| } |
| // Step 3. Default to interpreting args as input filenames. |
| input_filenames.emplace_back(argv[i]); |
| } |
| |
| if (dump_tables && only_cubic_sizes) { |
| cerr << "Incompatible options: --only-cubic-sizes and --dump-tables." << endl; |
| show_usage_and_exit(argc, argv, available_actions); |
| } |
| |
| if (!action) { |
| show_usage_and_exit(argc, argv, available_actions); |
| } |
| |
| action->run(input_filenames); |
| } |
