Операции с плавающей точкой без FPU, На сколько падает производительность? Опции

[sigmaN]

Интересно, а можно ли на целочисленном DSP с запасом производительности(скажем в 3-5 раз) зарулить вокодер на плавающей точке?

И вообще, каков overhead, так сказать, FP операций на проце без FPU?
Страдает ли точность вычисления?
Что нужно для подобных "извращений"?
Может быть есть какая-то библиотека виртуального FPU, так сказать?
DSP Техас 55 серии.

[Degun]

Кто пробовал для DSP фирмы Texas Instruments серии 62x или 64x пользоваться библиотекой Fast Run Time Support Library fastrts64x.lib, которая вроде бы предоставляет быструю реализацию основных операций с типами double и float. Насколько она действительно быстрее тех же операций, но встроенных в компилятор? Будет ли выигрыш? Если нет, то зачем она нужна вообще?

[fontp]

Кто пробовал для DSP фирмы Texas Instruments серии 62x или 64x пользоваться библиотекой Fast Run Time Support Library fastrts64x.lib, которая вроде бы предоставляет быструю реализацию основных операций с типами double и float. Насколько она действительно быстрее тех же операций, но встроенных в компилятор? Будет ли выигрыш? Если нет, то зачем она нужна вообще?

Нужна затем, чтобы уйти от стандарта IEEE и игнорировать всякие overflow/underflow. Как всегда проверки на ошибки забирают большую часть усилий и вся мощь уходит зазря. В Borland C тоже всегда был "fast float" и смысл тот же - не делать проверок и ускориться раза в 2.
Насколько быстро это всё будет для TI? Да не очень . Раз в 50-100 медленнее такта процессора (т.е. вычислений fixed). Длинна слова-то - стандартная и мантисса/порядок не выровнены на границу 16 бит

[rifch]

Нужна затем, чтобы уйти от стандарта IEEE и игнорировать всякие overflow/underflow. Как всегда проверки на ошибки забирают большую часть усилий и вся мощь уходит зазря. В Borland C тоже всегда был "fast float" и смысл тот же - не делать проверок и ускориться раза в 2.
Насколько быстро это всё будет для TI? Да не очень . Раз в 50-100 медленнее такта процессора (т.е. вычислений fixed). Длинна слова-то - стандартная и мантисса/порядок не выровнены на границу 16 бит

Сделал для функций этой библиотеки обёртку. Но оказалось, что с ней интересующая меня функция билинейного масштабирования работает даже медленее, чем при использовании встроенных в компилятор типа double. Из-за чего это? Может из-за накладных расходов на организацию классов?

Код

/*!\file fast_rts64x.h
* \brief Быстрая реализация основных операций с числами
* \brief с плавающей запятой для DSP фирмы Texas Instruments
* \brief серии 64x, основанная на библиотеке fast_rts64x.lib
* \version 1.0
* \date 2008
*/
#ifndef __FAST_RTS_64X_H
#define __FAST_RTS_64X_H

#ifdef __cplusplus
extern "C" {
#include <fastrts62x64x.h>
}
#else
#include <fastrts62x64x.h>
#endif

class double_fst
{
public:
    double value;

    inline double_fst( double v=0 ) { value=v; }
    inline double_fst( float v ) { value=spdp(v); }
    inline double_fst( char v ) { value=intdp(v); }
    inline double_fst( short v ) { value=intdp(v); }
    inline double_fst( int v ) { value=intdp(v); }
    inline double_fst( long v ) { value=longdp(v); }
    inline double_fst( unsigned char v ) { value=uintdp(v); }
    inline double_fst( unsigned short v ) { value=uintdp(v); }
    inline double_fst( unsigned int v ) { value=uintdp(v); }
    inline double_fst( unsigned long v ) { value=ulongdp(v); }

    inline operator double() const { return value; }
    inline operator float() const { return dpsp(value); }
    inline operator char() const { return (char)dpint(value); }
    inline operator short() const { return (short)dpint(value); }
    inline operator int() const { return dpint(value); }
    inline operator long() const { return dplong(value); }
    inline operator unsigned char() const { return (unsigned char)dpuint(value); }
    inline operator unsigned short() const { return (unsigned short)dpuint(value); }
    inline operator unsigned int() const { return dpuint(value); }
    inline operator unsigned long() const { return dpulong(value); }

