# Boost :

Subject: Re: [boost] Fixed point integer proposal
Date: 2009-06-25 20:47:29

Just to make the case for fixed-point accuracy over flixed-point speed:

template <class Number>
Number work(size_t iterations, std::vector<Number> const &data)
{
Number sum = 0;
size_t size = data.size();
for (size_t i = 0; i < iterations; ++i)
{
Number a = data[i % size];
Number b = data[(i + 500)%size];
sum += a * b;
}
return sum;
}

BOOST_AUTO_TEST_CASE(test_floats)
{
size_t iterations = 1000*1000*100;
size_t outter = 1;//00;//0*1000*10;
double int_t = 0;
double float_t = 0;

size_t size = 100000;
std::vector<int> ints(size);
srand(42);
generate_n(ints.begin(), size, rand);
std::vector<float> floats(size);
srand(42);
generate_n(floats.begin(), size, rand);

boost::timer int_timer;
int int_sum = 0;
for (size_t n = 0; n < outter; ++n)
{
int_sum += work(iterations, ints);
}
int_t = int_timer.elapsed();
boost::timer float_timer;
float float_sum = 0;
for (size_t n = 0; n < outter; ++n)
{
float_sum += work(iterations, floats);
}
float_t = float_timer.elapsed();
cout << int_t << ", " << float_t << "; " << int_sum << ", " << float_sum
<< endl;
}

>>>>

1.103, 0.949; 129244096, 1.80144e+016

In this (slightly-less non-toy case), floats were a little bit faster. If
you actually used fixed-point here, rather than floats, then the difference
would be much larger again.

Regards,
Christian

On Fri, Jun 26, 2009 at 12:23 PM, Christian Schladetsch <

>
>
>
>> I just wrote a quick test with the following loop for some random
>> initialization values:
>>
>> for (int i = 0; i < iterations; ++i)
>> {
>> sum += a * b;
>> a += b;
>> }
>>
>> I used MSVC++ to compile.
>>
>> I set iterations to a billion. When I used ints I got around 800
>> ticks. When I used floats I got around 3700 ticks.
>>
>> That is almost a factor five. For my purposes, that's an optimization
>> I am willing to sacrifice a lot for.
>
>
> I just did the same test, with SSE2 enabled.
>
> int: 0.916 seconds, 1321730048
> float: 1.398 seconds, 4.5036e+015
>
> In this case, floats were 70% the speed of ints, but also gave a modicum of
> the correct result.
>
> The ints were faster but gave the incorrect result. Furthermore, this was
> ints not fixed-point. Would doing it using an actual fixed-point number make
> up the %30 difference? Perhaps, but it would still give the wrong result.
>
> I didn't mean to claim that fixed-point was "always slower than floating
> point" - especially for toy cases like this ints will be faster (if wrong)
> because there is nothing else for the CPU todo while the FPU is working.
>
> Add in some fetches or stores and I think you will get a far different
> result.
>
> In any case, I merely intended to make the point that one good reason for
> using fixed-point over floating point is accuracy and not necessarily speed.
>
>
> Regards,
> Christian.
>
>
>