Test velocistico: 5M iterazioni C/C#/Java

[Vash1986]

Salve a tutti.

Gioco a Ultima Online, non sui server ufficiali bensì su quelli unofficial. Tali server necessitano di un "emulatore", ossia un programma che funga da server per tutti i client UO che si connettono, che emula lo stile di gioco ufficiale dei server EA GAMES.

Uno dei miei emulatori preferiti, per il quale scripto anche, è RunUO, scritto interamente in C#. Ed è proprio scriptando che ho notato che in pochi istanti vengono eseguite centinaia se non migliaia di righe di codice.

Il metodo per colpire gli avversari, il movimento, l'intelligenza dei mostri... e ci sono server a cui si connettono sino a 100 persone assieme che non vanno oltre il 10% di utilizzo cpu con un athlon 2000+.

Mi è dunque venuto un dubbio riguardo le potenzialità del C# e del framework e ho fatto un simpatico test.

Ho creato 3 programmini, rispettivamente in C, C# e Java, con una sola funzione/classe che eseguiva 5 miliardi di iterazioni.

for ( i = 0; i < 1000000; i++ )
for ( j = 0; j < 5000; j++ )
a = 0;

Premetto che ho un a64 3200+ venice non overclockato, 1gb di ram 400mhz.
Il primo colpo mi è venuto quando la virtual machine di Java è riuscita a fare il tutto in 16s mentre l'eseguibile C ha impiegato 17s.

