Newsgroup: it.comp.lang.c++
Titolo: Aumento di velocità

Salve,
sto cercando di velocizzare alcune funzioni che scrissi qualche tempo.
Credo che le due seguenti funzioni siano gia' abbastanza veloci anche
se credo che esista un modo per renderle ancora di piu'.
C'č qualcuno che sa' darmi qualche suggerimento?
Programmo sotto dos con il DJGPP.
Sicuramente riuscirei ad avere ottimi  risultati utilizzando l'inline
asembly, ma non lo conosco :(
/*********************
 * Pulisce il buffer *
 *********************/
void ClearBuffer( unsigned char *buff )
{
 memset( buff, 0, 64000 );
}
/**********************************************************
 * Copia il contenuto del buffer nella memoria della VGA  *
 **********************************************************/
void ShowBuffer( unsigned char *buff )
{
   memcpy( (unsigned char*)VGA, (unsigned char*)buff, 64000 );
}
Grazie!

Se il tuo programma è in C++ allora penso che potresti dichiarare le tue
funzioni come inline.
In caso contrario potresti usare la #define. Cmq non credo che cambi
qualcosa perché al massimo elimini qualche overhead di chiamata, ma la
velocità non dovrebbe variare di molto.
La vera soluzione è l'assembly, ma putroppo non rientra ancora in modo
adeguato nelle mie conoscenze e sicuramente ti darei consigli errati.
Ciao.
-- 
La classifica dei prodotti MS:
C#, la migliore barzelletta di Bill Gates.
Visual C++, il meno standard dei compilatori C++.
J++, la copiatura più riuscita.
Windows, il più instabile.
Visual Basic, un esempio di prodotto decente della MS - forse l'unico -.
OutlookExpress, scandali su scandali.
La classifica degli "amici" coglioni:
Stefano Zanchi, il miglior lamer del mondo.
 

adeguato nelle mie conoscenze e sicuramente ti darei consigli errati.
Magari prima si potrebbe provare con un semplice loop che copia 4
byte alla volta....
Questa semplice implementazione si e` rivelata enormemente piu` veloce
delle implementazioni di memcpy e memset di VC++ (che utilizza implementazioni
piu` corte, ma molto lente).
Nel caso ad esempio del borland invece si perde qualcosa, perche`
esse non solo sono implementate secondo lo schema degli assegnamenti di 4
byte alla volta, ma il loop e` srotolato e impostato in modo da ridurre al 
massimo
i salti.
Paolo
--
Paolo Marotta
Duck Communication Entertainment s.r.l.
Largo Arenula, 11 - Roma
http://www.duckce.com
p.ma...@duckce.com
-- 
Posted from 
HA-server-a.cs.interbusiness.it
 [151.99.250.31] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG


stai cercando funzioni + veloci di memset() e memcpy()? Dipende dal
compilatore, quello che usi tu non lo conosco, ma x esempio non sono
mai riuscito a fare delle funzioni simili che andassero + veloci di
quelle proprie del Borland C++ 5.5 o del Visual C++ 6, al massimo
uguali (e utilizzando l'assembly). Mi sa che ti dovrai accontentare,
cmq prova a vedere nel codice compilato in assembly (molti compilatori
hanno questa opzione) quale codice viene sostituito ad una chiamata a
memcpy() o a memset().

 byte alla volta....
mi faresti un piccolo esempio, x piacere?

Esempio di copia a 4 byte alla volta (ed e` molto dipendente dalla 
piattaforma):
void MemCpy(void* Dest, void* Src, unsigned int BufferSize) {
   int* SrcBuff = reinterpret_cast<int*>(Src);
   int* DestBuff = reinterpret_cast<int*>(Dest);
   unsigned int End = BufferSize/sizeof(int);
   for(unsigned int i=0; i<End; ++i) DestBuff[i] = SrcBuff[i];
   ...
}
Il codice non e` stato testato e cmq manca la parte che copia eventuali 
residui...
paolo


Grazie a tutti per i suggerimenti, ora cerchero' di trovare una
soluzione!
Grazie ancora!


su Pentium II il tuo codice ha la stessa velocità del memcpy fornito
dal compilatore, sia nel caso del Borland C++ 5.5 che del Visual C++
6.0. D'altro canto, entrambi utilizzano la forma REP MOVSD per copiare
i dati, che è la forma più veloce possibile su questo tipo di
processore (può essere pareggiata forse, ma non superata). Dove
precisamente il tuo codice ha ottenuto risultati migliori?
ps. non è x fare polemica, mi interessa veramente saperlo!

 >su Pentium II il tuo codice ha la stessa velocità del memcpy fornito
 >dal compilatore, sia nel caso del Borland C++ 5.5 che del Visual C++
 >6.0. D'altro canto, entrambi utilizzano la forma REP MOVSD per copiare
 >i dati, che è la forma più veloce possibile
La discussione fu condotta tempo fa su una ML, ricordo che io feci la prova
su Borland C++ 5.02 (Pentium Pro con NT 4.0) e che esaminai bene la routine 
borland...
era un loop molto ottimizzato.
La prova su VC++ fu fatta da un altra persona che so essere molto capace
(lavora da anni su applicazioni embedded).
Sono cmq ritornato a fare prove per conto mio e noto che effettivamente le
cose sono cambiate al punto che quel loop rende decisamente meno
di memcpy di VC++.
Paolo