    inline void operator = ( double_fst r ) { value=r.value; }
    inline void operator = ( double v ) { value=v; }
    inline void operator = ( float v ) { value=spdp(v); }
    inline void operator = ( char v ) { value=intdp(v); }
    inline void operator = ( short v ) { value=intdp(v); }
    inline void operator = ( int v ) { value=intdp(v); }
    inline void operator = ( long v ) { value=longdp(v); }
    inline void operator = ( unsigned char v ) { value=uintdp(v); }
    inline void operator = ( unsigned short v ) { value=uintdp(v); }
    inline void operator = ( unsigned int v ) { value=uintdp(v); }
    inline void operator = ( unsigned long v ) { value=ulongdp(v); }

    inline void operator += ( double_fst r ) { value=adddp(value, r.value); }
    inline void operator -= ( double_fst r ) { value=subdp(value, r.value); }
    inline void operator *= ( double_fst r ) { value=mpydp(value, r.value); }
    inline void operator /= ( double_fst r ) { value=divdp(value, r.value); }

    inline void operator += ( double v ) { value=adddp(value, v); }
    inline void operator -= ( double v ) { value=subdp(value, v); }
    inline void operator *= ( double v ) { value=mpydp(value, v); }
    inline void operator /= ( double v ) { value=divdp(value, v); }

    inline void operator += ( float v ) { value=adddp(value, spdp(v)); }
    inline void operator -= ( float v ) { value=subdp(value, spdp(v)); }
    inline void operator *= ( float v ) { value=mpydp(value, spdp(v)); }
    inline void operator /= ( float v ) { value=divdp(value, spdp(v)); }

    inline void operator += ( char v ) { value=adddp(value, intdp(v)); }
    inline void operator -= ( char v ) { value=subdp(value, intdp(v)); }
    inline void operator *= ( char v ) { value=mpydp(value, intdp(v)); }
    inline void operator /= ( char v ) { value=divdp(value, intdp(v)); }

    inline void operator += ( short v ) { value=adddp(value, intdp(v)); }
    inline void operator -= ( short v ) { value=subdp(value, intdp(v)); }
    inline void operator *= ( short v ) { value=mpydp(value, intdp(v)); }
    inline void operator /= ( short v ) { value=divdp(value, intdp(v)); }

    inline void operator += ( int v ) { value=adddp(value, intdp(v)); }
    inline void operator -= ( int v ) { value=subdp(value, intdp(v)); }
    inline void operator *= ( int v ) { value=mpydp(value, intdp(v)); }
    inline void operator /= ( int v ) { value=divdp(value, intdp(v)); }

    inline void operator += ( long v ) { value=adddp(value, longdp(v)); }
    inline void operator -= ( long v ) { value=subdp(value, longdp(v)); }
    inline void operator *= ( long v ) { value=mpydp(value, longdp(v)); }
    inline void operator /= ( long v ) { value=divdp(value, longdp(v)); }

    inline void operator += ( unsigned char v ) { value=adddp(value, uintdp(v)); }
    inline void operator -= ( unsigned char v ) { value=subdp(value, uintdp(v)); }
    inline void operator *= ( unsigned char v ) { value=mpydp(value, uintdp(v)); }
    inline void operator /= ( unsigned char v ) { value=divdp(value, uintdp(v)); }

    inline void operator += ( unsigned short v ) { value=adddp(value, uintdp(v)); }
    inline void operator -= ( unsigned short v ) { value=subdp(value, uintdp(v)); }
    inline void operator *= ( unsigned short v ) { value=mpydp(value, uintdp(v)); }
    inline void operator /= ( unsigned short v ) { value=divdp(value, uintdp(v)); }

