Newsgroup: it.comp.lang.visual-basic
Titolo: [NET] [OT] Prestazioni a confronto.

Ciao a tutti e scusate l'OT.
Ho da poco ripreso a studiare la piattaforma .NET (sto leggendo il
libro(ne) di Francesco Balena e mi sto divertendo a effetuare qualche
piccolo test (non molto significativo fino ad ora) sulle prestazioni.
Ho fatto un confronto fra 
VB.NET
, C# e C.
Ho costruito tre piccole applicazioni console in cui viene effettuata
questa operazione:
myOp += n1 * i + n2 * 0.1255;
dove myOp, n1, n2 sono double, i è un intero (il contatore di un ciclo
for)
questa espressione viene ciclata per 500.000.000 (500 milioni) di volte
e sorpesa ...
la procedura in C impiega 7360 millisecondi
in C# impiega 7250 e in 
VB.NET
 7130
(questi sono i tempi minimi su una serie di 6 prove)
non so quanto possa essere indicativo cmq non mi sembra male, farò delle
prove con le stringhe poi, se può interessare, posso postare i
risultati.
La prova è stata effettuata su un Athlon Xp 1800+ con 512 Mb Ram
Stefano
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 (questi sono i tempi minimi su una serie di 6 prove)
E' normale che tu abbia ottenuto valori simili poichč su operazioni "base",
cioč non usando funzioni proprietarie del linguaggio, il codice prodotto dai
vari linguaggi .NET č identico.
Ciao
--
Math Parser, VB.Framework : 
http://www.neodatatype.net
Sito Comune               : 
http://www.it-lang-vb.net

 
Ciao


 all'aumentare del numero dei cicli.
[SNIP]
Io ho ottenuto tempi del tutto uguali (771 ms con punte di 761 dopo qualche
esecuzione) con entrambi...
    Sub Main()
        Dim MyOp As Double = 0, n1 As Double = 0, n2 As Double = 0
        Dim i, t As Int32
        Console.WriteLine("
VB.NET
 - Press a key to start")
        Console.ReadLine()
        Console.WriteLine("Wait...")
        t = Environment.TickCount
        For i = 1 To 500000000
            MyOp += n1 * i + n2 * 0.1255
        Next
        Console.WriteLine("Done: {0} ms", Environment.TickCount - t)
        Console.ReadLine()
    End Sub
    [STAThread]
    static void Main(string[] args)
    {
        double MyOp = 0, n1 = 0, n2 = 0;
        Int32 i, t;
        Console.WriteLine("C# - Press a key to start");
        Console.ReadLine();
        Console.WriteLine("Wait...");
        t = Environment.TickCount;
        for (i=1; i<=500000000; i++)
            MyOp += n1 * i + n2 * 0.1255;
        Console.WriteLine("Done: {0} ms", Environment.TickCount - t);
        Console.ReadLine();
    }
andando a verificare il codice IL generato, e' risultato praticamente
identico
Ho provato con VS 2003 su un Athlon XP 1500+, compilando in configurazione
Release, ottimizzazioni attivate e controllo di overflow disattivato
Ciao
-- 
Luca Dormio - 
luca....@tin.it
________________________________
"Marty, non stai ragionando in maniera quadridimensionale"
Dr. Emmett L. Brown

 all'aumentare del numero dei cicli.
Per affermare una cosa del genere dovresti fornire il codice utilizzato nei
due linguaggi.
Se usi istruzioni equivalenti il codice compilato prodotto è identico.
Anzi, è VB che spesso utilizza un substrato aggiuntivo
(Microsoft.VisualBasic.Compatibility) che rallenta non poco le elaborazioni.
Questo se usi funzioni di compatibilità tipo Trim() Left()...
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 
Ciao,
di seguito posto il codice in 
VB.NET
, C# e C
Sicuramente non sto tenendo conto di qualche cosa, per cui mi da tempi
differenti.
Segnalazioni in merito sono benvenute.
Una nota per il libro di Balena, sono ancora a pag 120 quindi č forse
prematuro ma, i contenuti mi sembrano buoni,
perņ ho trovato molti errori di battitura e per un libro da 75euro
(della Mondadori Informatica) mi sembra
un po' troppo "poco curato".
Ciao
Stefano
/******************* Codice 
VB.NET
Module Module1
    Sub Main()
        Dim x As Double, res As Double
        Dim startTime As Date
        x = 12.5
        startTime = Now
        res = Add(x, 46.5)
        System.Console.Write("Il risultato č : ")
        System.Console.WriteLine(res)
        System.Console.WriteLine("Tempo impiegato: {0} secondi.",
Now.Subtract(startTime))
    End Sub
    Function Add(ByVal n1 As Double, ByVal n2 As Double)
        Dim i As Integer
        Dim MyD As Double = 0.0
        For i = 0 To 500000000
            MyD += n1 * i + n2 * 0.1225
        Next i
        Return MyD
    End Function
End Module
/******************* END Codice 
VB.NET
/******************* Codice C#
using System;
namespace ConsoleApplication2
{
	class Class1
	{
		[STAThread]
		static void Main(string[] args)
		{
			double x, res;
			System.DateTime startTime;
 
			x = 12.5;
			startTime = DateTime.Now;
			res = Add(x, 46.5);
			System.Console.Write ("Il risultato č : ");
			System.Console.WriteLine (res);
			System.Console.WriteLine("Tempo impiegato: {0} secondi.",
DateTime.Now.Subtract(startTime));
		}
		static double Add (double n1, double n2)
		{
			int i;
			double MyD = 0.0;
			for (i=0; i<=500000000; i++)
			{
				MyD += n1 * i + n2 * 0.1225;
			}
 
			return MyD;
		}
	}
}
/******************* END Codice C#
/******************* Codice C
#include "stdafx.h"
#include "windows.h"
// Prototipi ******************
double Add (double n1, double n2);
// End Prtototipi *************
void main(void)
{
	double res, x;
	unsigned int tbefore, tafter, totalms; 
	tbefore = GetTickCount(); 
	x = 12.5;
	res = Add(x, 46.5);
	tafter = GetTickCount(); 
	totalms = tafter - tbefore; 
 
	printf ("\n\nIl risultato e' : %f\n", res);
	printf ("Tempo impiegato : %i millisecondi.\n\n", totalms);
 
}
double Add (double n1, double n2)
{
	int i;
	double MyD = 0.0;
	for (i=0; i<=500000000; i++)
	{
		MyD += n1 * i + n2 * 0.1225;
	}
	return MyD;
}
/******************* END Codice C


 Questo se usi funzioni di compatibilità tipo Trim() Left()...
Tutto vero , pero' giusto per pignoleria:
la namespace Microsoft.VisualBasic.Compatibility non viene inclusa
automaticamente nei progetti 
VB.NET
, ma solo in quelli importati da progetti
VB6; e' quella che fa il lavoro piu' sporco, cioe' principalmente fornire le
classi per simulare i vecchi array di controlli preservando il codice
esistente, piu' altre cose tipo le funzioni LoadResXXX, quelle relative alle
conversioni in Twips ecc..
La namespace a cui ti riferisci e' invece Microsoft.VisualBasic, con tutti i
wrapper alle vecchie funzioni native, le costanti ecc...


 void main(void)
int main(void)
scrivere void main, per quanto accettato da molti compilatori è un
errore.
Valgono anche per il C gli stessi tre punti che riguardano il ciclo for
e l'inizializzazione delle variabili, considerando però che la 
possibilità di dichiarare le variabili all'interno del codice (e non 
all'inizio) è stata data solo dal recente standard C99 (del 1999), per 
cui VC6 ed i compilatori antecedenti lo standard del '99 non 
l'accettano...
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.


Ciao,
grazie per le segnalazioni, in effetti molte cose le ho scritte in fretta
senza pensarci troppo, come ad esempio il nome della funzione oppure
l'inizializzazione delle variabili, altre come il ++i e i++ nel ciclo for
non ne ero proprio a conoscenza.
Chiedo venia.
Il conteggio del tempo l'ho effettuato in quel modo perchč ho visto un
esempio sul libro di Balena
(cfr. pag 120)
Mi sapresti dire le differenze tra i due metodi?
Le 500.000.001 iterazioni sono solo un refuso ... perň cosě mi stai
castigando un po' troppo non credi? ;-)
grazie comunque per le precisazioni.
Ciao
Stefano

 dichiararlo al suo interno e non all'esterno for(int i=0;...)
Proprio oggi mi č successa una cosa strana con queste cose:
Io facevo due for consecutivi, es:
for (int i = 0; i < 100 ; i++) // ok, ++i, era per riportare esattamente :)
    ...
for (int i = 0; i < 100 ; i++)
    ...
Ebbene, quando mi entrava nel secondo for i non veniva reinizializzata, anzi
a dire il vero non veniva nemmeno piů incrementata il che mandava il tutto a
ramengo.
Non ho ben capito (non ho fatto ulteriori prove) se č un porblema del
compilatore, se č cosě "by design" o se ho trovato un buco per qualche
strana situazione.
Comunque ho risolto cosě:
int i
for (i = 0; i < 100 ; i++) // ok, ++i, era per riportare esattamente :)
    ...
for (i = 0; i < 100 ; i++)
    ...
Che ne pensi?


 Mi sapresti dire le differenze tra i due metodi?
[SNIP]
Semplicemente che il primo usa variabili e calcoli sul tipo piu' DateTime,
piu' "pesante", il secondo e' una semplice sottrazione di interi; per fare
dei benchmark di questo tipo e' piu' comodo perche' e' altrettanto semplice
da leggere e influenza meno il test stesso...


 castigando un po' troppo non credi? ;-)
Il mio non era un intento "castigatorio", anche perché in fondo solo
il void main era un vero e proprio errore...


 Che ne pensi?
for (int i=0; i<100; ++i)
...
for (int j=0; j<100; ++j)


 il void main era un vero e proprio errore...
Naturalmente scherzavo.
In effetti sono andato a rivedere un po' di ANSI C ed in effetti secondo
le specifiche la main deve restituire int,
Il libro "C Ansi C e C++" di Schildt nonostante specifichi che le
direttive Ansi impongono di restituire un int, fa restituire a tutte le
funzioni main degli esempi void.
Il compilatore VC++6 della microsoft, se dichiaro:
int main (void)
{
...
}
oppure 
main (void)
{
...
}
Mi da un warning:
 : warning C4508: 'main' : function should return a value; 'void' return
type assumed
Non voglio certo giustificarmi ma a volte le cose sono quanto meno
nebulose.
Comunque grazie per le spiegazioni e le precisazioni.
Ciao
Stefano


type assumed
Mettici un return 0 ;-)
-- 
ciao, hal

 Mettici un return 0 ;-)
va bene anche enter ?


wrote:

Si', se va a capo si legge meglio ;-)
-- 
ciao, hal

 il void main era un vero e proprio errore...
Perň l'SDK di C# riporta:
---
Il metodo Main č il punto di ingresso del programma, ovvero il punto in cui
il controllo del programma inizia e termina. Č dichiarato in una classe o in
una struct, deve essere di tipo static e puň avere un tipo restituito void o
int.
---
Quindi credo che anche se č buona norma far tornare l'errorlevel da un'app
con .NET non pare piů essere necessario (probabilmente lo fa in automatico
il compilatore).


il compilatore).
Da alcune prove veloci sembra che il valore di ritorno sia impostato
dalla mscoree.dll e lo metta sempre a zero, sia che si dichiari void o
int il tipo di ritorno della Main.
Se invece usi il compilatore c++ con le managed estensions il valore
di ritorno e' quello che imposti tu.
Ho provato cosi':
<C#>
using System;
namespace Cs3
{
	class Class1
	{
		[STAThread]
		static int Main(string[] args)
		{
			Console.WriteLine("Hello");
			return 1;
		}
	}
}
</C#>
L'esito e' stato:
The program '[1112] Cs3.exe' has exited with code 0 (0x0).
Perche'?
Invece cosi':
<MC++>
#using <mscorlib.dll>
#include <tchar.h>
using namespace System;
int _tmain(void)
{
    Console::WriteLine(S"Hello World");
    return 1;
}
</MC++>
L'esito e' stato:
The thread 'Win32 Thread' (0x20c) has exited with code 1 (0x1).
The program '[508] Test0001.exe' has exited with code 0 (0x0).
The program '[508] Test0001.exe: Native' has exited with code 1 (0x1).
In pratica sembra che ci siano due valori di ritorno: quello di .NET e
quello nativo, che in questo caso e' stato proprio quello impostato.
-- 
ciao, hal

 nebulose.
Io conosco decentemente il C++, ma molto poco il C.
Sono certissimo che entrambi i linguaggi richiedano che la main 
restituisca un int, ma mentre so che il C++ permette di evitare
il "return 0" alla fine della main, non sono certo che anche il C lo 
permetta...
In ogni caso il VC++6 è un compilatore vecchio e *poco* conforme allo 
standard C++.


 Perň l'SDK di C# riporta:
[cut]
Sě, sě. Il mio commento era riferito al solo C (ed al C++).


 molto grossi...
Arghh!! lo dico io!!!
Mannaggia, e io che avevo intenzione di prendermi il libro di Schildt
sul C#!
Nonostante gli errori il libro che ho io mi è piaciuto abbastanza.
Che fare?? Meglio lo Schildt o Il libro della Microsoft Press 
"Programmare Microsoft Visual C# .NET" di "Mickey Williams"
Oppure??
Considera che ora sto studiando dal super-tomo di Balena 
VB.NET
Qualsiasi consiglio in merito è stra-ben-accetto.
Grazie


 "Programmare Microsoft Visual C# .NET" di "Mickey Williams"
Non conosco libri sul C#, ma per i motivi sopra esposti starei ben alla
larga dai libri dello Schildt.



Terrň ben presente.
Ciao
Stefano