Šta je novo?

Odnos 64 bitnih sistema AMD vs Intel

monteboy je napisao(la):
Bilo kako bilo jedna od opcija je implicirala intrinsic, uglavnom nije ni jedna koju sam ti ja bio postovao.

Da ja sam probao u firmi iz VS2003 IDE-a gde je default /O2.

Ali to znaci da ti nisi uopste koristio jace optimizacije? Mislim na /O1 i /O2? Koliko sam video ni kompajleru je jedino default /Ot?

monteboy je napisao(la):
Koliko se ja secam patch je bio za P4 Prescott i to SSE3 !, e sad u detalju ga neznam ni ja tako samo mozemo naslutiti sta je optimirano istim u svakom slucaju uporedjenje se ne moze izvrsiti na korektan nacin ako se modifikuje verzija benchmark'a u bilo kom smislu za pojedini procesor.

Bile su dve verzije -- northwood_pi (SSE2) i prescott_pi (SSE3).

Sustina oba patch-a je da se eliminise promena moda zaokruzivanja pri konverziji double u integer -- nista vise od toga. To se kod SSE3 patch-a se postize koriscenjem nove FPU instrukcije FISTTP umesto FISTP:

Kod:
Code without SSE3:

	fstcw <old FCW>
	movw ax, <old FCW>
	or ax, 0xc00
	movw <new FCW>, ax
	fldcw <new FCW>
	fistp <INT>
	fldcw <old FCW>

Code with SSE3:

	fisttp  <INT>

Kod SSE2 patch-a se to isto postize uz pomoc instrukcije CVTTSD2SI i malo glue koda koji preuzima double vrednost sa stacka i vraca int. Sta god da je bilo u SSE2 patch-u izvrsavalo bi se i na P4 i na A64 tako da je takav test bilo moguce usvojiti kao validan.

monteboy je napisao(la):
Pa vjerovatno utice i malo cinjenica da je moj sistem clocknut na 2650 Mhz sto bi znacilo 650 MHz vise od default takta. Ipak razlika je i sobzirom te cinjenice prevelika predpostavljam da A64 jednostavno bolje lezi MS kompilat veceras cu ti poslati source , onda mozes odradit optimizaciju za Intel interesantno bi bilo onda uporediti ASM instrukcije da se ustanovi gdje lezi problem.

Moguce, ja bih ti samo jos predlozio da za alokaciju nizova ipak koristis VirtualAlloc() umesto new posto ona garantuje poravnanje memorije na 4 KB (page size granularity) pa ce biti lakse implementirati eventualne optimizacije.
 
Sa malim zaksnjenjem evo aktuelni code , napravi optimizaciju za Prescott bas me interesuje razlika

Kod:
#include "stdafx.h"
#include <math.h>
#include <sys/timeb.h>
#include <stdlib.h>
#include <float.h>
#include <windows.h>

const long _max_loop_count=10000; 
const long _max_data_count=10000; 

enum CalcOP
{
	CalcOP_PowLogSinCos = 0
};

double* data1=NULL;
double* data2=NULL;
double* res=NULL;

unsigned int fl_exception_mask;

_timeb t1,t2;
double f1,f2;
double d1,d2;

///////////////////////////////////////////////////////////////////////////////////////////////
/**/
/*********************************************************************************************/      
/*** initializiranje slucajnih double vrijednosti , count oznacava velicinu array'a    
/**/ void InitRandomData(double* fdata,const long count);
/*********************************************************************************************/      
/*** Pokretanje petlje za izracunavanje odgovarajuce operacije 
/**/ void RunLoop(enum CalcOP nOP);
/*********************************************************************************************/      
/**/ void Calc(double* res,double* data1,double* data2,enum CalcOP,const long count);
/*********************************************************************************************/      
/**/ void EnableSSE2(bool bState);
/**/
/**/ void PrintCheckSum();
///////////////////////////////////////////////////////////////////////////////////////////////

int _cdecl _tmain(int argc, _TCHAR* argv[])
{
	data1   = new double[_max_data_count];
	data2   = new double[_max_data_count];
	res		= new double[_max_data_count];

	fl_exception_mask = _control87(0,0);

	//initializiraj oba Array'a sa slucajnim double vrijednostima
	InitRandomData(data1,_max_data_count);
	InitRandomData(data2,_max_data_count);

	// aktiviraj SSE2 podrsku u Common Runtime Math funkcijama
	EnableSSE2(true);

	printf("\n\nSSE2 podrska aktivirana,stisni taster za pocetak");
	getchar();

	// odradi loop sa _max_data_count operacija sa tekucim zarezom i ukljucenim SSE2
	RunLoop(CalcOP_PowLogSinCos);
	
	d1 = f2-f1;
    
	// deaktiviraj SSE2 podrsku u Common Runtime Math funkcijama
    EnableSSE2(false);

	printf("\n\nSSE2 podrska deaktivirana,stisni taster za pocetak");
	getchar();

	// odradi loop sa _max_data_count operacija sa tekucim zarezom i izgasenim SSE2
	RunLoop(CalcOP_PowLogSinCos);
	
	d2 = f2-f1;

	double rf = (d2 /(d1/(double)100)) - (double)100;
	printf("\n\nrazlika : %.2f %%\n",rf);
	
	PrintCheckSum();

	getchar();

	// ocisti sve sa 
	delete[] data1;
	delete[] data2;
	delete[] res;
	
	return 0;
}

void RunLoop(enum CalcOP nOP)
{	
	_ftime(&t1);
	
	for(long l=0;l<_max_loop_count;l++)
		Calc(res,data1,data2,nOP,_max_data_count);
    
	_ftime(&t2);

	f1 = (double)t1.time+(double)(t1.millitm / (double)1000);
	f2 = (double)t2.time+(double)(t2.millitm / (double)1000);

	printf("izvrsno vrijeme : %.3f s",f2 - f1);
}

// initializiraj podatke sa slucajnim double vrijednostima
void InitRandomData(double* fdata,const long count)
{
	for(long i=0;i<count;i++)
	{
		_timeb t;
		_ftime(&t);
		srand( t.millitm );

        fdata[i] = 1/(1 + rand());
	}
}

// izvrsi odgovarajucu operaciju sa operantima iz data1 i data2 i spremi rezultat u res
void Calc(double* res,double* data1,double* data2,enum CalcOP nOP,const long count)
{
	static long lCounter=0;

	for(long i=0;i<count;i++,lCounter++)
	{
		// ispisi tacku nakon svake 10.000.000'ste operacije
		if(!(lCounter % 10000000))
			printf(".");

		switch(nOP)
		{
			case CalcOP_PowLogSinCos:
				res[i] = pow(log(atan(data1[i])/atan(data2[i])) -  log(exp(data1[i])*exp(data2[i])),2); 
				break;
		}	
	}
}

