Newsgroup: it.comp.lang.visual-basic
Titolo: semi-OT : benchmark DLL vs. codice VB ottimizzato (sintesi sonora)

moderatamente OT :
ho fatto un confronto tra codice VB ottimizzatissimo (sia mano 
che con opzioni del compilatore) e codice Cpp (la complessità 
dell'algoritmo è bassa nel senso che ha essenzialmente solo 
iteratività annidata su più livelli, niente stringhe, memory 
managment o simili, solo calcoli puri ... se interessa posso 
postare le routine oggetto del confronto, anzi, siccome quella 
Cpp è brevissima la accludo in calce direttamente)
statistica :
sintesi di 6'382'080 campioni (nota, ciascun singolo passaggio è 
eseguito con variabili ed array ad aritmetica intera, al massimo 
long, senza nessun cast da/a floating point, sia nel codice puro 
VB sia nella DLL Cpp, e in entrambi i casi la funzione SIN è 
precalcolata, memorizzata (con zoom) in una matrice permanente, 
e nessuna funzione in virgola mobile viene invocata 
implicitamente nei calcoli di sintesi dei campioni)
I valori di confronto sono stati misurati con l'API 
"GetTickCount" su un file wave generato di circa 1 MB, 
risultante però da una cinquantina di note, alcune sovrapposte e 
quindi ricampionate più volte sulla stessa regione di wave, per 
un totale di quasi 6,5 milioni di campioni generati
risultato del benchmark
codice interpretato :
Time_Basic : 5824 ticks (12431 ticks in debug)
Time_Cpp : 1157 ticks (2293 ticks in debug)
compilato con tutte le ottimizzazioni (indici matrici non 
controllati, e ogni altra sicurezza esclusa):
Time_Basic : 1139 ticks
Time_Cpp : 1127 ticks
beh, non so se fare i complimenti al compilatore o farmi i 
complimenti da solo, eh he he, nel senso che avere usato 
un'algebra long purissima ed array precalcolati, in effetti, 
pare abbia pagato discretamente (speravo meglio nel Cpp .... ora 
m''incazzo e comincio a sparare un po' di variabili register, >:(
! !
Ciao
Soviet-Mario
P.S.
mi incuriosisce abbastanza l'appunto che mi era stato mosso da 
qualcuno sul NG, non ricordo il nome ma pareva un buon 
conoscitore del Cpp, riguardo alle assegnazioni multiple nella 
medesima istruzione, che seguito ad usare sino a prova contraria.
Io non ho trovato l'avvertimento del comportamento imprevedibile 
sul Biarne Stroustroup, che è il mio unico libro di Cpp, ma il 
compilatore Borland C++Builder seguita a compilare liscio senza 
nessun warning, e nel campionamento alla prova dei fatti 
l'algoritmo produce i medesimi risultati di quello basic privo 
delle abbreviazioni .... qualcuno sa per esperienza se ci sono 
casi specifici ove tale costrutto sia inaffidabile ? Ed è 
possibile che con tutti i warning off il compilatore non 
eccepisca niente ? Sono perplesso.
codice nella DLL (porzione dell'engine di sintesi campioni sonori)
//----------------------------------------------------------------
extern "C" __export __stdcall void PlayArmonic (signed long * 
Wave32, signed long * GloSinLong, signed long IniSample, signed 
long FinSample, signed long FreqArm, signed long VolArm, signed 
long SfasamArm, signed long ConGloNumCampioniAlSecondo)
{
// ConGloNumCampioniAlSecondo coincide con
// le dimensioni dell'array SinLong[]
// dichiarato public nel modulo basic
signed long * StartWave = Wave32 + IniSample;
signed long * EndWave = Wave32 + FinSample;
signed long AngularSample = SfasamArm - FreqArm;
while (StartWave <= EndWave)
	(*(StartWave ++)) += (VolArm * GloSinLong [((AngularSample += 
FreqArm) %= ConGloNumCampioniAlSecondo)]);
return;
}
//----------------------------------------------------------------

 eccepisca niente ? Sono perplesso.
Con tutti i warning on, spero ;-)
Il libro da te citato è ottimo (anche se non di facilissima lettura) ma
come ogni libro che cerchi di spiegare un argomento molto complesso non
può essere anche completo. L'unico riferimento veramente completo è lo
standard.
Comunque:
http://www.research.att.com/~bs/bs_faq2.html#evaluation-order
<cite>
Basically, in C and C++, if you read a variable twice in an expression
where you also write it, the result is undefined. Don't do that.
</cite>
Come vedi non serve neppure scriverla due volte (cosa comunque vietata
dallo standard) ma basta addirittura scriverla una volta e leggerla due.
A questo punto vorrei farti notare una cosa.
<code>
aidee%cat pippo.cc
#include <iostream>
using namespace std;
int main()
{
    int a[10];
    cout << a[125] << endl;
    a[125] = 1234;
    cout << a[125] << endl;
}
aidee% g++ -Wall -ansi -pedantic-errors -o pippo pippo.cc
aidee% ./pippo 
1768387173
1234
</code>
Come vedi questo codice compila perfettamente, senza warning di sorta
e *FUNZIONA* (sulla mia macchina con il mio compilatore).
Se dovessi considerare corretto ciò che compila e che funziona ne
dovrei dedurre che il C++ permette di leggere ed assegnare il 125
elemento di un array di 10 elementi. Cosa palesemente falsa.
Però fare affidamento sul fatto che del codice funzioni pur essendo
sbagliato è sinceramente una leggerezza veramente non da poco.
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

It's undefined. Basically, in C and C++, if you read a variable 
twice in an expression where you also write it, the result is 
undefined. Don't do that. Another example is:
	v[i] = i++;
Related example:
	f(v[i],i++);
Here, the result is undefined because the order of evaluation of 
function arguments are undefined.
Having the order of evaluation undefined is claimed to yield 
better performing code. Compilers could warn about such 
examples, which are typically subtle bugs (or potential subtle 
bugs).
CUT
io invece ho scritto una cosa tipo
(*(A ++)) += (B * C [((D += E) %= F)]);
c'è qualche differenza che non riesco a spiegarmi però 
dall'esempio citato (e che mi risultava infatti, come pratica 
inaffidabile) e quello che ho scritto.
Forse è per il fatto che il += equivale al ++ prefisso, che 
quindi dovrebbe essere computato PRIMA di usare la variabile
il ++ postfisso, che invece indica di usarla DOPO, fa si che il 
compilatore non sappia se incrementarla dopo l'assegnamento 
(nella stessa istruzione) o prima dell'assegnamento ....
Inoltre si tratta di due assegnamenti, con stessa priorità, e 
totalmente parentetizzati .... che ambiguità esiste ?
Mi sfugge qualcosa.
Cmq non è un esempio così ovvio come l'usare una regione di 
memoria che non appartiene ad un array (che il più delle volte 
con la memoria libera bassa dovrebbe dare dei bei page faults), 
mente quel genere di codifica che uso spesso non mi ha ancora 
dato problemi in programmi diversi, e questa è una cosa molto 
strana, o no ?
ciao
CCCP++Mario
P.S. si, il Biarne Stroutroup l'ho trovato un libro difficile, 
in effetti. L'ho studiato a lungo e certi capitoli ancora mi 
sfuggono in parte (tipo l'exception handling ad es., altri 
proprio del tutto e mi sembrano troppo filosofici, i finali)
P.P.S. sei il fondatore del NG ? Da quanti anni esiste ?

 Da quanti anni esiste ?
http://groups.google.com/groups?ie=UTF-8&as_umsgid=5fk31u%241...@serra.unipi.it&as_scoring=d&lr=&num=100&hl=it
