Blog: Playing with the CPU pipeline: poly.cpp

#include <chrono>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <cassert>

using namespace std;

double sin1(double x) __attribute__((noinline));
double sin2(double x) __attribute__((noinline));
double sin3(double x) __attribute__((noinline));
double sin4(double x) __attribute__((noinline));
double sin5(double x) __attribute__((noinline));
double sin6(double x) __attribute__((noinline));
double sin7(double x) __attribute__((noinline));

static double const a0 = +1.0;
static double const a1 = -1.666666666666580809419428987894207e-1;
static double const a2 = +8.333333333262716094425037738346873e-3;
static double const a3 = -1.984126982005911439283646346964929e-4;
static double const a4 = +2.755731607338689220657382272783309e-6;
static double const a5 = -2.505185130214293595900283001271652e-8;
static double const a6 = +1.604729591825977403374012010065495e-10;
static double const a7 = -7.364589573262279913270651228486670e-13;

double sin1(double x)
{
    return x * a0
         + x * x * x * a1
         + x * x * x * x * x * a2
         + x * x * x * x * x * x * x * a3
         + x * x * x * x * x * x * x * x * x * a4
         + x * x * x * x * x * x * x * x * x * x * x * a5
         + x * x * x * x * x * x * x * x * x * x * x * x * x * a6
         + x * x * x * x * x * x * x * x * x * x * x * x * x * x * x * a7;
}

double sin2(double x)
{
    double ret = 0.0;
    double y = x;
    double x2 = x * x;
    ret += a0 * y; y *= x2;
    ret += a1 * y; y *= x2;
    ret += a2 * y; y *= x2;
    ret += a3 * y; y *= x2;
    ret += a4 * y; y *= x2;
    ret += a5 * y; y *= x2;
    ret += a6 * y; y *= x2;
    ret += a7 * y;
    return ret;
}

double sin3(double x)
{
    double x2 = x * x;
    return x * (a0 + x2 * (a1 + x2 * (a2 + x2 * (a3 + x2 * (a4 + x2 * (a5 + x2 * (a6 + x2 * a7)))))));
}

double sin4(double x)
{
    double x2 = x * x;
    double x4 = x2 * x2;
    double A = a0 + x4 * (a2 + x4 * (a4 + x4 * a6));
    double B = a1 + x4 * (a3 + x4 * (a5 + x4 * a7));
    return x * (A + x2 * B);
}

double sin5(double x)
{
    double x2 = x * x;
    double x4 = x2 * x2;
    double x6 = x4 * x2;
    double A = a0 + x6 * (a3 + x6 * a6);
    double B = a1 + x6 * (a4 + x6 * a7);
    double C = a2 + x6 * a5;
    return x * (A + x2 * B + x4 * C);
}

double sin6(double x)
{
    double x2 = x * x;
    double x4 = x2 * x2;
    double x8 = x4 * x4;
    double A = a0 + x2 * (a1 + x2 * (a2 + x2 * a3));
    double B = a4 + x2 * (a5 + x2 * (a6 + x2 * a7));
    return x * (A + x8 * B);
}

double sin7(double x)
{
    double x2 = x * x;
    double x3 = x2 * x;
    double x4 = x2 * x2;
    double x8 = x4 * x4;
    double x9 = x8 * x;
    __asm__("" : "+x" (x2), "+x" (x3), "+x" (x4), "+x" (x8), "+x" (x9));
    double A = x3 * (a1 + x2 * (a2 + x2 * a3));
    double B = a4 + x2 * (a5 + x2 * (a6 + x2 * a7));
    double C = a0 * x;
    return A + C + x9 * B;
}

int main()
{
    typedef chrono::high_resolution_clock clock_t;
    clock_t::time_point t0, t1;
    size_t const iterations = 10000000;
    double const inv = 1.0 / iterations;

    double sum = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum += run * inv;
    t1 = clock_t::now();
    double norm = chrono::nanoseconds(t1 - t0).count() * inv;

    double sum0 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum0 += sin(run * inv);
    t1 = clock_t::now();
    cout << "sin: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    double sum1 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum1 += sin1(run * inv);
    t1 = clock_t::now();
    cout << "sin1: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    double sum2 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum2 += sin2(run * inv);
    t1 = clock_t::now();
    cout << "sin2: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    double sum3 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum3 += sin3(run * inv);
    t1 = clock_t::now();
    cout << "sin3: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    double sum4 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum4 += sin4(run * inv);
    t1 = clock_t::now();
    cout << "sin4: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    double sum5 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum5 += sin5(run * inv);
    t1 = clock_t::now();
    cout << "sin5: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    double sum6 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum6 += sin6(run * inv);
    t1 = clock_t::now();
    cout << "sin6: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    double sum7 = 0.0;
    t0 = clock_t::now();
    for (size_t run = 0; run < iterations; run++)
        sum7 += sin7(run * inv);
    t1 = clock_t::now();
    cout << "sin7: " << chrono::nanoseconds(t1 - t0).count() * inv - norm << " ns" << endl;

    cout << setprecision(20);
    cout << sum0 << endl;
    cout << sum1 << endl;
    cout << sum2 << endl;
    cout << sum3 << endl;
    cout << sum4 << endl;
    cout << sum5 << endl;
    cout << sum6 << endl;
    cout << sum7 << endl;

    return sum + sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7 == 0.0;
}