    inline void operator += ( unsigned int v ) { value=adddp(value, uintdp(v)); }
    inline void operator -= ( unsigned int v ) { value=subdp(value, uintdp(v)); }
    inline void operator *= ( unsigned int v ) { value=mpydp(value, uintdp(v)); }
    inline void operator /= ( unsigned int v ) { value=divdp(value, uintdp(v)); }

    inline void operator += ( unsigned long v ) { value=adddp(value, ulongdp(v)); }
    inline void operator -= ( unsigned long v ) { value=subdp(value, ulongdp(v)); }
    inline void operator *= ( unsigned long v ) { value=mpydp(value, ulongdp(v)); }
    inline void operator /= ( unsigned long v ) { value=divdp(value, ulongdp(v)); }

    inline bool operator <  ( double_fst &r ) const { return value <  r.value; }
    inline bool operator >  ( double_fst &r ) const { return value >  r.value; }
    inline bool operator <= ( double_fst &r ) const { return value <= r.value; }
    inline bool operator >= ( double_fst &r ) const { return value >= r.value; }
    inline bool operator == ( double_fst &r ) const { return value == r.value; }
    inline bool operator != ( double_fst &r ) const { return value != r.value; }

    inline bool operator <  ( double v ) const { return value <  v; }
    inline bool operator >  ( double v ) const { return value >  v; }
    inline bool operator <= ( double v ) const { return value <= v; }
    inline bool operator >= ( double v ) const { return value >= v; }
    inline bool operator == ( double v ) const { return value == v; }
    inline bool operator != ( double v ) const { return value != v; }

    inline bool operator <  ( float v ) const { return value <  spdp(v); }
    inline bool operator >  ( float v ) const { return value >  spdp(v); }
    inline bool operator <= ( float v ) const { return value <= spdp(v); }
    inline bool operator >= ( float v ) const { return value >= spdp(v); }
    inline bool operator == ( float v ) const { return value == spdp(v); }
    inline bool operator != ( float v ) const { return value != spdp(v); }

    inline bool operator <  ( char v ) const { return value <  intdp(v); }
    inline bool operator >  ( char v ) const { return value >  intdp(v); }
    inline bool operator <= ( char v ) const { return value <= intdp(v); }
    inline bool operator >= ( char v ) const { return value >= intdp(v); }
    inline bool operator == ( char v ) const { return value == intdp(v); }
    inline bool operator != ( char v ) const { return value != intdp(v); }

    inline bool operator <  ( short v ) const { return value <  intdp(v); }
    inline bool operator >  ( short v ) const { return value >  intdp(v); }
    inline bool operator <= ( short v ) const { return value <= intdp(v); }
    inline bool operator >= ( short v ) const { return value >= intdp(v); }
    inline bool operator == ( short v ) const { return value == intdp(v); }
    inline bool operator != ( short v ) const { return value != intdp(v); }

    inline bool operator <  ( int v ) const { return value <  intdp(v); }
    inline bool operator >  ( int v ) const { return value >  intdp(v); }
    inline bool operator <= ( int v ) const { return value <= intdp(v); }
    inline bool operator >= ( int v ) const { return value >= intdp(v); }
    inline bool operator == ( int v ) const { return value == intdp(v); }
    inline bool operator != ( int v ) const { return value != intdp(v); }

    inline bool operator <  ( long v ) const { return value <  longdp(v); }
    inline bool operator >  ( long v ) const { return value >  longdp(v); }
    inline bool operator <= ( long v ) const { return value <= longdp(v); }
    inline bool operator >= ( long v ) const { return value >= longdp(v); }
    inline bool operator == ( long v ) const { return value == longdp(v); }
    inline bool operator != ( long v ) const { return value != longdp(v); }

    inline bool operator <  ( unsigned char v ) const { return value <  uintdp(v); }
    inline bool operator >  ( unsigned char v ) const { return value >  uintdp(v); }
    inline bool operator <= ( unsigned char v ) const { return value <= uintdp(v); }
    inline bool operator >= ( unsigned char v ) const { return value >= uintdp(v); }
    inline bool operator == ( unsigned char v ) const { return value == uintdp(v); }
    inline bool operator != ( unsigned char v ) const { return value != uintdp(v); }

    inline bool operator <  ( unsigned short v ) const { return value <  uintdp(v); }
    inline bool operator >  ( unsigned short v ) const { return value >  uintdp(v); }
    inline bool operator <= ( unsigned short v ) const { return value <= uintdp(v); }
    inline bool operator >= ( unsigned short v ) const { return value >= uintdp(v); }
    inline bool operator == ( unsigned short v ) const { return value == uintdp(v); }
    inline bool operator != ( unsigned short v ) const { return value != uintdp(v); }

    inline bool operator <  ( unsigned int v ) const { return value <  uintdp(v); }
    inline bool operator >  ( unsigned int v ) const { return value >  uintdp(v); }
    inline bool operator <= ( unsigned int v ) const { return value <= uintdp(v); }
    inline bool operator >= ( unsigned int v ) const { return value >= uintdp(v); }
    inline bool operator == ( unsigned int v ) const { return value == uintdp(v); }
    inline bool operator != ( unsigned int v ) const { return value != uintdp(v); }

    inline bool operator <  ( unsigned long v ) const { return value <  ulongdp(v); }
    inline bool operator >  ( unsigned long v ) const { return value >  ulongdp(v); }
    inline bool operator <= ( unsigned long v ) const { return value <= ulongdp(v); }
    inline bool operator >= ( unsigned long v ) const { return value >= ulongdp(v); }
    inline bool operator == ( unsigned long v ) const { return value == ulongdp(v); }
    inline bool operator != ( unsigned long v ) const { return value != ulongdp(v); }
};

//Для типа double_fst
inline double_fst operator + (double_fst l, double_fst r) { return double_fst(adddp(l.value,r.value)); }
inline double_fst operator - (double_fst l, double_fst r) { return double_fst(subdp(l.value,r.value)); }
inline double_fst operator * (double_fst l, double_fst r) { return double_fst(mpydp(l.value,r.value)); }
inline double_fst operator / (double_fst l, double_fst r) { return double_fst(divdp(l.value,r.value)); }

//Для типа double
inline double_fst operator + ( double l, double_fst r ) { return double_fst(adddp(l, r.value)); }
inline double_fst operator - ( double l, double_fst r ) { return double_fst(subdp(l, r.value)); }
inline double_fst operator * ( double l, double_fst r ) { return double_fst(mpydp(l, r.value)); }
inline double_fst operator / ( double l, double_fst r ) { return double_fst(divdp(l, r.value)); }
inline double_fst operator + ( double_fst l, double r ) { return double_fst(adddp(l.value, r)); }
inline double_fst operator - ( double_fst l, double r ) { return double_fst(subdp(l.value, r)); }
inline double_fst operator * ( double_fst l, double r ) { return double_fst(mpydp(l.value, r)); }
inline double_fst operator / ( double_fst l, double r ) { return double_fst(divdp(l.value, r)); }

//Для типа float
inline double_fst operator + ( float l, double_fst r ) { return double_fst(adddp(spdp(l), r.value)); }
inline double_fst operator - ( float l, double_fst r ) { return double_fst(subdp(spdp(l), r.value)); }
inline double_fst operator * ( float l, double_fst r ) { return double_fst(mpydp(spdp(l), r.value)); }
inline double_fst operator / ( float l, double_fst r ) { return double_fst(divdp(spdp(l), r.value)); }
inline double_fst operator + ( double_fst l, float r ) { return double_fst(adddp(l.value, spdp(r))); }
inline double_fst operator - ( double_fst l, float r ) { return double_fst(subdp(l.value, spdp(r))); }
inline double_fst operator * ( double_fst l, float r ) { return double_fst(mpydp(l.value, spdp(r))); }
inline double_fst operator / ( double_fst l, float r ) { return double_fst(divdp(l.value, spdp(r))); }

//Для типа char
inline double_fst operator + ( char l, double_fst r ) { return double_fst(adddp(intdp(l), r.value)); }
inline double_fst operator - ( char l, double_fst r ) { return double_fst(subdp(intdp(l), r.value)); }
inline double_fst operator * ( char l, double_fst r ) { return double_fst(mpydp(intdp(l), r.value)); }
inline double_fst operator / ( char l, double_fst r ) { return double_fst(divdp(intdp(l), r.value)); }
inline double_fst operator + ( double_fst l, char r ) { return double_fst(adddp(l.value, intdp(r))); }
inline double_fst operator - ( double_fst l, char r ) { return double_fst(subdp(l.value, intdp(r))); }
inline double_fst operator * ( double_fst l, char r ) { return double_fst(mpydp(l.value, intdp(r))); }
inline double_fst operator / ( double_fst l, char r ) { return double_fst(divdp(l.value, intdp(r))); }

//Для типа short
inline double_fst operator + ( short l, double_fst r ) { return double_fst(adddp(intdp(l), r.value)); }
inline double_fst operator - ( short l, double_fst r ) { return double_fst(subdp(intdp(l), r.value)); }
inline double_fst operator * ( short l, double_fst r ) { return double_fst(mpydp(intdp(l), r.value)); }
inline double_fst operator / ( short l, double_fst r ) { return double_fst(divdp(intdp(l), r.value)); }
inline double_fst operator + ( double_fst l, short r ) { return double_fst(adddp(l.value, intdp(r))); }
inline double_fst operator - ( double_fst l, short r ) { return double_fst(subdp(l.value, intdp(r))); }
inline double_fst operator * ( double_fst l, short r ) { return double_fst(mpydp(l.value, intdp(r))); }
inline double_fst operator / ( double_fst l, short r ) { return double_fst(divdp(l.value, intdp(r))); }

//Для типа int
inline double_fst operator + ( int l, double_fst r ) { return double_fst(adddp(intdp(l), r.value)); }
inline double_fst operator - ( int l, double_fst r ) { return double_fst(subdp(intdp(l), r.value)); }
inline double_fst operator * ( int l, double_fst r ) { return double_fst(mpydp(intdp(l), r.value)); }
inline double_fst operator / ( int l, double_fst r ) { return double_fst(divdp(intdp(l), r.value)); }
inline double_fst operator + ( double_fst l, int r ) { return double_fst(adddp(l.value, intdp(r))); }
inline double_fst operator - ( double_fst l, int r ) { return double_fst(subdp(l.value, intdp(r))); }
inline double_fst operator * ( double_fst l, int r ) { return double_fst(mpydp(l.value, intdp(r))); }
inline double_fst operator / ( double_fst l, int r ) { return double_fst(divdp(l.value, intdp(r))); }

//Для типа long
inline double_fst operator + ( long l, double_fst r ) { return double_fst(adddp(longdp(l), r.value)); }
inline double_fst operator - ( long l, double_fst r ) { return double_fst(subdp(longdp(l), r.value)); }
inline double_fst operator * ( long l, double_fst r ) { return double_fst(mpydp(longdp(l), r.value)); }
inline double_fst operator / ( long l, double_fst r ) { return double_fst(divdp(longdp(l), r.value)); }
inline double_fst operator + ( double_fst l, long r ) { return double_fst(adddp(l.value, longdp(r))); }
inline double_fst operator - ( double_fst l, long r ) { return double_fst(subdp(l.value, longdp(r))); }
inline double_fst operator * ( double_fst l, long r ) { return double_fst(mpydp(l.value, longdp(r))); }
inline double_fst operator / ( double_fst l, long r ) { return double_fst(divdp(l.value, longdp(r))); }

