为什么在提升精神中使用流会如此严重地惩罚性能呢？
我准备了一个小的基准程序来测量不同的解析方法。问题在于使用流和自定义函数将日期存储为time_t + double时性能大幅下降。
std :: string的奇怪的提升精神特性是因为搜索回溯用非匹配行的所有公共部分填充变量字符串，直到找到匹配的行。
对不起源代码质量（复制/粘贴，错误的变量名称，弱缩进...）。我知道这个基准代码不会包含在清洁代码书中，所以请忽略这个事实，让我们专注于这个主题。
我知道最快的方法是使用没有回溯的字符串，但是流的时间增量真的很奇怪。有人可以解释一下发生了什么吗？
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/repository/include/qi_seek.hpp>
#include <boost/chrono/chrono.hpp>
#include <iomanip>
#include <ctime>
typedef std::string::const_iterator It;
namespace structs {
struct Timestamp {
std::time_t date;
double ms;
friend std::istream& operator>> (std::istream& stream, Timestamp& time)
{
struct std::tm tm;
if (stream >> std::get_time(&tm, "%Y-%b-%d %H:%M:%S") >> time.ms)
time.date = std::mktime(&tm);
return stream;
}
};
struct Record1 {
std::string date;
double time;
std::string str;
};
struct Record2 {
Timestamp date;
double time;
std::string str;
};
typedef std::vector<Record1> Records1;
typedef std::vector<Record2> Records2;
}
BOOST_FUSION_ADAPT_STRUCT(structs::Record1,
(std::string, date)
(double, time)
(std::string, str))
BOOST_FUSION_ADAPT_STRUCT(structs::Record2,
(structs::Timestamp, date)
(double, time)
(std::string, str))
namespace boost { namespace spirit { namespace traits {
template <typename It>
struct assign_to_attribute_from_iterators<std::string, It, void> {
static inline void call(It f, It l, std::string& attr) {
attr = std::string(&*f, std::distance(f,l));
}
};
} } }
namespace qi = boost::spirit::qi;
namespace QiParsers {
template <typename It>
struct Parser1 : qi::grammar<It, structs::Record1()>
{
Parser1() : Parser1::base_type(start) {
using namespace qi;
start = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph]
>> eol;
}
private:
qi::rule<It, structs::Record1()> start;
};
template <typename It>
struct Parser2 : qi::grammar<It, structs::Record2()>
{
Parser2() : Parser2::base_type(start) {
using namespace qi;
start = '[' >> stream >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph]
>> eol;
}
private:
qi::rule<It, structs::Record2()> start;
};
template <typename It>
struct Parser3 : qi::grammar<It, structs::Records1()>
{
Parser3() : Parser3::base_type(start) {
using namespace qi;
using boost::phoenix::push_back;
line = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph];
ignore = *~char_("\r\n");
start = (line[push_back(_val, _1)] | ignore) % eol;
}
private:
qi::rule<It> ignore;
qi::rule<It, structs::Record1()> line;
qi::rule<It, structs::Records1()> start;
};
template <typename It>
struct Parser4 : qi::grammar<It, structs::Records2()>
{
Parser4() : Parser4::base_type(start) {
using namespace qi;
using boost::phoenix::push_back;
line = '[' >> stream >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph];
ignore = *~char_("\r\n");
start = (line[push_back(_val, _1)] | ignore) % eol;
}
private:
qi::rule<It> ignore;
qi::rule<It, structs::Record2()> line;
qi::rule<It, structs::Records2()> start;
};
}
template<typename Parser, typename Container>
Container parse_seek(It b, It e, const std::string& message)
{
static const Parser parser;
Container records;
boost::chrono::high_resolution_clock::time_point t0 = boost::chrono::high_resolution_clock::now();
parse(b, e, *boost::spirit::repository::qi::seek[parser], records);
boost::chrono::high_resolution_clock::time_point t1 = boost::chrono::high_resolution_clock::now();
auto elapsed = boost::chrono::duration_cast<boost::chrono::milliseconds>(t1 - t0);
std::cout << "Elapsed time: " << elapsed.count() << " ms (" << message << ")\n";
return records;
}
template<typename Parser, typename Container>
Container parse_ignoring(It b, It e, const std::string& message)
{
static const Parser parser;
Container records;
boost::chrono::high_resolution_clock::time_point t0 = boost::chrono::high_resolution_clock::now();
parse(b, e, parser, records);
boost::chrono::high_resolution_clock::time_point t1 = boost::chrono::high_resolution_clock::now();
auto elapsed = boost::chrono::duration_cast<boost::chrono::milliseconds>(t1 - t0);
std::cout << "Elapsed time: " << elapsed.count() << " ms (" << message << ")\n";
return records;
}
static const std::string input1 = "[2018-Mar-01 00:00:00.000000] - 1.000 s => String: Valid_string\n";
static const std::string input2 = "[2018-Mar-02 00:00:00.000000] - 2.000 s => I dont care\n";
static std::string input("");
int main() {
const int N1 = 10;
const int N2 = 100000;
input.reserve(N1 * (input1.size() + N2*input2.size()));
for (int i = N1; i--;)
{
input += input1;
for (int j = N2; j--;)
input += input2;
}
const auto records1 = parse_seek<QiParsers::Parser1<It>, structs::Records1>(input.begin(), input.end(), "std::string + seek");
const auto records2 = parse_seek<QiParsers::Parser2<It>, structs::Records2>(input.begin(), input.end(), "stream + seek");
const auto records3 = parse_ignoring<QiParsers::Parser3<It>, structs::Records1>(input.begin(), input.end(), "std::string + ignoring");
const auto records4 = parse_ignoring<QiParsers::Parser4<It>, structs::Records2>(input.begin(), input.end(), "stream + ignoring");
return 0;
}
控制台中的结果是：
Elapsed time: 1445 ms (std::string + seek)
Elapsed time: 21519 ms (stream + seek)
Elapsed time: 860 ms (std::string + ignoring)
Elapsed time: 19046 ms (stream + ignoring)
2 个答案:
答案 0 :(得分：3)
好的，在发布的代码中，70％¹的时间花在了流的下溢操作上。
我没有调查/为什么/那是，而是²写了一些天真的实现，看看我是否能做得更好。第一步：
²更新我自analyzed it以后提供了PR。
该PR所带来的改善并不会影响这一特定情况下的底线（参见摘要）
-
operator>>Timestamp（我们不会使用它） - 将
'[' >> stream >> ']'的所有实例替换为替代'[' >> raw[*~char_(']')] >> ']'，以便我们始终使用特征将迭代器范围转换为属性类型（std::string或Timestamp）
现在，我们实施assign_to_attribute_from_iterators<structs::Timestamp, It>特征：
变体1：数组源
template <typename It>
struct assign_to_attribute_from_iterators<structs::Timestamp, It, void> {
static inline void call(It f, It l, structs::Timestamp& time) {
boost::iostreams::stream<boost::iostreams::array_source> stream(f, l);
struct std::tm tm;
if (stream >> std::get_time(&tm, "%Y-%b-%d %H:%M:%S") >> time.ms)
time.date = std::mktime(&tm);
else throw "Parse failure";
}
};
使用callgrind进行性能分析：
（单击可缩放）
它确实有很大的改进，可能是因为我们假设底层的char缓冲区是连续的，Spirit实现不能做出这个假设。我们在time_get中花费了大约42％的时间。
粗略地说，25％的时间用于语言环境，其中一个令人担忧的 ~20％用于动态演员：（
变式2：具有重复使用的阵列源
相同，但重用静态流实例以查看它是否有显着差异：
static boost::iostreams::stream<boost::iostreams::array_source> s_stream;
template <typename It>
struct assign_to_attribute_from_iterators<structs::Timestamp, It, void> {
static inline void call(It f, It l, structs::Timestamp& time) {
struct std::tm tm;
if (s_stream.is_open()) s_stream.close();
s_stream.clear();
boost::iostreams::array_source as(f, l);
s_stream.open(as);
if (s_stream >> std::get_time(&tm, "%Y-%b-%d %H:%M:%S") >> time.ms)
time.date = std::mktime(&tm);
else throw "Parse failure";
}
};
分析显示没有显着差异。）
变式3：strptime和strtod / from_chars
让我们看看降级到C级是否会减少语言环境的影响：
template <typename It>
struct assign_to_attribute_from_iterators<structs::Timestamp, It, void> {
static inline void call(It f, It l, structs::Timestamp& time) {
struct std::tm tm;
auto remain = strptime(&*f, "%Y-%b-%d %H:%M:%S", &tm);
time.date = std::mktime(&tm);
#if __has_include(<charconv>) || __cpp_lib_to_chars >= 201611
auto result = std::from_chars(&*f, &*l, time.ms); // using <charconv> from c++17
#else
char* end;
time.ms = std::strtod(remain, &end);
assert(end > remain);
static_cast<void>(l); // unused
#endif
}
};
正如您所看到的，使用
strtod在这里有点不太理想。输入范围是有界的，但没有办法告诉strtod。我无法描述from_chars方法，因为它没有这个问题，所以这种方法更加安全。在实际使用示例代码时，使用
strtod是安全的，因为我们知道输入缓冲区是以NUL终止的。
在这里你可以看到解析日期时间仍然是一个值得关注的因素：
- mktime 15.58％
- strptime 40.54％
- strtod 5.88％
但总而言之，差异现在已经不那么严重了：
- Parser1：14.17％
- Parser2：43.44％
- Parser3：5.69％
- Parser4：35.49％
变式4：再次提升日期时间
有趣的是，“低级”C-API的性能与使用更高级别的Boost posix_time::ptime功能并不远：
template <typename It>
struct assign_to_attribute_from_iterators<structs::Timestamp, It, void> {
static inline void call(It f, It l, structs::Timestamp& time) {
time.date = to_time_t(boost::posix_time::time_from_string(std::string(f,l)));
}
};
这可能会牺牲一些精确度，according to the docs：
此处，解析日期和时间所花费的总时间为68％。解析器的相对速度接近最后的速度：
- Parser1：12.33％
- Parser2：43.86％
- Parser3：5.22％
- Parser4：37.43％
概要
总而言之，事实证明存储字符串似乎更快，即使你冒险分配更多。我已经做了一个非常简单的检查，通过增加子字符串的长度来确定这是否可以降到SSO：
static const std::string input1 = "[2018-Mar-01 00:01:02.012345 THWARTING THE SMALL STRING OPTIMIZATION HERE THIS WON'T FIT, NO DOUBT] - 1.000 s => String: Valid_string\n";
static const std::string input2 = "[2018-Mar-02 00:01:02.012345 THWARTING THE SMALL STRING OPTIMIZATION HERE THIS WON'T FIT, NO DOUBT] - 2.000 s => I dont care\n";
没有重大影响，因此离开解析本身。
很明显，您要么延迟解析时间（Parser3是最快的）或应该使用经过时间检验的Boost posix_time函数
LISTING
这是我使用的组合基准代码。一些事情发生了变化：
- 添加了一些健全性检查输出（以避免测试无意义的代码）
- 使迭代器通用（更改为
char*对优化构建中的性能没有显着影响） - 通过在正确的位置更改
#if 1至#if 0，可以在代码中手动切换上述变体
为方便起见， - 减少了N1 / N2
我自由地使用了C ++ 14，因为代码的目的是找到瓶颈。在分析后，任何获得的智慧都可以相对容易地向后移植。
<强> Live On Coliru
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/repository/include/qi_seek.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/chrono/chrono.hpp>
#include <iomanip>
#include <ctime>
#if __has_include(<charconv>) || __cpp_lib_to_chars >= 201611
# include <charconv> // not supported yet until GCC 8
#endif
namespace structs {
struct Timestamp {
std::time_t date;
double ms;
};
struct Record1 {
std::string date;
double time;
std::string str;
};
struct Record2 {
Timestamp date;
double time;
std::string str;
};
typedef std::vector<Record1> Records1;
typedef std::vector<Record2> Records2;
}
BOOST_FUSION_ADAPT_STRUCT(structs::Record1,
(std::string, date)
(double, time)
(std::string, str))
BOOST_FUSION_ADAPT_STRUCT(structs::Record2,
(structs::Timestamp, date)
(double, time)
(std::string, str))
namespace boost { namespace spirit { namespace traits {
template <typename It>
struct assign_to_attribute_from_iterators<std::string, It, void> {
static inline void call(It f, It l, std::string& attr) {
attr = std::string(&*f, std::distance(f,l));
}
};
static boost::iostreams::stream<boost::iostreams::array_source> s_stream;
template <typename It>
struct assign_to_attribute_from_iterators<structs::Timestamp, It, void> {
static inline void call(It f, It l, structs::Timestamp& time) {
#if 1
time.date = to_time_t(boost::posix_time::time_from_string(std::string(f,l)));
#elif 1
struct std::tm tm;
boost::iostreams::stream<boost::iostreams::array_source> stream(f, l);
if (stream >> std::get_time(&tm, "%Y-%b-%d %H:%M:%S") >> time.ms)
time.date = std::mktime(&tm);
else
throw "Parse failure";
#elif 1
struct std::tm tm;
if (s_stream.is_open()) s_stream.close();
s_stream.clear();
boost::iostreams::array_source as(f, l);
s_stream.open(as);
if (s_stream >> std::get_time(&tm, "%Y-%b-%d %H:%M:%S") >> time.ms)
time.date = std::mktime(&tm);
else
throw "Parse failure";
#else
struct std::tm tm;
auto remain = strptime(&*f, "%Y-%b-%d %H:%M:%S", &tm);
time.date = std::mktime(&tm);
#if __has_include(<charconv>) || __cpp_lib_to_chars >= 201611
auto result = std::from_chars(&*f, &*l, time.ms); // using <charconv> from c++17
#else
char* end;
time.ms = std::strtod(remain, &end);
assert(end > remain);
static_cast<void>(l); // unused
#endif
#endif
}
};
} } }
namespace qi = boost::spirit::qi;
namespace QiParsers {
template <typename It>
struct Parser1 : qi::grammar<It, structs::Record1()>
{
Parser1() : Parser1::base_type(start) {
using namespace qi;
start = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph]
>> eol;
}
private:
qi::rule<It, structs::Record1()> start;
};
template <typename It>
struct Parser2 : qi::grammar<It, structs::Record2()>
{
Parser2() : Parser2::base_type(start) {
using namespace qi;
start = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph]
>> eol;
}
private:
qi::rule<It, structs::Record2()> start;
};
template <typename It>
struct Parser3 : qi::grammar<It, structs::Records1()>
{
Parser3() : Parser3::base_type(start) {
using namespace qi;
using boost::phoenix::push_back;
line = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph];
ignore = *~char_("\r\n");
start = (line[push_back(_val, _1)] | ignore) % eol;
}
private:
qi::rule<It> ignore;
qi::rule<It, structs::Record1()> line;
qi::rule<It, structs::Records1()> start;
};
template <typename It>
struct Parser4 : qi::grammar<It, structs::Records2()>
{
Parser4() : Parser4::base_type(start) {
using namespace qi;
using boost::phoenix::push_back;
line = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph];
ignore = *~char_("\r\n");
start = (line[push_back(_val, _1)] | ignore) % eol;
}
private:
qi::rule<It> ignore;
qi::rule<It, structs::Record2()> line;
qi::rule<It, structs::Records2()> start;
};
}
template <typename Parser> static const Parser s_instance {};
template<template <typename> class Parser, typename Container, typename It>
Container parse_seek(It b, It e, const std::string& message)
{
Container records;
auto const t0 = boost::chrono::high_resolution_clock::now();
parse(b, e, *boost::spirit::repository::qi::seek[s_instance<Parser<It> >], records);
auto const t1 = boost::chrono::high_resolution_clock::now();
auto elapsed = boost::chrono::duration_cast<boost::chrono::milliseconds>(t1 - t0);
std::cout << "Elapsed time: " << elapsed.count() << " ms (" << message << ")\n";
return records;
}
template<template <typename> class Parser, typename Container, typename It>
Container parse_ignoring(It b, It e, const std::string& message)
{
Container records;
auto const t0 = boost::chrono::high_resolution_clock::now();
parse(b, e, s_instance<Parser<It> >, records);
auto const t1 = boost::chrono::high_resolution_clock::now();
auto elapsed = boost::chrono::duration_cast<boost::chrono::milliseconds>(t1 - t0);
std::cout << "Elapsed time: " << elapsed.count() << " ms (" << message << ")\n";
return records;
}
static const std::string input1 = "[2018-Mar-01 00:01:02.012345] - 1.000 s => String: Valid_string\n";
static const std::string input2 = "[2018-Mar-02 00:01:02.012345] - 2.000 s => I dont care\n";
std::string prepare_input() {
std::string input;
const int N1 = 10;
const int N2 = 1000;
input.reserve(N1 * (input1.size() + N2*input2.size()));
for (int i = N1; i--;) {
input += input1;
for (int j = N2; j--;)
input += input2;
}
return input;
}
int main() {
auto const input = prepare_input();
auto f = input.data(), l = f + input.length();
for (auto& r: parse_seek<QiParsers::Parser1, structs::Records1>(f, l, "std::string + seek")) {
std::cout << r.date << "\n";
break;
}
for (auto& r: parse_seek<QiParsers::Parser2, structs::Records2>(f, l, "stream + seek")) {
auto tm = *std::localtime(&r.date.date);
std::cout << std::put_time(&tm, "%Y-%b-%d %H:%M:%S") << "\n";
break;
}
for (auto& r: parse_ignoring<QiParsers::Parser3, structs::Records1>(f, l, "std::string + ignoring")) {
std::cout << r.date << "\n";
break;
}
for (auto& r: parse_ignoring<QiParsers::Parser4, structs::Records2>(f, l, "stream + ignoring")) {
auto tm = *std::localtime(&r.date.date);
std::cout << std::put_time(&tm, "%Y-%b-%d %H:%M:%S") << "\n";
break;
}
}
打印类似
的内容Elapsed time: 14 ms (std::string + seek)
2018-Mar-01 00:01:02.012345
Elapsed time: 29 ms (stream + seek)
2018-Mar-01 00:01:02
Elapsed time: 2 ms (std::string + ignoring)
2018-Mar-01 00:01:02.012345
Elapsed time: 22 ms (stream + ignoring)
2018-Mar-01 00:01:02
¹所有百分比均相对于总计划成本。那个 会使百分比出现偏差（如果不考虑非流解析器测试的话，提到的70％会更糟），但这些数字对于相对比较来说是一个足够好的指南在试运行中。
答案 1 :(得分：1)
stream解析器最终会这样做：
template <typename Iterator, typename Context
, typename Skipper, typename Attribute>
bool parse(Iterator& first, Iterator const& last
, Context& /*context*/, Skipper const& skipper
, Attribute& attr_) const
{
typedef qi::detail::iterator_source<Iterator> source_device;
typedef boost::iostreams::stream<source_device> instream;
qi::skip_over(first, last, skipper);
instream in(first, last); // copies 'first'
in >> attr_; // use existing operator>>()
// advance the iterator if everything is ok
if (in) {
if (!in.eof()) {
std::streamsize pos = in.tellg();
std::advance(first, pos);
} else {
first = last;
}
return true;
}
return false;
}
detail::iterator_source<Iterator>设备是一种昂贵的抽象，因为它需要是通用的。它需要能够支持前向迭代器¹。
专门用于随机访问迭代器
我创建了一个Pull Request来专门研究随机访问迭代器：https://github.com/boostorg/spirit/pull/383，它专门用于随机访问迭代器iterator_source：
std::streamsize read (char_type* s, std::streamsize n)
{
if (first == last)
return -1;
n = std::min(std::distance(first, last), n);
// copy_n is only part of c++11, so emulate it
std::copy(first, first + n, s);
first += n;
pos += n;
return n;
}
如果没有专业化，我们可以观察这些时间： Interactive Plot.ly
（100个样本，置信区间0.95）
benchmarking std::string + seek mean: 31.9222 ms std dev: 228.862 μs
benchmarking std::string + ignoring mean: 16.1855 ms std dev: 257.903 μs
benchmarking stream + seek mean: 1075.46 ms std dev: 22.23 ms
benchmarking stream + ignoring mean: 1064.41 ms std dev: 26.7218 ms
通过专业化，我们可以观察到这些时间： Interactive Plot.ly
benchmarking std::string + seek mean: 31.8703 ms std dev: 529.196 μs
benchmarking std::string + ignoring mean: 15.913 ms std dev: 848.514 μs
benchmarking stream + seek mean: 436.263 ms std dev: 19.4035 ms
benchmarking stream + ignoring mean: 419.539 ms std dev: 20.0511 ms
Nonius基准代码
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/repository/include/qi_seek.hpp>
#include <boost/chrono/chrono.hpp>
#include <iomanip>
#include <ctime>
namespace structs {
struct Timestamp {
std::time_t date;
double ms;
friend std::istream& operator>> (std::istream& stream, Timestamp& time)
{
struct std::tm tm;
if (stream >> std::get_time(&tm, "%Y-%b-%d %H:%M:%S") >> time.ms)
time.date = std::mktime(&tm);
return stream;
}
};
struct Record1 {
std::string date;
double time;
std::string str;
};
struct Record2 {
Timestamp date;
double time;
std::string str;
};
typedef std::vector<Record1> Records1;
typedef std::vector<Record2> Records2;
}
BOOST_FUSION_ADAPT_STRUCT(structs::Record1,
(std::string, date)
(double, time)
(std::string, str))
BOOST_FUSION_ADAPT_STRUCT(structs::Record2,
(structs::Timestamp, date)
(double, time)
(std::string, str))
namespace boost { namespace spirit { namespace traits {
template <typename It>
struct assign_to_attribute_from_iterators<std::string, It, void> {
static inline void call(It f, It l, std::string& attr) {
attr = std::string(&*f, std::distance(f,l));
}
};
} } }
namespace qi = boost::spirit::qi;
namespace QiParsers {
template <typename It>
struct Parser1 : qi::grammar<It, structs::Record1()>
{
Parser1() : Parser1::base_type(start) {
using namespace qi;
start = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph]
>> eol;
}
private:
qi::rule<It, structs::Record1()> start;
};
template <typename It>
struct Parser2 : qi::grammar<It, structs::Record2()>
{
Parser2() : Parser2::base_type(start) {
using namespace qi;
start = '[' >> stream >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph]
>> eol;
}
private:
qi::rule<It, structs::Record2()> start;
};
template <typename It>
struct Parser3 : qi::grammar<It, structs::Records1()>
{
Parser3() : Parser3::base_type(start) {
using namespace qi;
using boost::phoenix::push_back;
line = '[' >> raw[*~char_(']')] >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph];
ignore = *~char_("\r\n");
start = (line[push_back(_val, _1)] | ignore) % eol;
}
private:
qi::rule<It> ignore;
qi::rule<It, structs::Record1()> line;
qi::rule<It, structs::Records1()> start;
};
template <typename It>
struct Parser4 : qi::grammar<It, structs::Records2()>
{
Parser4() : Parser4::base_type(start) {
using namespace qi;
using boost::phoenix::push_back;
line = '[' >> stream >> ']'
>> " - " >> double_ >> " s"
>> " => String: " >> raw[+graph];
ignore = *~char_("\r\n");
start = (line[push_back(_val, _1)] | ignore) % eol;
}
private:
qi::rule<It> ignore;
qi::rule<It, structs::Record2()> line;
qi::rule<It, structs::Records2()> start;
};
}
typedef boost::chrono::high_resolution_clock::time_point time_point;
template<template <typename> class Parser, typename Container, typename It>
Container parse_seek(It b, It e, const std::string& message)
{
static const Parser<It> s_instance;
Container records;
time_point const t0 = boost::chrono::high_resolution_clock::now();
parse(b, e, *boost::spirit::repository::qi::seek[s_instance], records);
time_point const t1 = boost::chrono::high_resolution_clock::now();
std::cout << "Elapsed time: " << boost::chrono::duration_cast<boost::chrono::milliseconds>(t1 - t0).count() << " ms (" << message << ")\n";
return records;
}
template<template <typename> class Parser, typename Container, typename It>
Container parse_ignoring(It b, It e, const std::string& message)
{
static const Parser<It> s_instance;
Container records;
time_point const t0 = boost::chrono::high_resolution_clock::now();
parse(b, e, s_instance, records);
time_point const t1 = boost::chrono::high_resolution_clock::now();
std::cout << "Elapsed time: " << boost::chrono::duration_cast<boost::chrono::milliseconds>(t1 - t0).count() << " ms (" << message << ")\n";
return records;
}
static const std::string input1 = "[2018-Mar-01 00:01:02.012345] - 1.000 s => String: Valid_string\n";
static const std::string input2 = "[2018-Mar-02 00:01:02.012345] - 2.000 s => I dont care\n";
std::string prepare_input() {
std::string input;
const int N1 = 10;
const int N2 = 10000;
input.reserve(N1 * (input1.size() + N2*input2.size()));
for (int i = N1; i--;) {
input += input1;
for (int j = N2; j--;)
input += input2;
}
return input;
}
void verify(structs::Records1 const& records) {
if (records.empty())
std::cout << "Oops nothing parsed\n";
else {
structs::Record1 const& r = *records.begin();
std::cout << r.date << "\n";
}
}
void verify(structs::Records2 const& records) {
if (records.empty())
std::cout << "Oops nothing parsed\n";
else {
structs::Record2 const& r = *records.begin();
auto tm = *std::localtime(&r.date.date);
std::cout << std::put_time(&tm, "%Y-%b-%d %H:%M:%S") << " " << r.date.ms << "\n";
}
}
static std::string const input = prepare_input();
#define NONIUS_RUNNER
#include <nonius/benchmark.h++>
#include <nonius/main.h++>
NONIUS_BENCHMARK("std::string + seek", [] {
char const* f = input.data();
char const* l = f + input.length();
//std::string::const_iterator f = input.begin(), l = input.end();
verify(parse_seek<QiParsers::Parser1, structs::Records1>(f, l, "std::string + seek"));
})
NONIUS_BENCHMARK("stream + seek", [] {
char const* f = input.data();
char const* l = f + input.length();
//std::string::const_iterator f = input.begin(), l = input.end();
verify(parse_seek<QiParsers::Parser2, structs::Records2>(f, l, "stream + seek"));
})
NONIUS_BENCHMARK("std::string + ignoring", [] {
char const* f = input.data();
char const* l = f + input.length();
//std::string::const_iterator f = input.begin(), l = input.end();
verify(parse_ignoring<QiParsers::Parser3, structs::Records1>(f, l, "std::string + ignoring"));
})
NONIUS_BENCHMARK("stream + ignoring", [] {
char const* f = input.data();
char const* l = f + input.length();
//std::string::const_iterator f = input.begin(), l = input.end();
verify(parse_ignoring<QiParsers::Parser4, structs::Records2>(f, l, "stream + ignoring"));
})
¹，例如当解析器的迭代器碰巧是multi_pass_adaptor<InputIterator>时，它本身就是一个独立的怪物：Boost spirit memory leak
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？