void EnableSSE2(bool bState)
{
	if(bState)
	{
		_control87(_EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW | _EM_INEXACT ,_MCW_EM);
		_set_SSE2_enable(true);
	}
	else
	{
		_set_SSE2_enable(false);
		_control87(fl_exception_mask,_MCW_EM);
	}
}

// HEX(checksum + d2 - d1)
void PrintCheckSum()
{
	char path[_MAX_PATH];
	GetModuleFileName(NULL,path,_MAX_PATH);

	FILE* pFile = fopen(path,"r");
	
	DWORD checksum=0;

	while(!feof(pFile))
		checksum+=fgetc(pFile);
			
    fclose(pFile);

	double fcheck = checksum+(d2-d1);
    
	double l1 = floor(fcheck);
	double l2 = fcheck - l1;

	printf("\nvalidacija : %X.%X",(long) l1,(long) (l2*1000));
}

// coded by Monteboy 2005

Koga interesuje kao Executable :
 

Prilozi

Poslednja izmena:
Kako se ponasa 32bit'ni kompilat na 64bit'nom operativnom ?
Razlika je dobre 2 sekunde u korist 64 bitnog operativnog.

Hardware parametri su totalno bili identicni (Bios opcije , radni takt sistema),
programi i servisi koji su u pozadini radili.

mozes pogledati ovdje :
 

Prilozi

  • 32BitOn64Bit.webp
    32BitOn64Bit.webp
    48.1 KB · Pregleda: 63
Poslednja izmena:
Dakle, evo sta sam uradio:

- napravio sam DLL koji eksportuje dve funkcije: Calc_FPU i Calc_SSE2
- Funkcije su u odvojenim .c fajlovima
- Calc_FPU je prevedena MSVC-om sa /G7 /O2 i dobijen je FPU kod osim za pow()
- Calc_SSE2 je prevedena ICC-om sa /G7 /O3 /arch:SSE2 i dobijen je SSE2 kod koji bi trebao da radi i na A64 (nema provere da li je Intel CPU u kodu)
- Zbog izmestanja funkcija u DLL izbacen je printf koji ispisuje tackice
- Od ostatka koda sam napravio novu konzolnu aplikaciju koja zove DLL prevedenu sa MSVC (/G7 /O2)

Rezultat je kod mene sledeci:

Testiranje SSE2 u toku, sacekajte... 13.281 s
Testiranje FPU u toku, sacekajte... 162.000 s


Razlika : 1119.79 %

Sta jos nisam uradio:

- Nisam provalio zasto je FPU kod toliko sporiji na Intelu
- Nisam napravio 64-bitni build ali planiram da uradim i to cim budem imao vremena

Dakle, u prilogu binarna verzija pa ko zeli neka proba. Monteboy, zamolio bih te da probas i da mi javis rezultat. Ako te zanima, postovacu ceo projekat (i za dll i za exe) i to cim napravim 64-bitnu verziju.
 

Prilozi

audiofreak je napisao(la):
Dakle, evo sta sam uradio:

- napravio sam DLL koji eksportuje dve funkcije: Calc_FPU i Calc_SSE2
- Funkcije su u odvojenim .c fajlovima
- Calc_FPU je prevedena MSVC-om sa /G7 /O2 i dobijen je FPU kod osim za pow()
- Calc_SSE2 je prevedena ICC-om sa /G7 /O3 /arch:SSE2 i dobijen je SSE2 kod koji bi trebao da radi i na A64 (nema provere da li je Intel CPU u kodu)
- Zbog izmestanja funkcija u DLL izbacen je printf koji ispisuje tackice
- Od ostatka koda sam napravio novu konzolnu aplikaciju koja zove DLL prevedenu sa MSVC (/G7 /O2)

Rezultat je kod mene sledeci:

Testiranje SSE2 u toku, sacekajte... 13.281 s
Testiranje FPU u toku, sacekajte... 162.000 s


Razlika : 1119.79 %

Sta jos nisam uradio:

- Nisam provalio zasto je FPU kod toliko sporiji na Intelu
- Nisam napravio 64-bitni build ali planiram da uradim i to cim budem imao vremena

Dakle, u prilogu binarna verzija pa ko zeli neka proba. Monteboy, zamolio bih te da probas i da mi javis rezultat. Ako te zanima, postovacu ceo projekat (i za dll i za exe) i to cim napravim 64-bitnu verziju.


Nesto si kod FPU'a zeznuo jer je nemoguce toliko velika razlika na Intel'u izmedju SSE2 i FPU

Tvoja aplikacija daje sledece rezultate na mom sistemu :
 

Prilozi

  • audiofreak.gif
    audiofreak.gif
    13 KB · Pregleda: 89
monteboy je napisao(la):
Nesto si kod FPU'a zeznuo jer je nemoguce toliko velika razlika na Intel'u izmedju SSE2 i FPU

I ja sam se ponadao da sam zeznuo ali izgleda da je tako, samo mi jos nije jasno zasto. Gledao sam asemblerski listing i stvarno je generisan normalan FPU kod. E sad, zasto je tolika razlika nije mi jasno, ali imao sam je i sa tvojim programom samo sto mi je kod njega i SSE2 bio mnogo sporiji u odnosu na tvoj rezultat.

Proteracu ga kroz VTune da vidim mogu li da provalim sta ga toliko usporava. Ocigledno je neki zesci penal u pitanju.
 
audiofreak je napisao(la):
I ja sam se ponadao da sam zeznuo ali izgleda da je tako, samo mi jos nije jasno zasto. Gledao sam asemblerski listing i stvarno je generisan normalan FPU kod. E sad, zasto je tolika razlika nije mi jasno, ali imao sam je i sa tvojim programom samo sto mi je kod njega i SSE2 bio mnogo sporiji u odnosu na tvoj rezultat.

Proteracu ga kroz VTune da vidim mogu li da provalim sta ga toliko usporava. Ocigledno je neki zesci penal u pitanju.

Ma 100% imas gresku kod FPU racunice jer i na moj neoptimirani kompilat (bez /O2 ili /O3) nisi imao toliku razliku, razlika ti je bila 51%
 
monteboy je napisao(la):
Ma 100% imas gresku kod FPU racunice jer i na moj neoptimirani kompilat (bez /O2 ili /O3) nisi imao toliku razliku, razlika ti je bila 51%

