Attached original translation unit and output of creduce. Reduction takes
significant time
so you can use it for benchmarking of algorithm improvements as well.
At present this one can be fully reduced in about 2 hours using an
i7-2600. Yang, see the attached output-- hopefully you can use this when
improving the C++ passes.
Originally, C-Reduce was designed to be slow and thorough. For me,
reduction speed doesn't matter since C-Reduce can be invoked offline by
the Csmith driver.
Of course these large C++ test cases represent a totally different use
case. Anyway, hopefully you guys don't mind too much waiting an hour or
two. I'm not sure it's very easy to do large reductions much faster than
that.
John
class A ;
template <class , class = A > class B;
template <class _TypeT, class _Allocator> class B {
public:
_TypeT value_type;
typedef _Allocator allocator_type;
};
template <class charT> class cpp_regex_traits;
template <class charT, class = cpp_regex_traits<charT> > struct I;
template <class charT> class cpp_regex_traits {
public:
typedef charT char_type;
};
template <class , class implementationT > struct I : implementationT { };
typedef enum { match_default }
match_flags;
template <class , class > class C {
public:
int& get_traits() ;
};
template <class , class = B<int >::allocator_type > class D;
template <class BidiIterator, class Allocator> class D {
public:
BidiIterator value_type;
typedef Allocator allocator_type;
};
class repeater_count {
public:
repeater_count(repeater_count** ) ;
};
template <class BidiIterator, class Allocator, class traits> class F {
public:
typedef typename traits::char_type char_type;
typedef F self_type;
typedef bool (self_type::*matcher_proc_type)();
F(BidiIterator , BidiIterator , D<BidiIterator, Allocator>& p3, C<char_type, traits>& p4, match_flags , BidiIterator ) : m_result(p3), re(p4), traits_inst(p4.get_traits()), rep_obj(0) { } bool find();
bool match_startmark();
bool match_endmark();
bool match_literal();
bool match_start_line();
bool match_end_line();
bool match_wild();
bool match_match();
bool match_word_boundary();
bool match_within_word();
bool match_word_start();
bool match_word_end();
bool match_buffer_start();
bool match_buffer_end();
bool match_backref();
bool match_long_set();
bool match_set();
bool match_jump();
bool match_alt();
bool match_rep();
bool match_combining();
bool match_soft_buffer_end();
bool match_restart_continue();
bool match_long_set_repeat();
bool match_set_repeat();
bool match_char_repeat();
bool match_dot_repeat_dispatch() ;
bool match_backstep();
bool match_assert_backref();
bool match_toggle_case();
bool match_recursion();
D<BidiIterator, Allocator>& m_result;
C<char_type, traits>& re;
int& traits_inst;
repeater_count rep_obj;
};
class G;
class H {
G* pdata;
unsigned GrepFiles( );
};
class G {
public:
C<char, I<char> > e;
};
match_flags c;
template <class BidiIterator, class Allocator, class traits> bool F<BidiIterator, Allocator, traits>::find() {
matcher_proc_type a[] = { (&F::match_startmark), &F::match_endmark, &F::match_literal, &F::match_start_line, &F::match_end_line, &F::match_wild, &F::match_match, &F::match_word_boundary, &F::match_within_word, &F::match_word_start, &F::match_word_end, &F::match_buffer_start, &F::match_buffer_end, &F::match_backref, &F::match_long_set, &F::match_set, &F::match_jump, &F::match_alt, &F::match_rep, &F::match_combining, &F::match_soft_buffer_end, &F::match_restart_continue, &F::match_dot_repeat_dispatch, &F::match_char_repeat, &F::match_set_repeat, &F::match_long_set_repeat, &F::match_backstep, &F::match_assert_backref, &F::match_toggle_case, &F::match_recursion };
}
template <class Predicate, class BidiIterator, class charT, class traits> int regex_grep(Predicate , BidiIterator p2, BidiIterator p3, C<charT, traits>& p4, match_flags ) {
typedef typename D<BidiIterator>::allocator_type match_allocator_type;
D<BidiIterator> m;
F<BidiIterator, match_allocator_type, traits> b(0,0, m, p4, match_default,0);
b.find() ;
}
unsigned H::GrepFiles( ) {
int d, e, r = regex_grep(0,0,1, pdata->e, c);
}
