Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 420 insertions, 0 deletions

diff --git a/src/boost/libs/regex/performance/table_helper.cpp b/src/boost/libs/regex/performance/table_helper.cpp
new file mode 100644
index 00000000..2ff40f1f
--- /dev/null
+++ b/src/boost/libs/regex/performance/table_helper.cpp
@@ -0,0 +1,420 @@
+//  Copyright John Maddock 2015.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifdef _MSC_VER
+#  pragma warning (disable : 4224)
+#endif
+
+#include <boost/regex.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/container_hash/hash.hpp>
+#include <vector>
+#include <set>
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+std::vector<std::vector<double> > data;
+
+inline std::string sanitize_string(const std::string& s)
+{
+   static const boost::regex e("[^a-zA-Z0-9]+");
+   std::string result = boost::regex_replace(s, e, "_");
+   while(result[0] == '_')
+      result.erase(0);
+   return result;
+}
+
+inline std::string sanitize_short_string(const std::string& s)
+{
+   unsigned id = boost::hash<std::string>()(s);
+   return sanitize_string("id" + boost::lexical_cast<std::string>(id));
+}
+
+std::string format_precision(double val, int digits)
+{
+   std::stringstream ss;
+   ss << std::setprecision(digits);
+   ss << std::fixed;
+   ss << val;
+   return ss.str();
+}
+
+static std::string content;
+boost::filesystem::path path_to_content;
+
+struct content_loader
+{
+   content_loader()
+   {
+      boost::filesystem::path p(__FILE__);
+      p = p.parent_path();
+      p /= "doc";
+      p /= "performance_tables.qbk";
+      path_to_content = p;
+      if(boost::filesystem::exists(p))
+      {
+         boost::filesystem::ifstream is(p);
+         if(is.good())
+         {
+            do
+            {
+               char c = static_cast<char>(is.get());
+               if(c != EOF)
+                  content.append(1, c);
+            } while(is.good());
+         }
+      }
+   }
+   ~content_loader()
+   {
+      boost::filesystem::ofstream os(path_to_content);
+      os << content;
+   }
+   void instantiate()const
+   {
+   }
+};
+
+static const content_loader loader;
+
+void load_table(std::vector<std::vector<std::string> >& table, std::string::const_iterator begin, std::string::const_iterator end)
+{
+   static const boost::regex item_e(
+      "\\["
+      "([^\\[\\]]*(?0)?)*"
+      "\\]"
+      );
+
+   boost::regex_token_iterator<std::string::const_iterator> i(begin, end, item_e), j;
+
+   while(i != j)
+   {
+      // Add a row:
+      table.push_back(std::vector<std::string>());
+      boost::regex_token_iterator<std::string::const_iterator> k(i->first + 1, i->second - 1, item_e);
+      while(k != j)
+      {
+         // Add a cell:
+         table.back().push_back(std::string(k->first + 1, k->second - 1));
+         ++k;
+      }
+      ++i;
+   }
+}
+
+std::string save_table(std::vector<std::vector<std::string> >& table)
+{
+   std::string result;
+
+   for(std::vector<std::vector<std::string> >::const_iterator i = table.begin(), j = table.end(); i != j; ++i)
+   {
+      result += "[";
+      for(std::vector<std::string>::const_iterator k = i->begin(), l = i->end(); k != l; ++k)
+      {
+         result += "[";
+         result += *k;
+         result += "]";
+      }
+      result += "]\n";
+   }
+   return result;
+}
+
+void add_to_all_sections(const std::string& id, std::string list_name = "performance_all_sections")
+{
+   std::string::size_type pos = content.find("[template " + list_name + "[]"), end_pos;
+   if(pos == std::string::npos)
+   {
+      //
+      // Just append to the end:
+      //
+      content.append("\n[template ").append(list_name).append("[]\n[").append(id).append("]\n]\n");
+   }
+   else
+   {
+      //
+      // Read in the all list of sections, add our new one (in alphabetical order),
+      // and then rewrite the whole thing:
+      //
+      static const boost::regex item_e(
+         "\\["
+         "((?=[^\\]])[^\\[\\]]*+(?0)?+)*+"
+         "\\]|\\]"
+         );
+      boost::regex_token_iterator<std::string::const_iterator> i(content.begin() + pos + 12 + list_name.size(), content.end(), item_e), j;
+      std::set<std::string> sections;
+      while(i != j)
+      {
+         if(i->length() == 1)
+         {
+            end_pos = i->first - content.begin();
+            break;
+         }
+         sections.insert(std::string(i->first + 1, i->second - 1));
+         ++i;
+      }
+      sections.insert(id);
+      std::string new_list = "\n";
+      for(std::set<std::string>::const_iterator sec = sections.begin(); sec != sections.end(); ++sec)
+      {
+         new_list += "[" + *sec + "]\n";
+      }
+      content.replace(pos + 12 + list_name.size(), end_pos - pos - 12 - list_name.size(), new_list);
+   }
+}
+
+std::string get_colour(boost::uintmax_t val, boost::uintmax_t best)
+{
+   if(val <= best * 1.2)
+      return "green";
+   if(val > best * 4)
+      return "red";
+   return "blue";
+}
+
+boost::intmax_t get_value_from_cell(const std::string& cell)
+{
+   static const boost::regex time_e("(\\d+)ns");
+   boost::smatch what;
+   if(regex_search(cell, what, time_e))
+   {
+      return boost::lexical_cast<boost::uintmax_t>(what.str(1));
+   }
+   return -1;
+}
+
+void add_cell(boost::intmax_t val, const std::string& table_name, const std::string& row_name, const std::string& column_heading)
+{
+   //
+   // Load the table, add our data, and re-write:
+   //
+   std::string table_id = "table_" + sanitize_string(table_name);
+   boost::regex table_e("\\[table:" + table_id
+      + "\\s(?:[^\\[]|\\\\.)++"
+      "((\\["
+      "((?:[^\\[\\]]|\\\\.)*+(?2)?+)*+"
+      "\\]\\s*+)*+\\s*+)"
+      "\\]"
+      );
+
+   boost::smatch table_location;
+   if(regex_search(content, table_location, table_e))
+   {
+      std::vector<std::vector<std::string> > table_data;
+      load_table(table_data, table_location[1].first, table_location[1].second);
+      //
+      // Figure out which column we're on:
+      //
+      unsigned column_id = 1001u;
+      for(unsigned i = 0; i < table_data[0].size(); ++i)
+      {
+         if(table_data[0][i] == column_heading)
+         {
+            column_id = i;
+            break;
+         }
+      }
+      if(column_id > 1000)
+      {
+         //
+         // Need a new column, must be adding a new compiler to the table!
+         //
+         table_data[0].push_back(column_heading);
+         for(unsigned i = 1; i < table_data.size(); ++i)
+            table_data[i].push_back(std::string());
+         column_id = table_data[0].size() - 1;
+      }
+      //
+      // Figure out the row:
+      //
+      unsigned row_id = 1001;
+      for(unsigned i = 1; i < table_data.size(); ++i)
+      {
+         if(table_data[i][0] == row_name)
+         {
+            row_id = i;
+            break;
+         }
+      }
+      if(row_id > 1000)
+      {
+         //
+         // Need a new row, add it now:
+         //
+         table_data.push_back(std::vector<std::string>());
+         table_data.back().push_back(row_name);
+         for(unsigned i = 1; i < table_data[0].size(); ++i)
+            table_data.back().push_back(std::string());
+         row_id = table_data.size() - 1;
+      }
+      //
+      // Find the best result in this row:
+      //
+      boost::uintmax_t best = (std::numeric_limits<boost::uintmax_t>::max)();
+      std::vector<boost::intmax_t> values;
+      for(unsigned i = 1; i < table_data[row_id].size(); ++i)
+      {
+         if(i == column_id)
+         {
+            if(val < best)
+               best = val;
+            values.push_back(val);
+         }
+         else
+         {
+            std::cout << "Existing cell value was " << table_data[row_id][i] << std::endl;
+            boost::uintmax_t cell_val = get_value_from_cell(table_data[row_id][i]);
+            std::cout << "Extracted value: " << cell_val << std::endl;
+            if(cell_val < best)
+               best = cell_val;
+            values.push_back(cell_val);
+         }
+      }
+      //
+      // Update the row:
+      //
+      for(unsigned i = 1; i < table_data[row_id].size(); ++i)
+      {
+         std::string& s = table_data[row_id][i];
+         s = "[role ";
+         if(values[i - 1] < 0)
+         {
+            s += "grey -]";
+         }
+         else
+         {
+            s += get_colour(values[i - 1], best);
+            s += " ";
+            s += format_precision(static_cast<double>(values[i - 1]) / best, 2);
+            s += "[br](";
+            s += boost::lexical_cast<std::string>(values[i - 1]) + "ns)]";
+         }
+      }
+      //
+      // Convert back to a string and insert into content:
+      std::sort(table_data.begin() + 1, table_data.end(), [](std::vector<std::string> const& a, std::vector<std::string> const& b) { return a[0] < b[0]; } );
+      std::string c = save_table(table_data);
+      content.replace(table_location.position(1), table_location.length(1), c);
+   }
+   else
+   {
+      //
+      // Create a new table and try again:
+      //
+      std::string new_table = "\n[template " + table_id;
+      new_table += "[]\n[table:" + table_id;
+      new_table += " ";
+      new_table += table_name;
+      new_table += "\n[[Expression[br]Text][";
+      new_table += column_heading;
+      new_table += "]]\n";
+      new_table += "[[";
+      new_table += row_name;
+      new_table += "][[role blue 1.00[br](";
+      new_table += boost::lexical_cast<std::string>(val);
+      new_table += "ns)]]]\n]\n]\n";
+
+      std::string::size_type pos = content.find("[/tables:]");
+      if(pos != std::string::npos)
+         content.insert(pos + 10, new_table);
+      else
+         content += "\n\n[/tables:]\n" + new_table;
+      //
+      // Add a section for this table as well:
+      //
+      std::string section_id = "section_" + sanitize_short_string(table_name);
+      if(content.find(section_id + "[]") == std::string::npos)
+      {
+         std::string new_section = "\n[template " + section_id + "[]\n[section:" + section_id + " " + table_name + "]\n[" + table_id + "]\n[endsect]\n]\n";
+         pos = content.find("[/sections:]");
+         if(pos != std::string::npos)
+            content.insert(pos + 12, new_section);
+         else
+            content += "\n\n[/sections:]\n" + new_section;
+         add_to_all_sections(section_id);
+      }
+      //
+      // Add to list of all tables (not in sections):
+      //
+      add_to_all_sections(table_id, "performance_all_tables");
+   }
+}
+
+void report_execution_time(double t, std::string table, std::string row, std::string heading)
+{
+   try {
+      add_cell(static_cast<boost::uintmax_t>(t / 1e-9), table, row, heading);
+   }
+   catch(const std::exception& e)
+   {
+      std::cout << "Error in adding cell: " << e.what() << std::endl;
+      throw;
+   }
+}
+
+std::string boost_name()
+{
+   return "boost " + boost::lexical_cast<std::string>(BOOST_VERSION / 100000) + "." + boost::lexical_cast<std::string>((BOOST_VERSION / 100) % 1000);
+}
+
+std::string compiler_name()
+{
+#ifdef COMPILER_NAME
+   return COMPILER_NAME;
+#else
+   return BOOST_COMPILER;
+#endif
+}
+
+std::string platform_name()
+{
+#ifdef _WIN32
+   return "Windows x64";
+#else
+   return BOOST_PLATFORM;
+#endif
+}
+
+
+std::string get_compiler_options_name()
+{
+#if defined(BOOST_MSVC) || defined(__ICL)
+   std::string result;
+#ifdef BOOST_MSVC
+   result = "cl ";
+#else
+   result = "icl ";
+#endif
+#ifdef _M_AMD64
+#ifdef __AVX__
+   result += "/arch:AVX /Ox";
+#else
+   result += "/Ox";
+#endif
+   result += " (x64 build)";
+#else
+#ifdef _DEBUG
+   result +=  "/Od";
+#elif defined(__AVX2__)
+   result += "/arch:AVX2 /Ox";
+#elif defined(__AVX__)
+   result += "/arch:AVX /Ox";
+#elif _M_IX86_FP == 2
+   result += "/arch:sse2 /Ox";
+#else
+   result += "/arch:ia32 /Ox";
+#endif
+   result += " (x86 build)";
+#endif
+   std::cout << "Compiler options are found as: " << result << std::endl;
+   return result;
+#else
+   return "Unknown";
+#endif
+}
+