Newsgroup: it.comp.programmare.win32
Titolo: [OT] BC++ Builder vs. MS VC++ (vince Builder ?)

Ragazzi, non so che test abbiate fatto voi o su che benchmark vi
basiate per affermare che VC++ sia piu' veloce di BC++B.
Io, nel mio piccolo, ieri sera, ho fatto la prova a compilare il
programma che allego in fondo al messaggio (che non fa altro che
eseguire 10 prove da 1000 quicksort l'una su un array da 10000
elementi) ed i risultati, espressi in millisecondi, sono i seguenti:
VC++(*)  BC++B(**)
6.32400  5.91400
5.84400  5.48400
5.75700  5.59400
5.84300  5.83900
5.83500  5.60300
6.49800  5.50000
6.33600  5.69000
6.14000  5.44700
6.21500  5.43800
6.14500  5.58000
(*) Microsoft Visual C++ 6.0
(**) Borland C++ Builder 5.0 Enterprise
Come si puo' vedere dai risultati e, a meno di errori da parte mia,
BC++ Builder e' stato piu' veloce (mediamente) del 8% circa.
Il codice di test e' il seguente :
<CODE>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define H 10000
#define NUM 1000
#define PROVE 10
void SelectionSort( int *a, const int high )
{
     int i, j, t ;
     for ( i = 0 ; i <= high - 1 ; i++ )
     {
         for ( j = high ; j >= i+1 ; j-- )
         {
             if ( a[i] > a[j] )
             {
                t = a[i] ;
                a[i] = a[j] ;
                a[j] = t ;
             }
         }
     }
}
void QuickSort( int *a, const int high, int lo, int hi )
{
     int Lo, Hi, Mid, t ;
     Lo = lo ;
     Hi = hi ;
     Mid = a[(Lo+Hi)/2] ;
     do
     {
         while ( a[Lo] < Mid )  Lo++ ;
         while ( a[Hi] > Mid )  Hi-- ;
         if ( Lo <= Hi )
         {
            t = a[Lo] ;
            a[Lo] = a[Hi] ;
            a[Hi] = t ;
            Lo++ ;
            Hi-- ;
         }
     }
     while ( Lo <= Hi ) ;
     if ( Hi > lo )  QuickSort( a, high, lo, Hi ) ;
     if ( Lo < hi )  QuickSort( a, high, Lo, hi ) ;
}
void FixTime( DWORD *pt )
{
     *pt = GetTickCount() ;
}
void RandomizeArray( int *a, const int high )
{
     int i ;
     srand( time( 0 ) ) ;
     for ( i = 0 ; i < high ; i++ )
     {
         a[i] = rand() % high ;
     }
}
int main()
{
    int a[H], i, j ;
    DWORD Time1, Time2 ;
 
    for ( j = 0 ; j < PROVE ; j++ )
    {
        double mediaQSort = 0.0 ;
        for ( i = 0 ; i < NUM ; i++ )
        {
            RandomizeArray( a, H ) ;
            FixTime( &Time1 ) ;
            QuickSort( a, H, 0, H ) ;
            FixTime( &Time2 ) ;
            mediaQSort += (Time2 - Time1) ;
        }
        printf( "Quick Sort     : %10.5lf\n", mediaQSort / NUM ) ;
    }
    getchar() ;
    return 0 ;
}
</CODE>
--
Walkie...@Libero.It (ICQ# 8143647)


Premesso che, come ho già detto in un altro post, credo che le bugie
possano essere misurate con la seguente scala (una menzo-mercalli o una
lie-richter): - bugie a fin di bene
- bugie innocenti
- bugie dette per difendersi
- bugie dette per danneggiare altri
- statistiche
- benchmark
penso che una differenza come quella che tu evidenzi non sia troppo
indicativa e che possa essere influenzata da diversi fattori (soprattutto
su un sistema multi-processo). Per fare un benchmark più oggettivo
(tenendo presente quanto affermato sopra sull'oggettività dei benchmark)
dovresti anche provare a variare i livelli di ottimizzazione del
compilatore e provare i due programmi di test nelle stesse condizioni di
carico del PC (senza ambiente di sviluppo in background, ad esempio),
impostando per i relativi thread la priorità più alta possibile, magari
su PC diversi (le varie generazioni di microprocessori intel e
compatibili richiedono un diverso allineamento delle istruzioni per
sfruttare al massimo la possibilità di eseguire istruzioni in parallelo e
il codice più veloce per un P4 potrebbe non essere così performante su un
P3 o su un AMD). Una volta stabilito che esiste davvero una differenza di
velocità (e considerato quanto questa differenza di velocità pesa
eventualmente in termini di dimensione del codice prodotto) potrebbe
essere interessante analizzare il codice assembler prodotto dai due
compilatori, verificare come vengono tradotte le varie istruzioni e
verificare se delle modifiche apparentemente insignificanti del codice
sorgente generano variazioni di performance nel codice generato (mi pare
che il compilatore ms, ad esempio, compila gli if in un modo che risulta
generalmente penalizzante per i microprocessori di ultima generazione). 
-- 
Valter Minute
min...@inwind.it
 (the reply address of this message is invalid)

generalmente penalizzante per i microprocessori di ultima generazione). 
Mi bastano queste tue righe di risposta per chiedere : ha davvero
senso tirare fuori dei benchmark del genere ?
Ha davvero senso affermare che un compilatore e' piu' veloce di un
altro se tutte le condizioni di test devono essere vagliate con una
cura al millesimo di millimetro ?
In quali condizioni reali, quindi, sia avra' una situazione cosi'
fortemente a favore di un compilatore e non dell'altro ?
Credo proprio che non abbia senso ne' affermare che VC++ e' piu'
veloce di BC++B, ne' il contrario, perche' non credo che nessuno si
sia mai preso la briga di testare i compilatori in un ambiente del
tutto asettico...
--
Walkie...@Libero.It (ICQ# 8143647)


Soprattutto considerando che chi si è preso la briga di farlo non sempre 
era così indipendente...


 (**) Borland C++ Builder 5.0 Enterprise
Non hai messo i service pack.
Mettili. Il VC++ guadagna parecchio. Anche mettendo il processor pack,
inesistente per BC++.
I service pack ed il processor pack sono gratuiti.
Quando l'hai fatto, ti invito a pubblicare i nuovi risultati, ricordandoti
che le versioni performanti di VC++ partono dalla professional.
Attendo i tuoi risultati.
--
Alessandro Monopoli
-------------------------------------
Sito personale: 
http://www.alemonopoli.com
Membro dei Morningrise: 
http://www.morningrisegroup.com
-------------------------------------

ed i risultati, espressi in millisecondi, sono i seguenti:
Non pubblichi il livello di ottimizzazioni adottatto durante la
compilazione, non pubblichi come hai fatto i test di misura (con la
versione di debug magari?), non ti sei preoccupato di minimizzare il
time slice dei context switch alzando la priorita' del thread, usi un
misuratore di tempo pessimo (GetTickCount), e non ti sei dato la pena
a montare gli ultimi service pack.
Per di piu' il test e' pure sballato concettualmente. Usando un
randomizzatore (per di piu' mediocre come quello della libreria
standard) ti poni nella condizione di non ripetibilita' del test.
Un benchmark cosi' non vale il tempo che ho speso per scaricare il
messaggio.
Dai miei benchmark il BC e' piu' che pessimo. E sono fatti con un
minimo di serieta' in piu'. Prendi i miei, e rieseguili sulla tua
macchina se non ti fidi.
-- 
Tieni per te il Papero se vuoi la mia email
Sito Papero -> 
http://utenti.tripod.it/papero
Link al Sito Papero 
http://www.mathtools.net/

 macchina se non ti fidi.
WOW!!
Io ho citato i tuoi risultati per dimostrare quello che anche tu dici!
Ciao!


 wrote in message
3b06f1dd...@news.libero.it...


macchina se non ti fidi.
Certo, certo...
--
Walkie...@Libero.It (ICQ# 8143647)

 Certo, certo...
Tutti i programmi commerciali  sono fatti con Borland C++ Builder.
Certo, certo...
