timesoftfloat.c

<Floating Point Unit Core> fpupack.vhd pre_norm_addsub.vhd addsub_28.vhd post_norm_addsub.

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_floatx80[ inputNum ].low;
            a.high = inputs_floatx80[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNum = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_floatx80[ inputNum ].low;
        a.high = inputs_floatx80[ inputNum ].high;
        function( a );
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

static void time_ab_floatx80_z_flag( flag function( floatx80, floatx80 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNumA, inputNumB;
    floatx80 a, b;

    count = 0;
    inputNumA = 0;
    inputNumB = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_floatx80[ inputNumA ].low;
            a.high = inputs_floatx80[ inputNumA ].high;
            b.low = inputs_floatx80[ inputNumB ].low;
            b.high = inputs_floatx80[ inputNumB ].high;
            function( a, b );
            inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
            if ( inputNumA == 0 ) ++inputNumB;
            inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNumA = 0;
    inputNumB = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_floatx80[ inputNumA ].low;
        a.high = inputs_floatx80[ inputNumA ].high;
        b.low = inputs_floatx80[ inputNumB ].low;
        b.high = inputs_floatx80[ inputNumB ].high;
        function( a, b );
        inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
        if ( inputNumA == 0 ) ++inputNumB;
        inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

static void time_abz_floatx80( floatx80 function( floatx80, floatx80 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNumA, inputNumB;
    floatx80 a, b;

    count = 0;
    inputNumA = 0;
    inputNumB = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_floatx80[ inputNumA ].low;
            a.high = inputs_floatx80[ inputNumA ].high;
            b.low = inputs_floatx80[ inputNumB ].low;
            b.high = inputs_floatx80[ inputNumB ].high;
            function( a, b );
            inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
            if ( inputNumA == 0 ) ++inputNumB;
            inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNumA = 0;
    inputNumB = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_floatx80[ inputNumA ].low;
        a.high = inputs_floatx80[ inputNumA ].high;
        b.low = inputs_floatx80[ inputNumB ].low;
        b.high = inputs_floatx80[ inputNumB ].high;
        function( a, b );
        inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
        if ( inputNumA == 0 ) ++inputNumB;
        inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

static const struct {
    bits16 high;
    bits64 low;
} inputs_floatx80_pos[ numInputs_floatx80 ] = {
    { 0x403F, LIT64( 0xA9BE15A19C1E8B62 ) },
    { 0x0000, LIT64( 0x0000000000000000 ) },
    { 0x75A8, LIT64( 0xE59591E4788957A5 ) },
    { 0x3FFF, LIT64( 0xFFF0000000000040 ) },
    { 0x0CD8, LIT64( 0xFC000000000007FE ) },
    { 0x43BA, LIT64( 0x99A4000000000000 ) },
    { 0x3FFF, LIT64( 0x8000000000000000 ) },
    { 0x4081, LIT64( 0x94FBF1BCEB5545F0 ) },
    { 0x403E, LIT64( 0xFFF0000000002000 ) },
    { 0x3FFE, LIT64( 0xC860E3C75D224F28 ) },
    { 0x407E, LIT64( 0xFC00000FFFFFFFFE ) },
    { 0x737A, LIT64( 0x800000007FFDFFFE ) },
    { 0x4044, LIT64( 0xFFFFFF80000FFFFF ) },
    { 0x3BFE, LIT64( 0x8000040000001FFE ) },
    { 0x4002, LIT64( 0xFF80000000000020 ) },
    { 0x5E8D, LIT64( 0xFFFFFFFFFFE00004 ) },
    { 0x4004, LIT64( 0x8000000000003FFB ) },
    { 0x407F, LIT64( 0x800000000003FFFE ) },
    { 0x4000, LIT64( 0xA459EE6A5C16CA55 ) },
    { 0x0003, LIT64( 0xC42CBF7399AEEB94 ) },
    { 0x3F7F, LIT64( 0xF800000000000006 ) },
    { 0x407F, LIT64( 0xBF56BE8871F28FEA ) },
    { 0x407E, LIT64( 0xFFFF77FFFFFFFFFE ) },
    { 0x2DC9, LIT64( 0x8000000FFFFFFFDE ) },
    { 0x4001, LIT64( 0xEFF7FFFFFFFFFFFF ) },
    { 0x4001, LIT64( 0xBE84F30125C497A6 ) },
    { 0x406B, LIT64( 0xEFFFFFFFFFFFFFFF ) },
    { 0x4080, LIT64( 0xFFFFFFFFBFFFFFFF ) },
    { 0x07E9, LIT64( 0x81FFFFFFFFFFFBFF ) },
    { 0x263F, LIT64( 0x801FFFFFFEFFFFFE ) },
    { 0x403C, LIT64( 0x801FFFFFFFF7FFFF ) },
    { 0x4018, LIT64( 0x8000000000080003 ) }
};

static void time_az_floatx80_pos( floatx80 function( floatx80 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNum;
    floatx80 a;

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_floatx80_pos[ inputNum ].low;
            a.high = inputs_floatx80_pos[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNum = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_floatx80_pos[ inputNum ].low;
        a.high = inputs_floatx80_pos[ inputNum ].high;
        function( a );
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

#endif

#ifdef FLOAT128

enum {
    numInputs_float128 = 32
};

static const struct {
    bits64 high, low;
} inputs_float128[ numInputs_float128 ] = {
    { LIT64( 0x3FDA200000100000 ), LIT64( 0x0000000000000000 ) },
    { LIT64( 0x3FFF000000000000 ), LIT64( 0x0000000000000000 ) },
    { LIT64( 0x85F14776190C8306 ), LIT64( 0xD8715F4E3D54BB92 ) },
    { LIT64( 0xF2B00000007FFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) },
    { LIT64( 0x8000000000000000 ), LIT64( 0x0000000000000000 ) },
    { LIT64( 0xBFFFFFFFFFE00000 ), LIT64( 0x0000008000000000 ) },
    { LIT64( 0x407F1719CE722F3E ), LIT64( 0xDA6B3FE5FF29425B ) },
    { LIT64( 0x43FFFF8000000000 ), LIT64( 0x0000000000400000 ) },
    { LIT64( 0x401E000000000100 ), LIT64( 0x0000000000002000 ) },
    { LIT64( 0x3FFED71DACDA8E47 ), LIT64( 0x4860E3C75D224F28 ) },
    { LIT64( 0xBF7ECFC1E90647D1 ), LIT64( 0x7A124FE55623EE44 ) },
    { LIT64( 0x0DF7007FFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) },
    { LIT64( 0x3FE5FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) },
    { LIT64( 0x403FFFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFE ) },
    { LIT64( 0xBFFB2FBF7399AFEB ), LIT64( 0xA459EE6A5C16CA55 ) },
    { LIT64( 0xBDB8FFFFFFFFFFFC ), LIT64( 0x0000000000000400 ) },
    { LIT64( 0x3FC8FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) },
    { LIT64( 0x3FFBFFFFFFDFFFFF ), LIT64( 0xFFF8000000000000 ) },
    { LIT64( 0x407043C11737BE84 ), LIT64( 0xDDD58212ADC937F4 ) },
    { LIT64( 0x8001000000000000 ), LIT64( 0x0000001000000001 ) },
    { LIT64( 0xC036FFFFFFFFFFFF ), LIT64( 0xFE40000000000000 ) },
    { LIT64( 0x4002FFFFFE000002 ), LIT64( 0x0000000000000000 ) },
    { LIT64( 0x4000C3FEDE897773 ), LIT64( 0x326AC4FD8EFBE6DC ) },
    { LIT64( 0xBFFF0000000FFFFF ), LIT64( 0xFFFFFE0000000000 ) },
    { LIT64( 0x62C3E502146E426D ), LIT64( 0x43F3CAA0DC7DF1A0 ) },
    { LIT64( 0xB5CBD32E52BB570E ), LIT64( 0xBCC477CB11C6236C ) },
    { LIT64( 0xE228FFFFFFC00000 ), LIT64( 0x0000000000000000 ) },
    { LIT64( 0x3F80000000000000 ), LIT64( 0x0000000080000008 ) },
    { LIT64( 0xC1AFFFDFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) },
    { LIT64( 0xC96F000000000000 ), LIT64( 0x00000001FFFBFFFF ) },
    { LIT64( 0x3DE09BFE7923A338 ), LIT64( 0xBCC8FBBD7CEC1F4F ) },
    { LIT64( 0x401CFFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFF80 ) }
};

static void time_a_float128_z_int32( int32 function( float128 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNum;
    float128 a;

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_float128[ inputNum ].low;
            a.high = inputs_float128[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNum = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_float128[ inputNum ].low;
        a.high = inputs_float128[ inputNum ].high;
        function( a );
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

static void time_a_float128_z_int64( int64 function( float128 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNum;
    float128 a;

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_float128[ inputNum ].low;
            a.high = inputs_float128[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNum = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_float128[ inputNum ].low;
        a.high = inputs_float128[ inputNum ].high;
        function( a );
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

static void time_a_float128_z_float32( float32 function( float128 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNum;
    float128 a;

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_float128[ inputNum ].low;
            a.high = inputs_float128[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNum = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_float128[ inputNum ].low;
        a.high = inputs_float128[ inputNum ].high;
        function( a );
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

static void time_a_float128_z_float64( float64 function( float128 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNum;
    float128 a;

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_float128[ inputNum ].low;
            a.high = inputs_float128[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNum = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_float128[ inputNum ].low;
        a.high = inputs_float128[ inputNum ].high;
        function( a );
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

#ifdef FLOATX80

static void time_a_float128_z_floatx80( floatx80 function( float128 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNum;
    float128 a;

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_float128[ inputNum ].low;
            a.high = inputs_float128[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
        }
        count += minIterations;
    } while ( clock() - startClock < CLOCKS_PER_SEC );
    inputNum = 0;
    startClock = clock();
    for ( i = count; i; --i ) {
        a.low = inputs_float128[ inputNum ].low;
        a.high = inputs_float128[ inputNum ].high;
        function( a );
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
    }
    endClock = clock();
    reportTime( count, endClock - startClock );

}

#endif

static void time_az_float128( float128 function( float128 ) )
{
    clock_t startClock, endClock;
    int32 count, i;
    int8 inputNum;
    float128 a;

    count = 0;
    inputNum = 0;
    startClock = clock();
    do {
        for ( i = minIterations; i; --i ) {
            a.low = inputs_float128[ inputNum ].low;
            a.high = inputs_float128[ inputNum ].high;
            function( a );
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );