boost :: spirit :: qi性能

Question

我有以下片段。

#include <iostream> 
#include <sstream> 
#include <chrono> 

#include <boost/spirit/include/qi.hpp> 
#include <boost/spirit/include/classic.hpp> 

namespace qi = boost::spirit::qi; 
namespace classic = boost::spirit::classic; 

template<typename T> 
void output_time(const T& end, const T& begin) 
{ 
    std::cout << std::chrono::duration_cast<std::chrono::seconds>(
     end - begin).count() << std::endl; 
} 

template<typename Iter> 
struct qi_grammar : public qi::grammar<Iter> 
{ 
    qi_grammar():qi_grammar::base_type(rule_) 
    { 
     rule_ = *string_; 
     string_ = qi::char_('"') >> *(qi::char_ - '"') >> qi::char_('"'); 
    } 
    qi::rule<Iter> rule_; 
    qi::rule<Iter> string_; 
}; 

template<typename Iter> 
struct classic_grammar : public classic::grammar<classic_grammar<Iter>> 
{ 
    template<typename ScannerT> 
    struct definition 
    { 
     definition(const classic_grammar&) 
     { 
     rule = *string_; 
     string_ = classic::ch_p('"') >> *(classic::anychar_p - '"') >> classic::ch_p('"'); 
     } 
     classic::rule<ScannerT> rule, string_; 
     const classic::rule<ScannerT>& start() const { return rule; } 
    }; 
}; 

template<typename Iter> 
void parse(Iter first, Iter last, const qi_grammar<Iter>& prs) 
{ 
    auto start = std::chrono::system_clock::now(); 
    for (int i = 0; i < 100; ++i) 
    { 
     Iter next = first; 
     if (!qi::parse(next, last, prs) || next != last) 
     { 
     assert(false); 
     } 
    } 
    auto finish = std::chrono::system_clock::now(); 
    output_time(finish, start); 
} 

template<typename Iter> 
void parse_c(Iter first, Iter last, const classic_grammar<Iter>& prs) 
{ 
    auto start = std::chrono::system_clock::now(); 
    for (int i = 0; i < 100; ++i) 
    { 
     auto info = classic::parse(first, last, prs); 
     if (!info.hit) assert(false); 
    } 
    auto finish = std::chrono::system_clock::now(); 
    output_time(finish, start); 
} 

int main() 
{ 
    qi_grammar<std::string::const_iterator> qi_lexeme; 
    classic_grammar<std::string::const_iterator> classic_lexeme; 
    std::stringstream ss; 
    for (int i = 0; i < 1024 * 500; ++i) 
    { 
     ss << "\"name\""; 
    } 
    const std::string s = ss.str(); 
    std::cout << "Size: " << s.size() << std::endl; 
    std::cout << "Qi" << std::endl; 
    parse(s.begin(), s.end(), qi_lexeme); 
    std::cout << "Classic" << std::endl; 
    parse_c(s.begin(), s.end(), classic_lexeme); 
} 

结果

forever@pterois:~/My_pro1/cpp_pro$ ./simple_j 
Size: 3072000 
Qi 
0 
Classic 
1 

所以，补气解析比传统快。但是，当我改变）string_规则性病属性::字符串（（即qi::rule<Iter, std::string()> string_;）我有

forever@pterois:~/My_pro1/cpp_pro$ ./simple_j 
Size: 3072000 
Qi 
19 
Classic 
1 

这是非常，非常缓慢。我做错了什么？谢谢。

编译器：gcc 4.6.3。提升 - 1.48.0。标志：-std = C++ 0x -O2。在LWS结果是相同的。语义动作为char_即

string_ = qi::char_('"') >> *(qi::char_[boost::bind(&some_f, _1)] - '"') 
>> qi::char_('"')[boost::bind(&some_clear_f, _1)]; 

使用率提高性能比较，但我正在寻找另一种解决方案也是如此，如果它的存在。

Answer 1

我想我在SO上回答了一个非常类似的问题。可悲的是，我找不到它。

简而言之，您可能更喜欢在源数据中使用迭代器，而不是在每次匹配时分配（并复制）字符串。

当使用

qi::rule<Iter, boost::iterator_range<Iter>()> string_; 
string_ = qi::raw [ qi::char_('"') >> *(qi::char_ - '"') >> qi::char_('"') ]; 

我得到了（有显着（16倍）更大的数据集）：

Size: 49152000 
Qi 
12 
Classic 
11 

事实上，改变规则本身后

string_ = qi::raw [ qi::lit('"') >> *~qi::char_('"') >> '"' ]; 

我得到

Size: 49152000 
Qi 
7 
Classic 
11 

所以......这是相当不错的，我想。看到它在LWS：http://liveworkspace.org/code/opA5s$0

为了完整起见，很明显，你可以做这样的事情

const std::string dummy("hello world"); 
auto r = boost::make_iterator_range(begin(dummy), end(dummy)); 
std::string asstring(r.begin(), r.end()); 

诀窍得到的iterator_range的字符串是延迟实际字符串建设需要时。您可能想要自动产生这个技巧。这是Spirit Lex对令牌属性所做的。你可能想看看。