Public Types
enum class	type_t { unknown , all_pot_sizes , default_sizes }

Public Member Functions
	inputfile_t (const string &fname)

Public Attributes
string	filename

vector< inputfile_entry_t >	entries

type_t	type

Member Enumeration Documentation

◆ type_t

enum inputfile_t::type_t

strong

Enumerator
unknown
all_pot_sizes
default_sizes

68 { unknown, all_pot_sizes, default_sizes };

Constructor & Destructor Documentation

◆ inputfile_t()

inputfile_t::inputfile_t ( const string & fname )

inline

                                    : 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);
     }
   }