Re: [boost] Fixed point integer proposal

Subject: Re: [boost] Fixed point integer proposal
From: Christian Schladetsch (christian.schladetsch_at_[hidden])
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 <
christian.schladetsch_at_[hidden]> wrote:

>
>
>
>> 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.
>
>
>