Bug#364623: ICE: verify_flow_info failed
* Martin Michlmayr <tbm@cyrius.com> [2006-04-24 16:35]:
> > ../../src/alps/random/random.h: In member function 'void alps::BufferedRandomNumberGenerator<RNG>::seed() [with RNG = boost::random::lagged_fibonacci_01<double, 48, 607u, 273u>]':
> > ../../src/alps/random/random.h:143: error: too many outgoing branch edges from bb 4
> > ../../src/alps/random/random.h:143: internal compiler error: verify_flow_info failed
> > Please submit a full bug report,
The test case delta came up with is attached, but it's fairly large.
Also, this might be the same bug as PR26447. I've asked Andrew Pinski
in private whether he thinks they are the same bugs.
--
Martin Michlmayr
http://www.cyrius.com/
namespace std
{
template < class _T1, class _T2 > struct pair
{
};
}
extern "C"
{
extern "C"
{
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
struct _pthread_fastlock
{
}
pthread_mutexattr_t;
}
}
namespace std
{
struct __numeric_limits_base
{
};
template < typename _Tp >
struct numeric_limits:public __numeric_limits_base
{
static const bool is_integer = true;
};
};
typedef unsigned int uint32_t;
namespace std
{
template < typename _Alloc > class allocator;
template < class _CharT > struct char_traits;
template < typename _CharT, typename _Traits =
char_traits < _CharT >, typename _Alloc =
allocator < _CharT > >class basic_string;
typedef basic_string < char >string;
}
namespace __gnu_cxx
{
template < typename _Tp > class new_allocator
{
};
}
namespace std
{
template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <
_Tp >
{
};
template < typename _CharT, typename _Traits,
typename _Alloc > class basic_string
{
public:inline basic_string ();
basic_string (const _CharT * __s, const _Alloc & __a = _Alloc ());
};
}
namespace boost
{
template < class T > class integer_traits:public std::numeric_limits < T >
{
};
namespace detail
{
template < class T, T min_val, T max_val > class integer_traits_base
{
};
}
template <> class integer_traits < int >:public std::numeric_limits < int >,
public detail::integer_traits_base < int, (-2147483647 - 1), 2147483647 >
{
};
namespace random
{
template < class IntType, IntType m > class const_mod
{
public:static IntType add (IntType x, IntType c)
{
}
static IntType mult (IntType a, IntType x)
{
return mult_schrage (a, x);
}
static IntType mult_add (IntType a, IntType x, IntType c)
{
return add (mult (a, x), c);
}
static IntType mult_schrage (IntType a, IntType value)
{
for (;;)
{
if (value > 0)
break;
value += m;
}
}
};
template < class IntType, IntType a, IntType c, IntType m,
IntType val > class linear_congruential
{
public:typedef IntType result_type;
static const IntType modulus = m;
explicit linear_congruential (IntType x0 = 1):_modulus (modulus),
_x (_modulus ? (x0 % _modulus) :
x0)
{
}
IntType operator () ()
{
_x = const_mod < IntType, m >::mult_add (a, _x, c);
}
private:IntType _modulus;
IntType _x;
};
}
typedef random::linear_congruential < int32_t, 16807, 0, 2147483647,
1043618065 > minstd_rand0;
namespace random
{
namespace detail
{
template < class T > struct ptr_helper
{
typedef T value_type;
typedef T & reference_type;
typedef const T & rvalue_type;
static reference_type ref (T & r)
{
}
};
template < class T > struct ptr_helper <T & >
{
typedef T value_type;
typedef T & rvalue_type;
};
}
}
template < class UniformRandomNumberGenerator, class RealType =
double >class uniform_01
{
public:typedef UniformRandomNumberGenerator base_type;
typedef RealType result_type;
explicit uniform_01 (base_type rng):_rng (rng),
_factor (result_type (1) /
(result_type ((_rng.max) () - (_rng.min) ()) +
result_type (std::numeric_limits <
base_result >::is_integer ? 1 : 0)))
{
}
result_type operator () ()
{
return result_type (_rng () - (_rng.min) ()) * _factor;
}
private:typedef typename base_type::result_type base_result;
base_type _rng;
result_type _factor;
};
namespace random
{
namespace detail
{
template < class UniformRandomNumberGenerator >
class pass_through_engine
{
private:typedef ptr_helper < UniformRandomNumberGenerator >
helper_type;
public:typedef typename helper_type::value_type base_type;
typedef typename base_type::result_type result_type;
explicit pass_through_engine (UniformRandomNumberGenerator
rng):_rng (static_cast <
typename helper_type::
rvalue_type > (rng))
{
}
result_type min () const
{
}
result_type max () const
{
}
base_type & base ()
{
}
result_type operator () ()
{
return base ()();
}
private:UniformRandomNumberGenerator _rng;
};
}
template < class RealType, int w, unsigned int p,
unsigned int q > class lagged_fibonacci_01
{
public:typedef RealType result_type;
static const unsigned int long_lag = p;
lagged_fibonacci_01 ()
{
seed ();
}
public:void seed (uint32_t value = 331u)
{
minstd_rand0 intgen (value);
seed (intgen);
}
template < class Generator > void seed (Generator & gen)
{
typedef detail::pass_through_engine < Generator & >ref_gen;
uniform_01 < ref_gen, RealType > gen01 =
uniform_01 < ref_gen, RealType > (ref_gen (gen));
for (unsigned int j = 0; j < long_lag; ++j)
x[j] = gen01 ();
}
RealType x[long_lag];
};
}
typedef random::lagged_fibonacci_01 < double, 48, 607,
273 > lagged_fibonacci607;
namespace random
{
namespace detail
{
template < bool have_int, bool want_int > struct engine_helper;
template <> struct engine_helper <true, true >
{
template < class Engine, class DistInputType > struct impl
{
typedef pass_through_engine < Engine > type;
};
};
}
}
template < class Engine, class Distribution > class variate_generator
{
private:typedef random::detail::pass_through_engine < Engine >
decorated_engine;
public:typedef typename decorated_engine::base_type engine_value_type;
typedef Distribution distribution_type;
variate_generator (Engine e, Distribution d):_eng (decorated_engine (e)),
_dist (d)
{
}
private:enum
{
have_int =
std::numeric_limits <
typename decorated_engine::result_type >::is_integer, want_int =
std::numeric_limits < typename Distribution::input_type >::is_integer
};
typedef typename random::detail::engine_helper < have_int,
want_int >::template impl < decorated_engine,
typename Distribution::input_type >::type internal_engine_type;
internal_engine_type _eng;
distribution_type _dist;
};
template < class RealType = double >class uniform_real
{
public:typedef RealType input_type;
};
}
namespace alps
{
class BufferedRandomNumberGeneratorBase
{
};
template < class RNG >
class BufferedRandomNumberGenerator:public
BufferedRandomNumberGeneratorBase
{
public: BufferedRandomNumberGenerator ():rng_ (), gen_ (rng_,
boost::
uniform_real <> ())
{
}
protected: RNG rng_;
boost::variate_generator < RNG &, boost::uniform_real <> >gen_;
};
}
namespace boost
{
namespace detail
{
class sp_counted_base
{
};
class shared_count
{
private:sp_counted_base * pi_;
public:shared_count ():pi_ (0)
{
}
template < class Y > explicit shared_count (Y * p):pi_ (0)
{
}
};
}
template < class T > class shared_ptr
{
public:typedef T element_type;
template < class Y > explicit shared_ptr (Y * p):px (p), pn (p)
{
}
T *px;
detail::shared_count pn;
};
}
namespace std
{
template < typename _Key, typename _Tp, typename _Compare =
std::allocator < std::pair < const _Key, _Tp > > > class map
{
public:typedef _Key key_type;
typedef _Tp mapped_type;
mapped_type & operator[] (const key_type & __k)
{
}
};
}
namespace alps
{
namespace detail
{
template < class BASE > class abstract_creator
{
public:typedef BASE base_type;
virtual base_type *create () const = 0;
};
template < class BASE,
class T > class creator:public abstract_creator < BASE >
{
public:typedef BASE base_type;
base_type *create () const
{
return new T ();
}
};
}
template < class KEY, class BASE > class factory
{
public:typedef BASE base_type;
typedef KEY key_type;
typedef boost::shared_ptr < detail::abstract_creator < base_type >
>pointer_type;
template < class T > bool register_type (key_type k)
{
creators_[k] = pointer_type (new detail::creator < BASE, T > ());
}
private:typedef std::map < key_type, pointer_type > map_type;
map_type creators_;
};
class RNGFactory:public factory < std::string,
BufferedRandomNumberGeneratorBase >
{
public:RNGFactory ();
};
}
alps::RNGFactory::RNGFactory ()
{
register_type < BufferedRandomNumberGenerator < boost::lagged_fibonacci607 >
>("lagged_fibonacci607");
}
Reply to: