math KO!

[Sass Attila]

Sziasztok!

Tapasztalataim szerint igen nagy teljesítménybeli különbség tud lenni
akkor, ha a matematikai processzor olyan számmal dolgozik, melynek
lebegőpontos ábrázolásában: a*2^b ,  b>=1024 vagy b<-1022. A jelenség
akkor áll fenn, ha a kiindulási vagy a végeredmény beleesik ebbe a
tartományba.
A jelenség op-rendszer és fordító független. (ugyanozon a gépen
winXP/dotnet és lin/gcc alatt is egyformán lassabb)

Például
Celeron (Coppermine) 600 Mhz (linux alatt) :

#include <math.h>
#define exponent 512.0
int main(void)
{
        double d,k;
        int i;
        d = pow(2.0,exponent);
        for (i=0;i<100000000;i++)
                k = d * d;
}


22.22 s egyik és 2.7s a másik esetben (itt a végeredmény esik bele ebbe
a kategóriába, nem lassabb akkor sem, ha már a kiindulási szám is
beleesik)

Vagyis egymilliárd szorzás idejei: 222.2s és 27s.

Pentium 4 1.7Ghz Windows XP, dotnet fejlesztőeszköz alatt (ezen a gépen
megnéztem linux/gcc alatt is, teljesen hasonló volt az eredmény):

private void button1_Click(object sender, System.EventArgs e)
		{
			double exponent =512.0;
			double d,k;
			d = Math.Pow(2,exponent);
			int t = Environment.TickCount;
			for (int i = 0;i<1000000000;i++)
				k= d*d;
			MessageBox.Show((Environment.TickCount
-t).ToString());

		}

2.4s az egyik esetben és 100*7s = 700s  másik esetben (ez utóbbinál csak
10000000-ig futtattam a ciklust, ezért a 100*7s)

Vagyis egymilliárd szorzás idejei: 2,4s és 700s.

Egy 1.1G-s celeronon is megcsináltam, az is hasonló volt a 600-ashoz,
csak gyorsabb volt annál (de ott is kb. 10-es szorzó volt, ha jól
emlékszem)

Vagyis az 1.7-es P4 sokkal lassabb a 600-es celeronnál ebben a kritikus
tartományban.

Összeadásnál hasonló a helyzet, csak ott nyilván az exponent 1024 körül
kell legyen.

A kérdésem: Mitől lehet ez? 
A lebegőpontos szorzásnál a mantisszákat szorozni, a karakterisztikákat
összeadni kell. Ilyen nehéz összeadni két számot? A mantisszák szorzása
pillanatok alatt megvan (más mantisszákkal is csináltam a tesztet,
azoktól teljesen független a sebesség).

Csak valami olyant tudok elképzelni, hogy valami böszme sok bites
integerekké alakítja mindig a számokat, és azokkal számol belül...

Az is érdekes, hogy a P4-nél ilyen hatalmas a teljesítményesés (közel
300-szorosára nő a végrehajtási idő)

Tudjátok ennek az okát?

Nagyon kiváncsi lennék, hogy AMD processzorokon van-e ilyen
teljesítménybeli törés, és hol?... És nem x86 procikon?



--
sassi