Vidi, bila je razlika 51% ali je bilo mnogo sporije od tvog rezultata tako da mu to dodje na isto.

Ne moze biti greske kad je MSVC preveo kod za FPU, a kod je isti kao za SSE2 verziju, tj. razlikuje se samo ime funkcije, ostalo je copy & paste.

EDIT:

Poslao sam kod Intelu. Videcemo za koji dan.
 
Poslednja izmena:
audiofreak je napisao(la):
Vidi, bila je razlika 51% ali je bilo mnogo sporije od tvog rezultata tako da mu to dodje na isto.

Ne moze biti greske kad je MSVC preveo kod za FPU, a kod je isti kao za SSE2 verziju, tj. razlikuje se samo ime funkcije, ostalo je copy & paste.

EDIT:

Poslao sam kod Intelu. Videcemo za koji dan.

Disassemblirao sam tvoj kompilat i primijetio da u drugom dijelu (FPU) koristis intrinsic funkcije , namjerno ?
 
Znaci da rezimiramo : AMD postize dobre rezultate i na jednom i na drugom Kompajleru sa /O2 ili /O3 optimizacijom nebitno. Intel P4 Prescott iz jos nepoznatih razloga kod FPU'a daje veoma slabe rezultate kod oba kompajlera dok su mu SSE2 rezultati adekvatni AMD 64 3200+

Kad govorimo o neoptimiranom kodu sa i bez SSE2 posebno MS kompilat AMD u ovom slucaju daleko stoji ispred Intel'a isto za mene neshvatljivo kao da kod neoptimiranog code'a Intel ne uspijeva da zaposli svoje racunarske jedinice.

Sve u svemu rezultati govore da je AMD u prosjeku univerzialniji CPU.

I ranije sam slusao izjave tipa "Intel'ov FPU je rupa ali nisam mogao da vjerujem da je tolika razlika"

Nadam se da ce Intel na tvoj source imati validan razlog za ovako losu prestavu.
 
monteboy je napisao(la):
Disassemblirao sam tvoj kompilat i primijetio da u drugom dijelu (FPU) koristis intrinsic funkcije , namjerno ?

Da, namerno da bih bio siguran da je FPU kod generisan, tj. da se ne koristi slucajno SSE2.

monteboy je napisao(la):
Intel P4 Prescott iz jos nepoznatih razloga kod FPU'a daje veoma slabe rezultate kod oba kompajlera dok su mu SSE2 rezultati adekvatni AMD 64 3200+

Zapravo jos nisam probao FPU kod generisan sa Intelom jer novi kompajler (8.1) ne uspevam da nateram da napravi tacno sta ja hocu (izbacili su podrsku za sve starije procesore od P3). Microsoftov FPU kod svakako lose radi. SSE2 rezultati su malo sporiji nego na overklokovanom A64 3200+.

Hajde ako te ne mrzi probaj 64-bitnu verziju bas me zanima kako to radi. Imaj na umu da mozda ni ne radi jer ja nemam nacina da je proverim dok ne nabavim Pentium 630. Prevedena je sa MSVC kompajlerom iz DDK 3790 i ICC-om za EM64T.
 

Prilozi

audiofreak je napisao(la):
Da, namerno da bih bio siguran da je FPU kod generisan, tj. da se ne koristi slucajno SSE2.

To opet nije pravo uporedjenje jer tvoji motivi su bili optimirati code a moji su bili uociti na razliku SSE2 i FPU instrukcija bez posebnih optimizacija -> totalno isti source

Kao druga stvar uporedjivanje kompilata razlicitih kompajlera je isto nerealno jer sasvim je logicno da Intel C++ bolje optimira za P4 nego za AMD procesore. Cinjenica da Intel na MSVC kompilatu propada u zemlju je opet samo Intel'ov problem.

I nije tacno da Microsoftov Kompajler optimira za sve CPU'e lose , veceras cu ti odraditi kompilat koji ima optimizaciju /O2 kao i jednu mogucu varijantu optimizacije code'a pa ces da vidis koliku prednost samo donosi izbacivanje printf funkcije koju si ti uklonio u tvojoj verziji, sinoc sam na brzinu samo nju izbacio i imao sam 3 sekunde manje bez ikakvih dodatnih optimizacija -> rollout petlji , optimizacija memori pristupa itd.

Tvoj optimirani code sa Intel Kompajlerom je na mom AMD 64 radio 30% brze nego na tvom P4 dok je MSVC radio i 5 puta brze.

A posto si veoma ubijedjen da je to samo prednost zbog overclocka dobices i dokaz na Default taktu da je rezultat na A64 opet bolji iako je kode optimiran prvenstveno za Intel.

Hajde ako te ne mrzi probaj 64-bitnu verziju bas me zanima kako to radi. Imaj na umu da mozda ni ne radi jer ja nemam nacina da je proverim dok ne nabavim Pentium 630. Prevedena je sa MSVC kompajlerom iz DDK 3790 i ICC-om za EM64T.

Tvoj 64bitni primjer na Win64 postize veoma lose rezultate potrebno mu je preko 30 sekundi ????
 
Poslednja izmena:
monteboy je napisao(la):
To opet nije pravo uporedjenje jer tvoji motivi su bili optimirati code a moji su bili uociti na razliku SSE2 i FPU instrukcija bez posebnih optimizacija -> totalno isti source

Da, ali ja sam pokusao da uporedim optimizovan FPU kod i optimizovan SSE2 kod, a ti si preveo bez optimizacija.

monteboy je napisao(la):
Kao druga stvar uporedjivanje kompilata razlicitih kompajlera je isto nerealno jer sasvim je logicno da Intel C++ bolje optimira za P4 nego za AMD procesore.

Cemu sad ovakva opaska kad SSE2 kod generisan ICC-om radi brze i kod tebe?


monteboy je napisao(la):
I nije tacno da Microsoftov Kompajler optimira za sve CPU'e lose

Slazem se da nije tacno. MSVC uopste ne optimizuje ni za jedan procesor, bar ne verzije pre VS 2005. Tek sa novim kompajlerom se situacija popravlja.

monteboy je napisao(la):
pa ces da vidis koliku prednost samo donosi izbacivanje printf funkcije koju si ti uklonio u tvojoj verziji, sinoc sam na brzinu samo nju izbacio i imao sam 3 sekunde manje bez ikakvih dodatnih optimizacija -> rollout petlji , optimizacija memori pristupa itd.

Tih 3 sekunde nisu bitne uopste, i ti i ja znamo da mala razlika postoji jer je to izbaceno. Tri sekunde manje se dobije i za FPU i za SSE2 tako da ne utice na poredjenje.

monteboy je napisao(la):
Tvoj optimirani code sa Intel Kompajlerom je na mom AMD 64 radio 30% brze nego na tvom P4 dok je MSVC radio i 5 puta brze.
A posto si veoma ubijedjen da je to samo prednost zbog overclocka dobices i dokaz na Default taktu da je rezultat na A64 opet bolji iako je kode optimiran prvenstveno za Intel.

Prvo, ti imas 3200+ sto bi trebao biti ekvivalent 3.2 GHz P4 pa ga jos i overklokujes i to prilicno, a ja imam 2.8 GHz procesor koji radi na defaultu. To je slozices se stvar koja "malo" ometa direktno poredjenje. A opet moj CPU sa SSE2 optimizacijom zaostaje samo 30%. Ja sam prilicno zadovoljan takvim ishodom ne bas sasvim fer poredjenja.

Drugo, kod koji je generisao ICC nema nikakvih specificnosti za P4 (koristio sam samo genericke SSE2 optimizacije) i daje ubrzanje i kod tebe i kod mene.

Ti si imao 19.734 s sa tvojim 32-bitnim exe-om, jel tako? Odbi 3 s koje pominjes za printf i dobices 16,734 s. Sa ICC-om imas 10.531 s. To je 58.9 % brze nego sa MSVC-om pa ti vidi koliko je MSVC dobar, koliko ICC optimizuje samo za Intel P4 i kako AMD-u optimizacija ne treba.

monteboy je napisao(la):
Tvoj 64bitni primjer na Win64 postize veoma lose rezultate potrebno mu je preko 30 sekundi ????

Za SSE2 ili za FPU? Daj oba rezultata. Kao sto rekoh, ja ne mogu da probam, nemam 64-bitni CPU jos uvek.
 
Slatko se nasmijah na ovu tvoju izjavu da si zadovoljan sa 30% razlike na Intel Kompajleru.

30% bukvalno prestavljeno ti doce na tvojih 2,8 GHz -> dodatnih 900 MHz znaci Intel P4 na 3700 MHz a ja imam AMD 64 3200+

Jos mi nisi odgovorio zasto je razlika kod MSVC'a 500% i to u oba testa SSE2 i FPU
 
monteboy je napisao(la):
Slatko se nasmijah na ovu tvoju izjavu da si zadovoljan sa 30% razlike na Intel Kompajleru.

Ne znam da li se namerno pravis da ne razumes ili sta?

Ja sam rekao da sam zadovoljan sto je kod mene SSE2 kod sporiji 30% na 2.8 GHz procesoru nego kod tebe na 3200+ pa jos overklokovanom. Nemoj da izvrces moje reci.

monteboy je napisao(la):
Jos mi nisi odgovorio zasto je razlika kod MSVC'a 500% i to u oba testa SSE2 i FPU

Jos uvek to nisam provalio, ali radim na tome. Javicu ti sigurno, ne brini. Ti si meni duzan rezultate za FPU i SSE2 za 64-bitni kod.
 
Athlon 64 -- the art of high-speed error ignoring :d

Dakle, posle duzeg kopanja ustanovio sam u cemu je problem:

Kod:
void InitRandomData(double* fdata,const long count)
{
	for(long i=0;i<count;i++)
	{
		_timeb t;
		_ftime(&t);
		srand( t.millitm );

        fdata[i] = 1/(1 + rand());
	}
}

Sta radi ova rutina? Navodno inicijalizuje pocetne vrednosti za racunanje u data1 i data2 nizovima. Zasto navodno? Zato sto:

Kod:
        fdata[i] = 1/(1 + rand());

Uvek daje 0 jer je cela desna polovina izraza integer-ska i kao takva se izracunava. Ispravan kod glasi:

Kod:
        fdata[i] = 1.0/(1.0 + rand());

Moze i samo . umesto .0 naravno.

Sta je posledica toga? Posto je atan(0) = 0, dolazi do deljenja nule sa nulom u izrazu sto izaziva FPU exception INVALID OPERATION. To je razlog za dobar deo usporenja koda na Intel procesoru kome takav exception ocigledno manje prija nego AMD-ovom procesoru. Drugim recima, AMD brze prelazi preko gresaka i po meni to je lose jer ovoliko usporenje je odlican signal da nesto sa kodom nije u redu ako vec programer ne predvidi mehanizam da uhvati ovakve greske.

Ali to nije sve... Sta ova rutina jos radi pogresno?

Kod:
	for(long i=0;i<count;i++)
	{
		_timeb t;
		_ftime(&t);
[b]		srand( t.millitm );[/b]

        fdata[i] = 1/(1 + rand());
	}

1. Poziva srand() u petlji!

- srand() se zove samo jednom da bi se inicijalizovao seed (pocetna vrednost) za random generator.

2. Poziva srand() sa parametrom t.millitm koji je vreme u milisekundama!

- ceo ovaj kod za inicijalizaciju se zavrsava za < 1 ms tako da to znaci da je seed stalno isti. Stalno isti seed = stalno iste vrednosti koje vraca rand(). Dakle, nema nikakve slucajne vrednosti, sve su iste.

Ispravan kod bi mogao glasiti ovako:

Kod:
void InitRandomData(double* fdata, const long count)
{
	long i;

	__asm	rdtsc;
	__asm	mov	dword ptr [i], eax;

	srand(i);

	for (i = 0; i < count; i++) {
		fdata[i] = 1.0 / (1.0 + rand());
	}
}

RDTSC vraca broj CPU taktova proteklih od ukljucenja. Gornja 32 bita ignorisemo jer se sporije menjaju, dovoljno je samo procitati donja 32 bita TSC registra da bi dobili dosta drugaciju vrednost od prethodne za seed.

Moj rezultat se nakon ovoga naravno promenio:

D:\work\cpp\bench\release>bench.exe
Testing SSE2, please wait... 18.531 s
Testing FPU, please wait... 76.250 s


Difference : 311.47 %

I dalje je moj procesor sporiji od tvog, ali sada razlika vise nije toliko drasticna. Molim te, testiraj ponovo sa programom u prilogu i daj tvoje rezultate sada kada se vise ne racuna sa nulama. Bilo bi lepo i da testiras na default taktu. U arhivi ti je i source pa uzivaj.

Da napomenem samo da i ovaj ispravljen kod i dalje ima FP exceptions (tipa INEXACT -- kada neki broj ne moze da se predstavi tacno datim brojem bitova). Ukoliko bi se to eliminisalo, kod bi radio jos brze (odnosno normalno) i na Intel-u. Suvise ovakvih izuzetaka signalizira da tip koji je izabran za reprezentaciju podataka (u ovom slucaju double) nije dovoljno precizan za zahtevani proracun. U realnim aplikacijama ovo se retko javlja kad su ulazni podaci ispravni, a tamo gde se javlja cesce obicno rezultira pogresnim rezultatom proracuna ili prekidom rada programa. To se ovde nije desilo jer su izuzeci maskirani, a izlazne vrednosti se ne proveravaju jer nema smisla posto su ulazni parametri generisani funkcijom rand().
 

Prilozi

Poslednja izmena:
Evo i nove verzije, nadam se da je ova poslednja. Primetio sam da i pored toga sto generise FPU kod za atan(), exp() i log(), MSVC ne generise FPU kod za pow() pa je postojala mogucnost da se izvrsi SSE2 verzija pow() funkcije u FPU varijanti testa. Sada je to sa najnovijim testom nemoguce.

Moj rezultat:
bench.gif


Takodje sam ubacio i MSVC SSE2 da se vidi ciji kompajler je bolji 🙂

Nova verzija u prilogu sa sve source code-om. Od 64-bitnog release-a sam trenutno odustao buduci da jos nemam gde da ga probam.
 

Prilozi

audiofreak je napisao(la):
Evo i nove verzije, nadam se da je ova poslednja. Primetio sam da i pored toga sto generise FPU kod za atan(), exp() i log(), MSVC ne generise FPU kod za pow() pa je postojala mogucnost da se izvrsi SSE2 verzija pow() funkcije u FPU varijanti testa. Sada je to sa najnovijim testom nemoguce.

Moj rezultat:
bench.gif


Takodje sam ubacio i MSVC SSE2 da se vidi ciji kompajler je bolji 🙂

Nova verzija u prilogu sa sve source code-om. Od 64-bitnog release-a sam trenutno odustao buduci da jos nemam gde da ga probam.

E sad vise nista ne razumijem kod tvojih rezultata , dobro ajd uticala je greska u initializaciji array'a to donekle razumijem ali ove 18,xxx sekundi ne razumijem ama uopste u prvom postu si bio postavio 13,xxx s sad je na ICC 18,xxx s skocila iako si ispravio gresku i nebi trebalo da dodje do FPU exceprion's

Kako objasnjavas to ?

Druga stvar kompilat MSVC kod SSE nisi optimirao uopste ni sa /O1 ni /O2
Da ICC bolje optimira za Intel sam ti 8 puta vec rekao to nije potrebno utvrdjivat to zna svaka pticica na grani.

Sto se tice poslednje verzije, sa tvoje strane mozda.Sa moje dolaze optimirane verzije za AMD 32 Bitna i AMD 64 bitna preko vikenda ce biti vise jer sad nemam vremena za to.

Nije mi bio povod od pocetka da se bakcem sa optimizacijom za AMD glavni cilj mi je bio ukazati samo na razliku izmedju SSE i FPU ali posto si zapeo dobices MSVC kompilat koji ce raditi na Default taktu
AMD 64 3200+ brze od tvog ICC'je tako da se i sam uvjeris da nije MSVC problem nego Intel samo dobro odradjuje ICC generisani code sto uopste nije fleksibilno.
 
Poslednja izmena:
monteboy je napisao(la):
E sad vise nista ne razumijem kod tvojih rezultata , dobro ajd uticala je greska u initializaciji array'a to donekle razumijem ali ove 18,xxx sekundi ne razumijem ama uopste u prvom postu si bio postavio 13,xxx s sad je na ICC 18,xxx s skocila iako si ispravio gresku i nebi trebalo da dodje do FPU exceprion's

Kako objasnjavas to ?

Kao sto rekoh, razlika je nastala zbog toga sto se sada zaista nesto racuna. SSE2 kod nije osetljiv na exceptions kao FPU. Ako probas i kod tebe ce verovatno biti malo sporije. Uostalom, vrati nule u niz pa ces opet dobiti brze za SSE2 i sporije za FPU.

monteboy je napisao(la):
Druga stvar kompilat MSVC kod SSE nisi optimirao uopste ni sa /O1 ni /O2

Ima komentar u makefile zasto nisam:

# ovde se ne sme staviti /O2 jer sadrzi /Og sto u ovom slucaju iz
# nekog meni nepoznatog razloga tera MSVC kompajler da generise FPU
# kod uprkos postojanju /arch:SSE2 opcije tako da je ovo najvise sto
# moze od njega da se dobije po pitanju SSE2 optimizacija

monteboy je napisao(la):
Sto se tice poslednje verzije, sa tvoje strane mozda.Sa moje dolaze optimirane verzije za AMD 32 Bitna i AMD 64 bitna preko vikenda ce biti vise jer sad nemam vremena za to.

Nemam nista protiv, samo povedi racuna da ne bude gresaka koje AMD brze izvrsava nego Intel 😀
 
Iako si trazio definiciju po netu za goto komandu i sugestiju izbjegavanja iste opet je koristis ????

Evo korekcija tvoga code'a kako bi izbjegao spageti code :

alokiranje i ciscenje memorije po mogucnosti odvojiti u posebnu funkciju

Kod:
bool AllocMemory()
{
	return  ((data1 = (double*)valloc(_max_data_count * sizeof(double))) && 
		    (data2 = (double*)valloc(_max_data_count * sizeof(double))) &&
	        (res = (double*)valloc(_max_data_count * sizeof(double))) );
}

void FreeMem()
{
	if(res) vfree(res);
	if(data2) vfree(data2);
	if(data1) vfree(data1);

	data1 = data2 = res = NULL;
}


Vec kad koristis bench.cpp onda iskoristi i prednosti C++

Definisi posebnu klassu za hvatanje Exception's

Kod:
class CMYException
{
protected:
	DWORD  m_LastError;
	LPVOID m_lpMsgBuf;

public:
	CMYException(DWORD errCode) 
	{	
		m_LastError = errCode;
	};

	void ShowError()
	{
		FormatMessage(	FORMAT_MESSAGE_ALLOCATE_BUFFER | 
						FORMAT_MESSAGE_FROM_SYSTEM | 
						FORMAT_MESSAGE_IGNORE_INSERTS,
						NULL,
						m_LastError,
						MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
						(LPTSTR) &m_lpMsgBuf,
						0,
						NULL 
					 );

		MessageBox( NULL, (LPCTSTR)m_lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION );
	
		LocalFree( m_lpMsgBuf );
	};

	virtual ~CMYException() {};
};


U Main funkciji vise nije potrebno dva puta testirati pointere a i ciscenje Array'a se desava samo na jednom mjestu uz to izbacujes Sistemsku poruku kod nemogucnosti alokacije memorije

Kod:
	try
	{
		if(!AllocMemory())
		       throw CMYException(GetLastError());
			
		InitRandomData(data1, _max_data_count);
		InitRandomData(data2, _max_data_count);
                  
                        .......... 
                        .... 
                        ...


	}
	catch(CMYException e)
	{
		e.ShowError();
	}

	FreeMem();

	return 0;
 
Poslednja izmena:
monteboy je napisao(la):
Iako si trazio definiciju po netu za goto komandu i sugestiju izbjegavanja iste opet je koristis ????

Da, obozavam goto komandu. Opet me nisi razumeo, ja je ne izbegavam nego je koristim jer takva preporuka stoji u kodnom standardu za linux kernel -- citljivije je za ljude, a znam da ce kompajler na kraju generisati jmp kako god ja da napisem.

monteboy je napisao(la):
alokiranje i ciscenje memorije po mogucnosti odvojiti u posebnu funkciju

Koja je prednost toga? Jedan vise call i return? Pa ionako ce biti inline, a kod nije toliko komplikovan da bi se uvodila funkcija za to.

monteboy je napisao(la):
Vec kad koristis bench.cpp onda iskoristi i prednosti C++

Zapravo hteo sam i to kao C, ali mi to nije bio prioritet pa je ostalo CPP:

Kod:
_timeb	t1, t2;

Koje treba za C da glasi:

Kod:
struct _timeb	t1, t2;

Takodje i definicije varijabli u sred koda (rf1, itd) treba pomeriti na pocetak.

monteboy je napisao(la):
Definisi posebnu klassu za hvatanje Exception's

To je sad vec kozmetika, i nepotrebno komplikuje jednostavan program omogucavajuci ti da pogresis na vise mesta nego do sada.

monteboy je napisao(la):
U Main funkciji vise nije potrebno dva puta testirati pointere a i ciscenje Array'a se desava samo na jednom mjestu uz to izbacujes Sistemsku poruku kod nemogucnosti alokacije memorije

1. Ispitivanje izraza se prekida cim je uslov ispunjen
2. Ako su svi razliciti od NULL na izlazu iz programa nece biti drugog testa

Uostalom, ovo je potpuno nebitno jer nije u kriticnoj putanji koda (tj. u petlji) -- desava se samo jednom. Kod koji si predlozio je overkill za ovako prostu aplikaciju. Ako nista drugo, teze ga je prepraviti da ti signalizira koja alokacija nije uspela od tri za slucaj da te to zanima. Zaista ne vidim svrhu davanja kripticne sistemske poruke umesto sopstvene.

Ja sam za minimalizam u programiranju, sto jednostavnije to bolje i lakse za odrzavanje (a i brze radi u vecini slucajeva). Nazalost, da bi se nesto u startu kvalitetno osmislilo potrebno je vreme, a ti si rekao da vremena nema. Zato i imamo danas ovakav softver -- glomazan, spor i pun gresaka.

Znaci, ti neces da testiras tvoju masinu sa mojom poslednjom verzijom testa na default taktu? Ja sam probao svaki tvoj test, red bi bio da probas i ti ovo.

U prilogu ispravljena verzija source-a (sada je bench.c umesto bench.cpp). Proglasavam ovo verzijom 1.0 final -- uzivajte.
 

Prilozi

audiofreak je napisao(la):
Da, obozavam goto komandu. Opet me nisi razumeo, ja je ne izbegavam nego je koristim jer takva preporuka stoji u kodnom standardu za linux kernel -- citljivije je za ljude, a znam da ce kompajler na kraju generisati jmp kako god ja da napisem.

Onda preporuku nisi dobro razumio upravo ti jer goto je specificna komanda koja samo u specijalnim slucajevima ima osnova inache svaki imalo solidan programer je totalno izbjegava -> a ti je vrlo rado koristis. Sa time samo mogu zakljucit da nikad nisi odradio neki veci projekat jer sa silnim goto komandama biti u preglednosti bio brzo kraj. Assembler i jmp instrukcija je jedno strukturirani jezici tipa C ili hibridni tipa C++ su nesto drugo.

Postoji jednostavno pravilnik i stil programiranja koji se zove cist a goto definitivno kod C ili C++ programera spada u dirty rubriku htio ti to uviditi ili ne tako je.

Koja je prednost toga? Jedan vise call i return? Pa ionako ce biti inline, a kod nije toliko komplikovan da bi se uvodila funkcija za to.

Prednost je da se naucis sire da razmishljas i da prilagodjavas source za dodavanja i prosirenja a to podrazumijeva cist stil programiranja.
Ovo je banalan primjer hvatanja samo Exceptions za alokaciju memorije , Klasa se elegantno moze prosiriti za hvatanje FPU Exception's (SHU Exceptions) i sire sto bi kod ozbiljne aplikacije uvijek trebalo odraditi.

I nikad se kod programiranje ne radi o kozmetici nego bi po pravilu svaki dio source trebao da ima svoju osnovu.

P.S prije bi goto uvrstio u rubriku kozmetika !

E sad odakle tebe ideja da ce bench da ostane kommand line aplikacija ?

Vise ces saznati nakon vikenda a sad te ostavljam u nadi da ces optimirati jos malo kompilat jer ce ti trebati svaki djelic sekunde ..... 😀
 
Poslednja izmena:
monteboy je napisao(la):
Onda preporuku nisi dobro razumio upravo ti jer goto je specificna komanda koja samo u specijalnim slucajevima ima osnova inache svaki imalo solidan programer je totalno izbjegava -> a ti je vrlo rado koristis. Sa time samo mogu zakljucit da nikad nisi odradio neki veci projekat jer sa silnim goto komandama biti u preglednosti bio brzo kraj. Assembler i jmp instrukcija je jedno strukturirani jezici tipa C ili hibridni tipa C++ su nesto drugo.

Postoji jednostavno pravilnik i stil programiranja koji se zove cist a goto definitivno kod C ili C++ programera spada u dirty rubriku htio ti to uviditi ili ne tako je.

Bas si tvrdoglav. Lepo ti nekoliko puta navodim izvor, a ti neces da procitas. E sad cu da ti citiram:

