Операции с плавающей точкой без 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.

[fontp]

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

Так чего Вы тогда от него хотите? Короткие функции, вызываемые через Call по определению будут работать медленно. Для стандартных float это не так, они оформлены intrinsic и вставляются компилятором inline
А вот Вы возьмите не библиотеку lib, а её исходный код. Повытаскивайте те функции, что Вам нужны в h-файл и припишите к каждой функции модификатор inline - и всё сразу станет во много раз быстрее.