Poi ho scoperto con estremo stupore che "runnando" il programma in SharpDevelop (C#) ha impiegato SOLAMENTE 7s.

Qui c'è qualcosa che decisamente non mi torna... il C è conosciuto come uno dei linguaggi più efficaci e veloci. Certo non mi aspettavo che battesse il Java su operazioni elementari come un semplice ciclo for, ma non capisco davvero come sia possibile che il C# abbia impiegato meno di metà del tempo!

Voi che ne pensate?

[redcloud]

Ho appena fatto una prova tra C e Java su Debian e Sempron a 1800MHz.

C - 19sec
Java - 9 sec

[cionci]

Contate che qui può intervenire il loop unrolling... Ora non mi ricordo se i compilatori C/C++ lo fanno in automatico senza particolari opzioni di compilazione, ma probabilmente Java e C# lo fanno...

In pratica sostituiscono quelle chiamate con una lista di a = 0;

Prova ad immettere i e j da linea di comando:

for ( i = 0; i < argv[1]; i++ )
for ( j = 0; j < argv[2]; j++ )
a = 0;

e fate la stessa cosa per Java e C#...e vederete che probabilmente cambierà qualcosa...

[trallallero]

Originariamente inviato da cionci

Contate che qui può intervenire il loop unrolling... Ora non mi ricordo se i compilatori C/C++ lo fanno in automatico senza particolari opzioni di compilazione, ma probabilmente Java e C# lo fanno...

In pratica sostituiscono quelle chiamate con una lista di a = 0;

Prova ad immettere i e j da linea di comando:

for ( i = 0; i < argv[1]; i++ )
for ( j = 0; j < argv[2]; j++ )
a = 0;

e fate la stessa cosa per Java e C#...e vederete che probabilmente cambierà qualcosa...

sicuramente la prima cosa che cambierá é che ti dará almeno un warning sul

   i < argv[1]

ce lo mettiamo un atoi ?

scherzi a parte, non puó essere che magari il java o il C# hanno un compilatore "intelligente" che vede che ci sono migliaia di istruzioni identiche e semplicemente ... non le esegue ?

[sottovento]

In effetti, come dice trallallero, molti compilatori semplicemente eliminano questo codice. Uno di questi, se non sbaglio, e' proprio gcc con qualche strana opzione di ottimizzazione.
In questo caso, pero' si avrebbe un tempo di calcolo uguale a zero.

Una considerazione: il codice da eseguire e' davvero poco, e non puo' essere tradotto in macchina in modi cosi' diversi.
Sarebbe interessante comparare il codice generato. Per esempio, gcc -S dovrebbe generare il codice assembler. Anche Java ha un'opzione simile (sorry, non la ricordo!).

Cmq la differenza di 1 secondo potrebbe non essere significativa: potrebbe dipendere dal criterio usato per il calcolo dei tempi e dalle precisioni, sempre che ripetendo parecchie volte la prova non persista

[scorpion89]

Provando a usare qualke opzione di gcc il risultato è 1secondo.
usando queste opzioni
gcc -malign-double -funroll-all-loops -Os
trovate googlando un po'

Ciao

[VICIUS]

Sicuramente i compilatori jit di java e c# riescono ad intercettare le istruzzioni duplicate ad ogni ciclo e ad eliminarle. Questo puo farlo anche un compilatore C come gcc ma ci si deve ricordare di specificare un livello di ottimizzazione maggiore di 0.

$ gcc -O0 test.c -o test
$ time ./test

real    0m13.541s
user    0m12.065s
sys     0m0.212s

Mentre gia con -O1 C spazza via Java e C#

$ gcc -O1 test.c -o test
$ time ./test

real    0m0.005s
user    0m0.000s
sys     0m0.000s

ciao

[Vash1986]

Avevate ragione, ho spuntato le opzioni di ottimizzazione e ora il nuovo eseguibile C arriva a fare il tutto in 7s, ovvero con la stessa velocità del C#.

redcloud per caso hai settato qualche opzione di ottimizzazione per java?

[redcloud]

Originariamente inviato da Vash1986

Avevate ragione, ho spuntato le opzioni di ottimizzazione e ora il nuovo eseguibile C arriva a fare il tutto in 7s, ovvero con la stessa velocità del C#.

redcloud per caso hai settato qualche opzione di ottimizzazione per java?

No, Java è talmente pulito che fa tutto da se

[Vash1986]

Originariamente inviato da redcloud

No, Java è talmente pulito che fa tutto da se

Allora o la virtual machine di windows fa veramente pena oppure il tuo Sempron con Debian dà legnate al mio A64 con Winzoz XP

[BountyKiller]

se hai usato il visual studio hai compilato in release???

anch'io ho fatto qualche test velocistico ma sull'assmebly......ho scoperto con mi grande sorpresa che un'operazione di increment su un registro è il 10% più lentachei non caricare 1 in un registro e poi sommarlo all'accumulatore......

[Vash1986]

Stavolta ho fatto un programma un po' più serio, e compilando sia in C che in C# con le dovute ottimizzazioni.

Calcolo 500 volte pi greco. Ogni singolo calcolo esegue 2 milioni di somme/sottrazioni secondo la formula di Leibniz.

pi/4 = 1/1 - 1/3 + 1/5 - 1/7 + 1/9 ...

C - 1,5s

double calcPiQuarti()
{
    double pi = 0;
    int i;
    char sign = 1; // 1 = plus, 0 = minus

    for ( i = 1; i < 2000000; i += 2 )
    {
        if ( sign )
        {
            pi += ( 1.0 / (double)i );
            sign = 0;
        }
        else
        {
            pi -= ( 1.0 / (double)i );
            sign = 1;
        }
    }

    return pi;
}

int main()
{
 double prova; int i,b;
 printf( "Il valore di pi greco e': %f\n", calcPiQuarti()*4 ); // Verifica esattezza: OK! 3.141592

 for ( i = 0; i < 500; i++ )
      b = calcPiQuarti();

 system("pause"); // non funziona su linux, su windows aspetta la pressione di un tasto con "Premere un tasto per continuare..."
 return 0;
}

C# - 6s

using System;

namespace prova
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			int i; double j;
			Console.WriteLine("Hello World!");
			
			for ( i = 0; i < 500; i++ )
				j = calcPiQuarti();
			
			Console.WriteLine("Ho finito");
		}
		
		static double calcPiQuarti()
		{
    		double pi = 0;
    		int i;
    		bool sign = true;

    		for ( i = 1; i < 2000000; i += 2 )
    		{
        		if ( sign )
        		{
            		pi += ( 1.0 / (double)i );
            		sign = false;
        		}
        		else
        		{
            		pi -= ( 1.0 / (double)i );
            		sign = true;
        		}
    		}

    	return pi;
		}
	}
}

