Qi Symbols性能降低? [英] Qi Symbols slow performance?
问题描述
我想提出一个主题，该主题将我送进了一个兔子洞，并提出了一个有关 qi ::符号.
I wanted to raise a subject that just sent me down a rabbit hole and brought up a question about qi::symbols.
It all started while I was looking into the new beast library and read a tutorial example
它以从HTTP路径猜测MIME类型的函数开始 扩展名.我开始更加仔细地观察，并看到了:
It starts with a function that guesses mime types from http path extensions. I started to look more closely and saw this:
auto const ext = [&path]
{
auto const pos = path.rfind(".");
if(pos == boost::beast::string_view::npos)
return boost::beast::string_view{};
return path.substr(pos);
}();
我花了一段时间才知道这是 IIFE 为C ++样式，用于在声明ext为常量的同时对其进行初始化.
It took me a while to figure out it was a IIFE in C++ style, and was used to initialize ext while declaring it constant.
无论如何，我开始测试这是否会对性能产生任何影响 将证明可怕的可读性与简单的实现是合理的.
Anyway, I started testing if this made any performance difference that would justify the horrible readability vs the straight forward implementation.
这样做是让我开始怀疑，这是否会更好地在以下环境中实现 qi ::符号.所以我想出了两种替代的实现方式:
Doing so I started wondering is this wouldn't be much better implemented in qi::symbols. So I came up with two alternative implementations:
#include <boost/smart_ptr/scoped_array.hpp>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/moment.hpp>
#include <boost/chrono.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_parse.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/assign.hpp>
#include <iostream>
#include <string>
#include <vector>
#include <random>
using namespace boost::accumulators;
typedef boost::chrono::duration<long long, boost::micro> microseconds;
namespace qi = boost::spirit::qi;
namespace karma = boost::spirit::karma;
namespace ascii = qi::ascii;
namespace phx = boost::phoenix;
const std::map<const std::string, const std::string> mime_exts = {
{ ".htm", "text/html" },
{ ".html", "text/html" },
{ ".php", "text/html" },
{ ".css", "text/css" },
{ ".js", "application/javascript" },
{ ".json", "application/json" },
{ ".xml", "application/xml" },
{ ".swf", "application/x-shockwave-flash" },
{ ".flv", "video/x-flv" },
{ ".png", "image/png" },
{ ".jpe", "image/jpeg" },
{ ".jpeg", "image/jpeg" },
{ ".jpg", "image/jpeg" },
{ ".gif", "image/gif" },
{ ".bmp", "image/bmp" },
{ ".ico", "image/vnd.microsoft.icon" },
{ ".tif", "image/tiff" },
{ ".tiff", "image/tiff" },
{ ".svg", "image/svg+xml"},
{ ".svgz", "image/svg+xml"}
};
const char *mime_literals[] = {
"text/html",
"text/css",
"text/plain",
"application/javascript",
"application/json",
"application/xml",
"application/x-shockwave-flash",
"video/x-flv",
"image/png",
"image/jpeg",
"image/gif",
"image/bmp",
"image/vnd.microsoft.icon",
"image/tiff",
"image/svg+xml"
};
template <typename Iterator>
struct mimetype_matching_parser : qi::grammar<Iterator, unsigned int()> {
mimetype_matching_parser() : mimetype_matching_parser::base_type(m_start, "mimetype_matching_parser") {
m_mime_extensions.add
(".htm", 0)
(".html", 0)
(".php", 0)
(".css", 1)
(".txt", 2)
(".js", 3)
(".json", 4)
(".xml", 5)
(".swf", 6)
(".flv", 7)
(".png", 8)
(".jpe", 9)
(".jpeg", 9)
(".jpg", 9)
(".gif", 10)
(".bmp", 11)
(".ico", 12)
(".tiff", 13)
(".tif", 13)
(".svg", 14)
(".svgz", 14)
;
using qi::no_case;
m_start %= no_case[m_mime_extensions] >> qi::eoi;
}
qi::symbols<char, unsigned int> m_mime_extensions;
qi::rule<Iterator, unsigned int()> m_start;
};
std::string mime_extension(const std::string &n_path) {
// First locate the extension itself
const std::size_t last_dot = n_path.rfind(".");
if (last_dot == std::string::npos) {
return "application/text";
}
// and now pipe the extension into a qi symbols parser.
// I don't know if this is any faster than a more trivial algorithm::ends_with
// approach but I guess it won't be any slower
const mimetype_matching_parser<std::string::const_iterator> p;
unsigned int result;
std::string::const_iterator begin = n_path.begin() + last_dot;
const std::string::const_iterator end = n_path.end();
try {
if (qi::parse(begin, end, p, result) && (begin == end)) {
return mime_literals[result];
} else {
return "application/text";
}
} catch (const std::exception &) { // asio throws on invalid parse
return "application/text";
}
}
std::string mime_extension2(const std::string &n_path) {
using boost::algorithm::iequals;
auto const ext = [&n_path] {
auto const pos = n_path.rfind(".");
if (pos == std::string::npos)
return std::string{};
return n_path.substr(pos);
}();
// const std::size_t pos = n_path.rfind(".");
// if (pos == std::string::npos) {
// return std::string{};
// }
// const std::string ext = n_path.substr(pos);
if (iequals(ext, ".htm")) return "text/html";
if (iequals(ext, ".html")) return "text/html";
if (iequals(ext, ".php")) return "text/html";
if (iequals(ext, ".css")) return "text/css";
if (iequals(ext, ".txt")) return "text/plain";
if (iequals(ext, ".js")) return "application/javascript";
if (iequals(ext, ".json")) return "application/json";
if (iequals(ext, ".xml")) return "application/xml";
if (iequals(ext, ".swf")) return "application/x-shockwave-flash";
if (iequals(ext, ".flv")) return "video/x-flv";
if (iequals(ext, ".png")) return "image/png";
if (iequals(ext, ".jpe")) return "image/jpeg";
if (iequals(ext, ".jpeg")) return "image/jpeg";
if (iequals(ext, ".jpg")) return "image/jpeg";
if (iequals(ext, ".gif")) return "image/gif";
if (iequals(ext, ".bmp")) return "image/bmp";
if (iequals(ext, ".ico")) return "image/vnd.microsoft.icon";
if (iequals(ext, ".tiff")) return "image/tiff";
if (iequals(ext, ".tif")) return "image/tiff";
if (iequals(ext, ".svg")) return "image/svg+xml";
if (iequals(ext, ".svgz")) return "image/svg+xml";
return "application/text";
}
std::string mime_extension3(const std::string &n_path) {
using boost::algorithm::iequals;
auto ext = [&n_path] {
auto const pos = n_path.rfind(".");
if (pos == std::string::npos) {
return std::string{};
} else {
return n_path.substr(pos);
}
}();
boost::algorithm::to_lower(ext);
const std::map<const std::string, const std::string>::const_iterator i = mime_exts.find(ext);
if (i != mime_exts.cend()) {
return i->second;
} else {
return "application/text";
}
}
const std::string samples[] = {
"test.txt",
"test.html",
"longer/test.tiff",
"www.webSite.de/ico.ico",
"www.websIte.de/longEr/path/ico.bmp",
"www.TEST.com/longer/path/ico.svg",
"googlecom/shoRT/path/index.HTM",
"googlecom/bild.jpg",
"WWW.FLASH.COM/app.swf",
"WWW.FLASH.COM/BILD.GIF"
};
int test_qi_impl() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 10);
const std::string sample = samples[dis(gen)];
const std::string result = mime_extension(sample);
int ret = dis(gen);
for (const char &c : result) { ret += c; }
return ret;
}
int test_lambda_impl() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 10);
const std::string sample = samples[dis(gen)];
const std::string result = mime_extension2(sample);
int ret = dis(gen);
for (const char &c : result) { ret += c; }
return ret;
}
int test_map_impl() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 10);
const std::string sample = samples[dis(gen)];
const std::string result = mime_extension3(sample);
int ret = dis(gen);
for (const char &c : result) { ret += c; }
return ret;
}
int main(int argc, char **argv) {
const unsigned int loops = 100000;
accumulator_set<boost::chrono::high_resolution_clock::duration, features<tag::mean> > times_qi;
accumulator_set<boost::chrono::high_resolution_clock::duration, features<tag::mean> > times_lambda;
accumulator_set<boost::chrono::high_resolution_clock::duration, features<tag::mean> > times_map;
std::cout << "Measure execution times for " << loops << " lambda runs" << std::endl;
for (unsigned int i = 0; i < loops; i++) {
boost::chrono::high_resolution_clock::time_point start = boost::chrono::high_resolution_clock::now();
test_lambda_impl();
boost::chrono::high_resolution_clock::time_point end = boost::chrono::high_resolution_clock::now();
times_lambda(end - start);
}
std::cout << "Measure execution times for " << loops << " qi runs" << std::endl;
for (unsigned int i = 0; i < loops; i++) {
boost::chrono::high_resolution_clock::time_point start = boost::chrono::high_resolution_clock::now();
test_qi_impl();
boost::chrono::high_resolution_clock::time_point end = boost::chrono::high_resolution_clock::now();
times_qi(end - start);
}
std::cout << "Measure execution times for " << loops << " map runs" << std::endl;
for (unsigned int i = 0; i < loops; i++) {
boost::chrono::high_resolution_clock::time_point start = boost::chrono::high_resolution_clock::now();
test_map_impl();
boost::chrono::high_resolution_clock::time_point end = boost::chrono::high_resolution_clock::now();
times_map(end - start);
}
std::cout << "Lambda runs took " << mean(times_lambda) << std::endl;
std::cout << "Qi runs took " << mean(times_qi) << std::endl;
std::cout << "Map runs took " << mean(times_map) << std::endl;
return EXIT_SUCCESS;
}
令我惊讶的是，lambda确实很重要(一点点).令我惊讶的是 更有什者，qi的实现要慢得多.
To my surprise, the lambda does matter (a little bit). What surprised me even more was that the qi implementation is much slower.
Measure execution times for 100000 lambda runs
Measure execution times for 100000 qi runs
Measure execution times for 100000 map runs
Lambda runs took 12443 nanoseconds
Qi runs took 15311 nanoseconds
Map runs took 10466 nanoseconds
尝试优化#1
首先，我使用的是这样的符号
Attempted Optimization #1
First, I was using symbols like this
template <typename Iterator>
struct mimetype_matching_parser : qi::grammar<Iterator, std::string()> {
mimetype_matching_parser() : mimetype_matching_parser::base_type(m_start,
"mimetype_matching_parser") {
m_mime_extensions.add
(".htm", "text/html")
(".html", "text/html")
(".php", "text/html")
(".css", "text/css")
(".svg", "whatever...")
;
using qi::no_case;
m_start %= no_case[m_mime_extensions] >> qi::eoi;
}
qi::symbols<char, std::string> m_mime_extensions;
qi::rule<Iterator, std::string()> m_start;
};
直接将字符串作为属性返回.一位同事指出 这是一个额外的std :: string副本，所以我对其进行了更改，因此它仅将索引返回给 静态字符数组:
That returned the string directly as attribute. A colleague pointed out that this is one extra std::string copy so I changed it so it only returns an index to a static char array:
const char *mime_literals[] = {
"text/html",
"text/css",
"text/plain",
// ... and so forth
};
template <typename Iterator>
struct mimetype_matching_parser : qi::grammar<Iterator, unsigned int()> {
mimetype_matching_parser() : mimetype_matching_parser::base_type(m_start, "mimetype_matching_parser")
{
m_mime_extensions.add
(".htm",0)
(".html",0)
(".php",0)
(".css",1)
(".svg",... etc.
;
using qi::no_case;
m_start %= no_case[m_mime_extensions] >> qi::eoi;
}
qi::symbols<char, unsigned int> m_mime_extensions;
qi::rule<Iterator, unsigned int()> m_start;
};
这有点快，但确实不值得一提.
This was a little bit faster but not really worth mentioning.
在我的笔记本电脑上，在释放"模式下，我得到: -野兽指南(Lambda)的平均运行时间为6200纳秒. -Qi的平均执行时间约为7100纳秒.
On my laptop, in Release mode, I am getting: - Beast Tutorial (Lambda) implementation averages at 6200 nanoseconds a run. - Qi implementation averages at about 7100 nanoseconds.
现在，这是我的第一个问题:为什么?
Now, that would be my first question: Why is that?
野兽"实现使我感到非常低效，因为它经历了所有 子字符串，每次都调用iequals，同时它可以缓存 小写.
The 'beast' implementation strikes me as very inefficient as it goes through all the substrings, calls iequals every time, while it would be able to cache the lowercase.
我认为qi肯定会对我添加到关键字中的关键字进行二进制搜索 符号解析器.但是看起来并不像这样.
I thought surely qi would do a binary search upon the keywords I added to a symbols parser. But is doesn't look like it does.
因此，我想出了自己的微不足道的实现，并使用带有 缓存的小写临时文件(请参见随附的源中的impl3).
So I came up with my own, also trivial implementation and use a static map with a cached lowercase temporary (see impl3 in attached source).
测试产生:
- 静态地图的平均运行时间约为2400纳秒
那么，我想问题是为什么?
我是否以某种方式滥用了qi::symbols?它实际上是否进行二进制搜索，但是
演出丢到其他地方了吗?
Am I misusing qi::symbols somehow? Does it actually do a binary search but
the performance is lost some other place?
斯蒂芬¹
(我在Windows MSVC14 64位上使用boost 1.66)
(I am on windows MSVC14 64 bits with boost 1.66)
(¹这个问题是从Spirit General邮件列表中改写的，该邮件列表在20180112T14:15CET上发布；
(¹ this question was paraphrased from the Spirit General mailing list, where it was posted 20180112T14:15CET; the online archives seem sadly broken)
推荐答案
Stephan Menzel在12-01-18 14:15写道:
On 12-01-18 14:15, Stephan Menzel wrote:
所以我想出了两种不同的实现.请找到 附带的来源.
So I came up with two different implementations. Please find the source attached.
我已经看过了.首先是一些肤浅的观察:
I've looked at it. A few superficial observations first:
-
您正在比较苹果和梨，因为Beast使用零拷贝字符串视图，而Qi不这样做.
You're comparing apples and pears, since Beast uses zero-copy string-views, where Qi doesn't.
此外，样本选择将调用UB，因为uniform_int_distribution(0,10)超出了样本数组的范围(应为(0, 9)).
Also, the sample selection invokes UB because uniform_int_distribution(0,10) is out of range for the sample array (should be (0, 9)).
最后，地图方法没有.txt扩展名的映射.
Lastly, the map approach didn't have a mapping for the .txt extension.
通过这些，我将测试程序简化/构造为以下内容:
With these out of the way I simplified/structured the test program to the following:
在我的系统上打印以下内容:
Prints the following on my system:
Lambda runs took 2319 nanoseconds
Qi runs took 2841 nanoseconds
Map runs took 193 nanoseconds
现在，最大的罪魁祸首是(显然吗?)您每次通过循环(编译规则)都在构造语法.当然没有必要了.删除将产生:
Now, the biggest culprit is (obviously?) that you're constructing the grammar each time through the loop (compiling the rules). Of course, there's no need. Removing that yields:
Lambda runs took 2676 nanoseconds
Qi runs took 98 nanoseconds
Map runs took 189 nanoseconds
这已经更快了，即使您在没有实际需要时仍在复制字符串.利用上面链接的答案的启发，我可能会这样写:
That's already faster, even though you're still copying strings when there's no actual need for it. Using the inspiration from the answer linked above, I'd probably write it like:
#include <boost/spirit/include/qi.hpp>
namespace qi_impl {
namespace qi = boost::spirit::qi;
struct mimetype_symbols_type : qi::symbols<char, char const*> {
mimetype_symbols_type() {
auto rev = [](string_view s) -> std::string { return { s.rbegin(), s.rend() }; };
this->add
(rev(".htm"), "text/html")
(rev(".html"), "text/html")
(rev(".php"), "text/html")
(rev(".css"), "text/css")
(rev(".txt"), "text/plain")
(rev(".js"), "application/javascript")
(rev(".json"), "application/json")
(rev(".xml"), "application/xml")
(rev(".swf"), "application/x-shockwave-flash")
(rev(".flv"), "video/x-flv")
(rev(".png"), "image/png")
(rev(".jpe"), "image/jpeg")
(rev(".jpeg"), "image/jpeg")
(rev(".jpg"), "image/jpeg")
(rev(".gif"), "image/gif")
(rev(".bmp"), "image/bmp")
(rev(".ico"), "image/vnd.microsoft.icon")
(rev(".tiff"), "image/tiff")
(rev(".tif"), "image/tiff")
(rev(".svg"), "image/svg+xml")
(rev(".svgz"), "image/svg+xml")
;
}
} static const mime_symbols;
char const* using_spirit(const string_view &n_path) {
char const* result = "application/text";
qi::parse(n_path.crbegin(), n_path.crend(), qi::no_case[mime_symbols], result);
return result;
}
}
您再也不需要为找到最后一个点"而费解，也不必检查匹配项是否在末尾"，您可以直接从符号中获取值.您可以根据需要随意分配string_view或std::string.
There is no more no need to muck with finding "the last dot" in the first place, no need to "check for the match being at the end", and you get the value directly from the symbols. You are free to assign to a string_view or a std::string as desired.
始终使用string_views(同时支持/显示std::string_view和boost::string_view).
Using string_views (both std::string_view and boost::string_view supported/shown) throughout.
请注意，这还显示了
map<>方法上使用的自定义比较器，只是为了证明知道映射键都是小写字母确实有好处. (实际上，这并不是因为它缓存了小写字母"，因为它只使用过一次！)
Note also this shows a custom comparator being used on the
map<>approach, just to prove that indeed there's a benefit from knowing that the map keys are all lower-case. (It's not, in fact, because it "cached the lowercase" since it's only used once!)
#include <boost/chrono.hpp>
#include <string>
#ifdef BOOST_STRING_VIEW
#include <boost/utility/string_view.hpp>
using string_view = boost::string_view;
#else
#include <string_view>
using string_view = std::string_view;
#endif
static auto constexpr npos = string_view::npos;
#include <boost/spirit/include/qi.hpp>
namespace qi_impl {
namespace qi = boost::spirit::qi;
struct mimetype_symbols_type : qi::symbols<char, char const*> {
mimetype_symbols_type() {
auto rev = [](string_view s) -> std::string { return { s.rbegin(), s.rend() }; };
this->add
(rev(".htm"), "text/html")
(rev(".html"), "text/html")
(rev(".php"), "text/html")
(rev(".css"), "text/css")
(rev(".txt"), "text/plain")
(rev(".js"), "application/javascript")
(rev(".json"), "application/json")
(rev(".xml"), "application/xml")
(rev(".swf"), "application/x-shockwave-flash")
(rev(".flv"), "video/x-flv")
(rev(".png"), "image/png")
(rev(".jpe"), "image/jpeg")
(rev(".jpeg"), "image/jpeg")
(rev(".jpg"), "image/jpeg")
(rev(".gif"), "image/gif")
(rev(".bmp"), "image/bmp")
(rev(".ico"), "image/vnd.microsoft.icon")
(rev(".tiff"), "image/tiff")
(rev(".tif"), "image/tiff")
(rev(".svg"), "image/svg+xml")
(rev(".svgz"), "image/svg+xml")
;
}
} static const mime_symbols;
char const* using_spirit(const string_view &n_path) {
char const* result = "application/text";
qi::parse(n_path.crbegin(), n_path.crend(), qi::no_case[mime_symbols], result);
return result;
}
}
#include <boost/algorithm/string.hpp>
namespace impl {
string_view using_iequals(const string_view &n_path) {
using boost::algorithm::iequals;
auto const ext = [&n_path] {
auto pos = n_path.rfind(".");
return pos != npos? n_path.substr(pos) : string_view {};
}();
if (iequals(ext, ".htm")) return "text/html";
if (iequals(ext, ".html")) return "text/html";
if (iequals(ext, ".php")) return "text/html";
if (iequals(ext, ".css")) return "text/css";
if (iequals(ext, ".txt")) return "text/plain";
if (iequals(ext, ".js")) return "application/javascript";
if (iequals(ext, ".json")) return "application/json";
if (iequals(ext, ".xml")) return "application/xml";
if (iequals(ext, ".swf")) return "application/x-shockwave-flash";
if (iequals(ext, ".flv")) return "video/x-flv";
if (iequals(ext, ".png")) return "image/png";
if (iequals(ext, ".jpe")) return "image/jpeg";
if (iequals(ext, ".jpeg")) return "image/jpeg";
if (iequals(ext, ".jpg")) return "image/jpeg";
if (iequals(ext, ".gif")) return "image/gif";
if (iequals(ext, ".bmp")) return "image/bmp";
if (iequals(ext, ".ico")) return "image/vnd.microsoft.icon";
if (iequals(ext, ".tiff")) return "image/tiff";
if (iequals(ext, ".tif")) return "image/tiff";
if (iequals(ext, ".svg")) return "image/svg+xml";
if (iequals(ext, ".svgz")) return "image/svg+xml";
return "application/text";
}
}
#include <boost/algorithm/string.hpp>
#include <map>
namespace impl {
struct CiCmp {
template <typename R1, typename R2>
bool operator()(R1 const& a, R2 const& b) const {
return boost::algorithm::ilexicographical_compare(a, b);
}
};
static const std::map<string_view, string_view, CiCmp> s_mime_exts_map {
{ ".txt", "text/plain" },
{ ".htm", "text/html" },
{ ".html", "text/html" },
{ ".php", "text/html" },
{ ".css", "text/css" },
{ ".js", "application/javascript" },
{ ".json", "application/json" },
{ ".xml", "application/xml" },
{ ".swf", "application/x-shockwave-flash" },
{ ".flv", "video/x-flv" },
{ ".png", "image/png" },
{ ".jpe", "image/jpeg" },
{ ".jpeg", "image/jpeg" },
{ ".jpg", "image/jpeg" },
{ ".gif", "image/gif" },
{ ".bmp", "image/bmp" },
{ ".ico", "image/vnd.microsoft.icon" },
{ ".tif", "image/tiff" },
{ ".tiff", "image/tiff" },
{ ".svg", "image/svg+xml"},
{ ".svgz", "image/svg+xml"},
};
string_view using_map(const string_view& n_path) {
auto const ext = [](string_view n_path) {
auto pos = n_path.rfind(".");
return pos != npos? n_path.substr(pos) : string_view {};
};
auto i = s_mime_exts_map.find(ext(n_path));
if (i != s_mime_exts_map.cend()) {
return i->second;
} else {
return "application/text";
}
}
}
#include <random>
namespace samples {
static string_view const s_samples[] = {
"test.txt",
"test.html",
"longer/test.tiff",
"www.webSite.de/ico.ico",
"www.websIte.de/longEr/path/ico.bmp",
"www.TEST.com/longer/path/ico.svg",
"googlecom/shoRT/path/index.HTM",
"googlecom/bild.jpg",
"WWW.FLASH.COM/app.swf",
"WWW.FLASH.COM/BILD.GIF"
};
std::mt19937 s_random_generator(std::random_device{}());
std::uniform_int_distribution<> s_dis(0, boost::size(s_samples) - 1);
string_view random_sample() {
return s_samples[s_dis(s_random_generator)];
}
}
#include <boost/functional/hash.hpp>
#include <iostream>
template <typename F>
int generic_test(F f) {
auto sample = samples::random_sample();
string_view result = f(sample);
//std::cout << "DEBUG " << sample << " -> " << result << "\n";
return boost::hash_range(result.begin(), result.end());
}
#include <boost/serialization/array_wrapper.hpp> // missing include in boost version on coliru
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics.hpp>
template <typename F>
auto benchmark(F f) {
using C = boost::chrono::high_resolution_clock;
using duration = C::duration;
const unsigned int loops = 100000;
namespace ba = boost::accumulators;
ba::accumulator_set<duration, ba::features<ba::tag::mean>> times;
for (unsigned int i = 0; i < loops; i++) {
auto start = C::now();
generic_test(f);
times(C::now() - start);
}
return ba::mean(times);
}
int main() {
std::cout << std::unitbuf;
std::cout << "Lambda runs took " << benchmark(impl::using_iequals) << std::endl;
std::cout << "Qi runs took " << benchmark(qi_impl::using_spirit) << std::endl;
std::cout << "Map runs took " << benchmark(impl::using_map) << std::endl;
}
打印
Lambda runs took 2470 nanoseconds
Qi runs took 119 nanoseconds
Map runs took 2239 nanoseconds // see Note above
这篇关于Qi Symbols性能降低?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
