partition_action_t Struct Reference

Inheritance diagram for partition_action_t:

Public Member Functions
virtual const char *	invokation_name () const override
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 ()

Member Function Documentation

invokation_name()

virtual const char* partition_action_t::invokation_name ( ) const

inlineoverridevirtual

Reimplemented from action_t.

{ return "partition"; }

run()

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

inlineoverridevirtual

Reimplemented from action_t.

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

References inputfile_t::all_pot_sizes, check_all_files_in_same_exact_order(), inputfile_t::default_sizes, efficiency_of_partition(), find_partition_with_efficiency_higher_than(), i, print_partition(), Eigen::internal::repeat(), size, and inputfile_t::type.

---

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

• analyze-blocking-sizes.cpp