ceph/src/boost/libs/random/performance/generate_table.cpp

   1 // generate_table.cpp
   2 //
   3 // Copyright (c) 2009
   4 // Steven Watanabe
   5 //
   6 // Distributed under the Boost Software License, Version 1.0. (See
   7 // accompanying file LICENSE_1_0.txt or copy at
   8 // http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #include <vector>
  11 #include <utility>
  12 #include <iostream>
  13 #include <cstring>
  14 #include <fstream>
  15 #include <boost/regex.hpp>
  16 #include <boost/tuple/tuple.hpp>
  17 #include <boost/lexical_cast.hpp>
  18 #include <boost/foreach.hpp>
  19 #include <boost/format.hpp>
  20 #include <boost/multi_index_container.hpp>
  21 #include <boost/multi_index/hashed_index.hpp>
  22 #include <boost/multi_index/sequenced_index.hpp>
  23
  24 boost::regex generator_regex("(?:fixed-range )?([^:]+): (\\d+(?:\\.\\d+)?) nsec/loop = \\d+(?:\\.\\d+)? CPU cycles");
  25 boost::regex distribution_regex("([^\\s]+)( virtual function)? ([^:]+): (\\d+(?:\\.\\d+)?) nsec/loop = \\d+(?:\\.\\d+)? CPU cycles");
  26
  27 std::string template_name(std::string arg) {
  28     return boost::regex_replace(arg, boost::regex("[^\\w]"), "_");
  29 }
  30
  31 struct compare_second {
  32     template<class Pair>
  33     bool operator()(const Pair& p1, const Pair& p2) const {
  34         return (p1.second < p2.second);
  35     }
  36 };
  37
  38 typedef boost::multi_index_container<
  39     std::string,
  40     boost::mpl::vector<
  41         boost::multi_index::sequenced<>,
  42         boost::multi_index::hashed_unique<boost::multi_index::identity<std::string> >
  43     >
  44 > unique_list;
  45
  46 int main(int argc, char** argv) {
  47
  48     std::string suffix;
  49     std::string id;
  50
  51     if(argc >= 2 && std::strcmp(argv[1], "-linux") == 0) {
  52         suffix = "linux";
  53         id = "Linux";
  54     } else  {
  55         suffix = "windows";
  56         id = "Windows";
  57     }
  58
  59     std::vector<std::pair<std::string, double> > generator_info;
  60     std::string line;
  61     while(std::getline(std::cin, line)) {
  62         boost::smatch match;
  63         if(std::strncmp(line.c_str(), "counting ", 9) == 0) break;
  64         if(boost::regex_match(line, match, generator_regex)) {
  65             std::string generator(match[1]);
  66             double time = boost::lexical_cast<double>(match[2]);
  67             if(generator != "counting") {
  68                 generator_info.push_back(std::make_pair(generator, time));
  69             }
  70         } else {
  71             std::cerr << "oops: " << line << std::endl;
  72         }
  73     }
  74
  75     double min = std::min_element(generator_info.begin(), generator_info.end(), compare_second())->second;
  76
  77     std::ofstream generator_defs("performance_data.qbk");
  78     std::ofstream generator_performance(("generator_performance_" + suffix + ".qbk").c_str());
  79     generator_performance << "[table Basic Generators (" << id << ")\n";
  80     generator_performance << "  [[generator] [M rn/sec] [time per random number \\[nsec\\]] "
  81                              "[relative speed compared to fastest \\[percent\\]]]\n";
  82
  83     typedef std::pair<std::string, double> pair_type;
  84     BOOST_FOREACH(const pair_type& pair, generator_info) {
  85         generator_defs << boost::format("[template %s_speed[] %d%%]\n")
  86             % template_name(pair.first) % static_cast<int>(100*min/pair.second);
  87         generator_performance << boost::format("  [[%s][%g][%g][%d%%]]\n")
  88             % pair.first % (1000/pair.second) % pair.second % static_cast<int>(100*min/pair.second);
  89     }
  90     generator_performance << "]\n";
  91
  92     std::map<std::pair<std::string, std::string>, double> distribution_info;
  93     unique_list generator_names;
  94     unique_list distribution_names;
  95     do {
  96         boost::smatch match;
  97         if(boost::regex_match(line, match, distribution_regex)) {
  98             if(!match[2].matched && match[1] != "counting") {
  99                 std::string generator(match[1]);
 100                 std::string distribution(match[3]);
 101                 double time = boost::lexical_cast<double>(match[4]);
 102                 generator_names.push_back(generator);
 103                 distribution_names.push_back(distribution);
 104                 distribution_info.insert(std::make_pair(std::make_pair(distribution, generator), time));
 105             }
 106         } else {
 107             std::cerr << "oops: " << line << std::endl;
 108         }
 109     } while(std::getline(std::cin, line));
 110
 111     std::ofstream distribution_performance(("distribution_performance_" + suffix + ".qbk").c_str());
 112
 113     distribution_performance << "[table Distributions (" << id << ")\n";
 114     distribution_performance << "  [[\\[M rn/sec\\]]";
 115     BOOST_FOREACH(const std::string& generator, generator_names) {
 116         distribution_performance << boost::format("[%s]") % generator;
 117     }
 118     distribution_performance << "]\n";
 119     BOOST_FOREACH(const std::string& distribution, distribution_names) {
 120         distribution_performance << boost::format("  [[%s]") % distribution;
 121         BOOST_FOREACH(const std::string& generator, generator_names) {
 122             std::map<std::pair<std::string, std::string>, double>::iterator pos =
 123                 distribution_info.find(std::make_pair(distribution, generator));
 124             if(pos != distribution_info.end()) {
 125                 distribution_performance << boost::format("[%g]") % (1000/pos->second);
 126             } else {
 127                 distribution_performance << "[-]";
 128             }
 129         }
 130         distribution_performance << "]\n";
 131     }
 132     distribution_performance << "]\n";
 133 }