//Для типа unsigned char
inline double_fst operator + ( unsigned char l, double_fst r ) { return double_fst(adddp(uintdp(l), r.value)); }
inline double_fst operator - ( unsigned char l, double_fst r ) { return double_fst(subdp(uintdp(l), r.value)); }
inline double_fst operator * ( unsigned char l, double_fst r ) { return double_fst(mpydp(uintdp(l), r.value)); }
inline double_fst operator / ( unsigned char l, double_fst r ) { return double_fst(divdp(uintdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned char r ) { return double_fst(adddp(l.value, uintdp(r))); }
inline double_fst operator - ( double_fst l, unsigned char r ) { return double_fst(subdp(l.value, uintdp(r))); }
inline double_fst operator * ( double_fst l, unsigned char r ) { return double_fst(mpydp(l.value, uintdp(r))); }
inline double_fst operator / ( double_fst l, unsigned char r ) { return double_fst(divdp(l.value, uintdp(r))); }

//Для типа unsigned short
inline double_fst operator + ( unsigned short l, double_fst r ) { return double_fst(adddp(uintdp(l), r.value)); }
inline double_fst operator - ( unsigned short l, double_fst r ) { return double_fst(subdp(uintdp(l), r.value)); }
inline double_fst operator * ( unsigned short l, double_fst r ) { return double_fst(mpydp(uintdp(l), r.value)); }
inline double_fst operator / ( unsigned short l, double_fst r ) { return double_fst(divdp(uintdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned short r ) { return double_fst(adddp(l.value, uintdp(r))); }
inline double_fst operator - ( double_fst l, unsigned short r ) { return double_fst(subdp(l.value, uintdp(r))); }
inline double_fst operator * ( double_fst l, unsigned short r ) { return double_fst(mpydp(l.value, uintdp(r))); }
inline double_fst operator / ( double_fst l, unsigned short r ) { return double_fst(divdp(l.value, uintdp(r))); }

//Для типа unsigned int
inline double_fst operator + ( unsigned int l, double_fst r ) { return double_fst(adddp(uintdp(l), r.value)); }
inline double_fst operator - ( unsigned int l, double_fst r ) { return double_fst(subdp(uintdp(l), r.value)); }
inline double_fst operator * ( unsigned int l, double_fst r ) { return double_fst(mpydp(uintdp(l), r.value)); }
inline double_fst operator / ( unsigned int l, double_fst r ) { return double_fst(divdp(uintdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned int r ) { return double_fst(adddp(l.value, uintdp(r))); }
inline double_fst operator - ( double_fst l, unsigned int r ) { return double_fst(subdp(l.value, uintdp(r))); }
inline double_fst operator * ( double_fst l, unsigned int r ) { return double_fst(mpydp(l.value, uintdp(r))); }
inline double_fst operator / ( double_fst l, unsigned int r ) { return double_fst(divdp(l.value, uintdp(r))); }

//Для типа unsigned long
inline double_fst operator + ( unsigned long l, double_fst r ) { return double_fst(adddp(ulongdp(l), r.value)); }
inline double_fst operator - ( unsigned long l, double_fst r ) { return double_fst(subdp(ulongdp(l), r.value)); }
inline double_fst operator * ( unsigned long l, double_fst r ) { return double_fst(mpydp(ulongdp(l), r.value)); }
inline double_fst operator / ( unsigned long l, double_fst r ) { return double_fst(divdp(ulongdp(l), r.value)); }
inline double_fst operator + ( double_fst l, unsigned long r ) { return double_fst(adddp(l.value, ulongdp(r))); }
inline double_fst operator - ( double_fst l, unsigned long r ) { return double_fst(subdp(l.value, ulongdp(r))); }
inline double_fst operator * ( double_fst l, unsigned long r ) { return double_fst(mpydp(l.value, ulongdp(r))); }
inline double_fst operator / ( double_fst l, unsigned long r ) { return double_fst(divdp(l.value, ulongdp(r))); }

#endif //__FAST_RTS_64X_H

[fontp]

Сделал для функций этой библиотеки обёртку. Но оказалось, что с ней интересующая меня функция билинейного масштабирования работает даже медленее, чем при использовании встроенных в компилятор типа double. Из-за чего это? Может из-за накладных расходов на организацию классов?

Обёртка, то ладно...Надеюсь, все функции библиотеки объявлены как inline. Иначе - беда. Издержки на вызов функции

[Degun]

Обёртка, то ладно...Надеюсь, все функции библиотеки объявлены как inline. Иначе - беда. Издержки на вызов функции

А разве можно функции, собранные в файл-библиотеку fastrts62x64x.lib, объявить как inline. Вроде бы, т. к. они уже скомпилированны в библиотеку, то они не могут быть inline.