Java - 6s

public class Prova 
{
	public static void main(String[] args)
	{
		System.out.println( "Il valore di pi greco è:" + calcPiQuarti()*4 );
		
		double a;
		
		for ( int i = 0; i < 500; i++ )
			a = calcPiQuarti();
		
		System.out.println( "Finito!" );
	}
	
	static double calcPiQuarti()
	{
	    double pi = 0;
	    int i;
	    char sign = 1; // 1 = plus, 0 = minus

	    for ( i = 1; i < 2000000; i += 2 )
	    {
	        if ( sign == 1 )
	        {
	            pi += ( 1.0 / (double)i );
	            sign = 0;
	        }
	        else
	        {
	            pi -= ( 1.0 / (double)i );
	            sign = 1;
	        }
	    }

	    return pi;
	}
}

A quanto pare il C è vincitore

[trallallero]

Originariamente inviato da Vash1986

...
A quanto pare il C è vincitore

avevi dubbi ?

[Marinelli]

Utilizzato l'ultimo programma di Vash, in C:

- compilato con Dev-C++ ==> 21s
- compilato con Intel C++ compiler ==> non fa neppure a tempo a comparire la finestra che ha già finito

In Java: circa 17,5s

Ciao

P.S. Il processore è un PIII 1000E, su Asus P3b-f

[sottovento]

Originariamente inviato da Vash1986

...
A quanto pare il C è vincitore

Beh, occorre fare un minimo di attenzione. In questo caso le cose sono semplici, ma non e' sempre cosi'.
C non fa alcun controllo sui dati, non solleva eccezioni nei casi singolari e tutto il resto.
Inoltre: hai compilato con le opzioni di ottimizzazione del compilatore?
Come suggerito prima, non ci sono tantissimi modi per tradurre in macchina questo codice, puoi controllare l'assembler generato, e a questo punto e' facile capire il motivo di una simile differenza.

High Flying
Sottovento

[ilsensine]

Originariamente inviato da VICIUS

Mentre gia con -O1 C spazza via Java e C#

$ gcc -O1 test.c -o test
$ time ./test

real    0m0.005s
user    0m0.000s
sys     0m0.000s

Grazie, dai una occhiata al disassemblato
Hai appena misurato il tempo di startup di una applicazione sotto linux

[sottovento]

Originariamente inviato da ilsensine

Grazie, dai una occhiata al disassemblato
Hai appena misurato il tempo di startup di una applicazione sotto linux

Inutile guardare il disassemblato, direi

[cionci]

Originariamente inviato da trallallero

scherzi a parte, non puó essere che magari il java o il C# hanno un compilatore "intelligente" che vede che ci sono migliaia di istruzioni identiche e semplicemente ... non le esegue ?

Sicuramente...ma quella è una particolarità del ciclo che è stato usato... In generale il loop unrolling può essere fatto con qualsiasi ciclo di una lunghezza predeterminata...

[Vash1986]

Originariamente inviato da sottovento

Beh, occorre fare un minimo di attenzione. In questo caso le cose sono semplici, ma non e' sempre cosi'.
C non fa alcun controllo sui dati, non solleva eccezioni nei casi singolari e tutto il resto.

Inoltre: hai compilato con le opzioni di ottimizzazione del compilatore?

Lo so che il C non esegue alcun controllo, infatti è per questo che è più veloce.
Certo, ho compilato con le ottimizzazioni sia di C# che C.

Ma a voi risulta che applicazioni C++ siano meno performanti di applicazioni C? Altrimenti non mi spiegherei perchè quasi tutto su linux è fatto in C.

[The3DProgrammer]

beh in linea teorica l'uso massiccio di classi polimorfiche potrebbe rallentare l'esecuzione, causa meccanismo delle vtables. In pratica non credo che il rallentamento sia così netto (devo convertire l'engine raytracing che sto scrivendo in C, ti saprò dire in futuro )

ciau