Linux Kernel Coding Style je napisao(la):
Chapter 6: Centralized exiting of functions

Albeit deprecated by some people, the equivalent of the goto statement is
used frequently by compilers in form of the unconditional jump instruction.

The goto statement comes in handy when a function exits from multiple
locations and some common work such as cleanup has to be done.

The rationale is:

- unconditional statements are easier to understand and follow
- nesting is reduced
- errors by not updating individual exit points when making
modifications are prevented
- saves the compiler work to optimize redundant code away 😉

Kod:
int fun(int )
{
	int result = 0;
	char *buffer = kmalloc(SIZE);

	if (buffer == NULL)
		return -ENOMEM;

	if (condition1) {
		while (loop1) {
			...
		}
		result = 1;
		goto out;
	}
	...
out:
	kfree(buffer);
	return result;
}

Ako Linux kernel za tebe nije dovoljno veliki projekat koji bi prvi stradao od upotrebe goto komandi, onda stvarno Linus Torvalds ne zna sta prica.

O razlikama izmedju asemblera i strukturiranih jezika najbolje govori primer:

C/C++
Kod:
if (a == 10) {
	b = 20;
} else { // razlicito
	b = 30;
} // nastavi

Assembler
Kod:
	cmp	eax, 10
	jnz	razlicito
	mov	ebx, 20
	jmp	nastavi
razlicito:
	mov	ebx, 30
nastavi:
	...

Dakle, ta strukturiranost se na kraju postize uz pomoc jmp instrukcije koja je ekvivalent goto komande. U mnogim oblastima postoje mitovi, goto je mit medju slabije upucenim programerima.

Naravno da gornji asemblerski kod moze da se napise krace i brze bez uslovnih i bezuslovnih skokova koriscenjem CMOVcc instrukcije ali to sad nije tema.

monteboy je napisao(la):
Prednost je da se naucis sire da razmishljas i da prilagodjavas source za dodavanja i prosirenja a to podrazumijeva cist stil programiranja.

To je u redu ako si ti hteo nesto da dodajes, ja nisam. Nasi ciljevi su bili fundamentalno razliciti:

Ti si krenuo da nadogradjujes neispravan program -- tvoj kod je sadrzao greske koje su uticale drasticno na performanse na jednoj od testiranih platformi i tu je kraj price -- sam si se diskreditovao gorim pocetnickim greskama nego sto je ona sa nizom (lokalno .vs. globalno) za koju si prozvao mog ortaka. Svaka dalja diskusija na tu temu je izlisna. Kod se prvo testira i kad si siguran da nema gresaka tek onda se nadogradjuje.

Ja sam sa druge strane bio siguran da nesto nije u redu i moj cilj je prvenstveno bio da ispravim tu gresku. To sto sam usput neke stvari promenio prema sopstvenom nahodjenju bilo je zato sto sam smatrao da to najbolje odgovara trenutnom stanju tvog projekta. I dalje smatram da C++ nema sta da trazi u benchmark-u.

monteboy je napisao(la):
Ovo je banalan primjer hvatanja samo Exceptions za alokaciju memorije , Klasa se elegantno moze prosiriti za hvatanje FPU Exception's (SHU Exceptions) i sire sto bi kod ozbiljne aplikacije uvijek trebalo odraditi.

SEH (__try/__except) moze da odradi istu stvar daleko jednostavnije i za hvatanje FPU exception-a vec imam kod baziran na njemu. Medjutim, ako ti je cilj portabilnost koda onda svakako treba koristiti C++ try/catch/throw mehanizam. Posto sumnjam da ces praviti i Linux verziju glasam za C/SEH varijantu ako vec smatras da je to neophodno raditi error handling na taj nacin. Po meni je i if (x == NULL) dovoljno dobro.

monteboy je napisao(la):
E sad odakle tebe ideja da ce bench da ostane kommand line aplikacija ?

Pa nisam ni sumnjao da ce napredovati ka GUI varijanti, zato sam ti i napravio DLL. Nadam se samo da neces koristiti MFC za tako prostu stvar? Jedan dijalog bi bio dovoljan za ovo sto sada imas.

monteboy je napisao(la):
Vise ces saznati nakon vikenda a sad te ostavljam u nadi da ces optimirati jos malo kompilat jer ce ti trebati svaki djelic sekunde ..... 😀

Daj ti okaci tvoj rezultat sa ovim. Dok to ne vidim ne radim nista drugo.
 
monteboy je napisao(la):
Onda preporuku nisi dobro razumio upravo ti jer goto je specificna komanda koja samo u specijalnim slucajevima ima osnova inache svaki imalo solidan programer je totalno izbjegava -> a ti je vrlo rado koristis. Sa time samo mogu zakljucit da nikad nisi odradio neki veci projekat jer sa silnim goto komandama biti u preglednosti bio brzo kraj. Assembler i jmp instrukcija je jedno strukturirani jezici tipa C ili hibridni tipa C++ su nesto drugo.

SuSE 9.2 kernel 2.6.8-24 source - nesto malo vise od 3000 .c i .h fajlova ima u sebi goto <labela> , ukupan broj pojavljivanja goto je preko 30000.
 
Lukija je napisao(la):
SuSE 9.2 kernel 2.6.8-24 source - nesto malo vise od 3000 .c i .h fajlova ima u sebi goto <labela> , ukupan broj pojavljivanja goto je preko 30000.

Kad govorimo o cistom C programiranju onda si u pravu jer alternativa ne postoji ja sam ukazao da nijedan solidan C++ programer nece koristiti goto komandu to sto je Linux pisan u cistom C'u je sasvim druga stvar C++ kao i svaki moderan objektorijentisani jezik ima Exception handling koji cini goto komandu suvisnu upravo to pokusavam objasniti , detaljinije mozes pogledati ovdje :

http://www.cprogramming.com/tutorial/goto.html

Gledajuci vasu argumentaciju onda bi mogli formulirati i sledece posto je DOS 1.0 uradjen komplet u Assembleru najbolje bi bilo se vratiti korijenima i poceti izradjivati aplikacije na bitnom nivou to bi potrajalo jedno nekoliko mjeseci a ne daj boze da zatreba nakon odgovarajuceg vremena prosiriti aplikaciju dodati ili izmijeniti nesto onda bi tek bilo veselo.
 
audiofreak je napisao(la):
C/C++
Kod:
if (a == 10) {
	b = 20;
} else { // razlicito
	b = 30;
} // nastavi

Assembler
Kod:
	cmp	eax, 10
	jnz	razlicito
	mov	ebx, 20
	jmp	nastavi
razlicito:
	mov	ebx, 30
nastavi:
	...

Dakle, ta strukturiranost se na kraju postize uz pomoc jmp instrukcije koja je ekvivalent goto komande. U mnogim oblastima postoje mitovi, goto je mit medju slabije upucenim programerima.

Al si nasao primjer , jel moglo prostije ?
Kakve to sad ima veze sa Exception Handling'om da mi je samo znati ????


To je u redu ako si ti hteo nesto da dodajes, ja nisam. Nasi ciljevi su bili fundamentalno razliciti:

Ti si krenuo da nadogradjujes neispravan program -- tvoj kod je sadrzao greske koje su uticale drasticno na performanse na jednoj od testiranih platformi i tu je kraj price -- sam si se diskreditovao gorim pocetnickim greskama nego sto je ona sa nizom (lokalno .vs. globalno) za koju si prozvao mog ortaka. Svaka dalja diskusija na tu temu je izlisna. Kod se prvo testira i kad si siguran da nema gresaka tek onda se nadogradjuje.

Ja sam sa druge strane bio siguran da nesto nije u redu i moj cilj je prvenstveno bio da ispravim tu gresku. To sto sam usput neke stvari promenio prema sopstvenom nahodjenju bilo je zato sto sam smatrao da to najbolje odgovara trenutnom stanju tvog projekta. I dalje smatram da C++ nema sta da trazi u benchmark-u.

Iskreno da ti recem gore navedeni source je nastao u roku od dva minuta nit je debugiran niti sam provjeravao vrijednosti u array'u tako da nemozemo govoriti o nikakvom projektu postavljen je da se ti malo pozabavis sa kompiliranjem i uporedimo vrijednosti to sto je kasnije nastala ideja nekakvog bench'a je sasvim druga stvar ozbiljna namjera nekakvog projekta prvenstveno nije postojala. Kad govorimo o projektima onda se realizacija i postavljanje bilo kakvog source'a tek postavlja na kraju nakon analize , projekt plana utvrdjivanja uslova realizacije i sirokog testiranja aplikacije sto u ovom slucaju nije bilo.
 
Evo audiofreak da ti ispunim zelju i da te malo spustim na zemlju sto se tice ubedjenja u Intel P4 :

Odradio sam tvoj bench kao sto si i zatrazio spustao sam frikvenciju CPU'a sve dok nisam dosao na tvoje 18,xxx sekundi da bi imali odprilike uporedjenje :

audiofreak.gif


50 MHz ispod default takta mi je potrebno da bi dobio tvoje vrijeme e sad pogledajmo razliku kod neutralnog MSVC kompilata.

MSVC SSE2 razlika izmedju tvog i mog sistema punih 6 sekundi
MSVC FPU razlika izmedju tvog i mog sistema neshvatljivih 35 sekundi

Znaci potvrdilo se ono sto sam i bio rekao svi proizvodjaci software'a trebali bi da koriste ICC i nijedan drugi kompajler da bi postigli ekvivalentne rezultate AMD'a i to po mogucnosti samo SSE2 ili SSE3 jer u suprotnom Intel daleko ostaje iza AMD'a

To su bili medjurezultati tvoga bencha a tek ces da vidis sta radi AMD optimizacija 😀
 
Poslednja izmena:
monteboy je napisao(la):
Kad govorimo o cistom C programiranju onda si u pravu jer alternativa ne postoji ja sam ukazao da nijedan solidan C++ programer nece koristiti goto komandu to sto je Linux pisan u cistom C'u je sasvim druga stvar C++ kao i svaki moderan objektorijentisani jezik ima Exception handling koji cini goto komandu suvisnu upravo to pokusavam objasniti

Postoje alternative za exception handling u vidu setjmp/longjmp i Microsoftovih nestandardnih SEH (Structured Exception Handler) ekstenzija C standarda.

S obzirom da ja koristim C++ samo kada smatram da je neophodno, a za ovo kao sto rekoh mislim da je C++ kod overkill to je bio razlog da napisem kod onako kako sam ga napisao uz upotrebu goto komandi.

monteboy je napisao(la):
Al si nasao primjer , jel moglo prostije ?
Kakve to sad ima veze sa Exception Handling'om da mi je samo znati ????

Ako hoces, mogu i komplikovaniji primer da ti napisem :d

Pricao si o strukturalnim jezicima i ja sam ti pokazao na sta se ta "struktura" svodi u asembleru. Ima veze sa obradom izuzetaka jer se i ona na kraju svodi na uslovne i bezuslovne skokove. I samo da znas, moguce je koristiti Exception Handling i u asembleru, to nije privilegija samo "visih" programskih jezika 🙂

monteboy je napisao(la):
50 MHz ispod default takta mi je potrebno da bi dobio tvoje vrijeme

Slobodno si mogao da objavis rezultat na default taktu. Videli bi da nisi mnogo brzi od mene u ICC SSE2 kodu iako ti CPU ima 3200+ rating, a moj 2800.

monteboy je napisao(la):
MSVC SSE2 razlika izmedju tvog i mog sistema punih 6 sekundi
MSVC FPU razlika izmedju tvog i mog sistema neshvatljivih 35 sekundi

Znaci potvrdilo se ono sto sam i bio rekao svi proizvodjaci software'a trebali bi da koriste ICC i nijedan drugi kompajler da bi postigli ekvivalentne rezultate AMD'a i to po mogucnosti samo SSE2 ili SSE3 jer u suprotnom Intel daleko ostaje iza AMD'a

Da li ti shvatas sustinu ovih rezultata?

1. ICC je fenomenalan kompajler kad postize toliku razliku u odnosu na MSVC bez potrebe za promenom koda

2. ICC daje kod koji jednako bolje radi i na AMD-u

3. FPU kod je i na AMD-u sporiji od dobrog (ICC-ovog) SSE2 koda i to dosta, to znaci da i AMD-u itekako prija optimizacija

Dakle, ne pricam ja bezveze da softver treba optimizovati.

monteboy je napisao(la):
To su bili medjurezultati tvoga bencha a tek ces da vidis sta radi AMD optimizacija

Vazi, u medjuvremenu da bi malo izjednacili takmicenje uradio sam test na Pentiumu 640 (3.2 GHz EM64T) pod WinXP 64-bit:

bench.png


Dakle, ovo je 32-bitna verzija na 64-bitnom OS-u. Ako stignem (masina je kod mene do petka) pokusacu da napravim 64-bitnu verziju koja radi kako treba.
 
Nazad
Vrh Dno