Newsgroup: it.comp.lang.visual-basic
Titolo: [?] codice più efficiente

Il mio manuale (VB6 - F. Balena) afferma che tra
x ^ 3
e
x * x * x
quest'ultima soluzione č circa 20 volte piů veloce!!!
Poichč sono alle prese con un progetto che
di calcoli deve farne veramente tanti, mi chiedevo
se ci siano delle particolari regole da seguire per
rendere il codice piů efficiente.
Grazie.

 rendere il codice più efficiente.
Scriveva Knuth che meno del 4% di un programma richiede generalmente più
della metà del suo tempo di esecuzione.
Tutto sta nel trovare ed ottimizzare quel 4%.
Quindi scrivi il tuo programma seguendo le regole che ti ha suggerito
Roal (che sono valide sempre), controlla se le prestazioni sono
accettabili, se non lo sono cerca di stabilire quali sono le parti
critiche e dedicati solo ad esse. Controlla se gli algoritmi utilizzati
sono i più adatti, se non è possibile evitare di eseguire alcuni calcoli
(spesso se ne riescono ad eliminare parecchi), e se non ottieni
risultati soddisfacenti non c'è altra possibilità che fare eseguire i
calcoli ad una
dll scritta in un altro linguaggio più efficiente.
Ciao.

 writes:
s> Il mio manuale (VB6 - F. Balena) afferma che tra
s> x ^ 3
s> e
s> x * x * x
s> quest'ultima soluzione č circa 20 volte piů veloce!!!
La prima  viene tradotta in  una chiamata a  funzione (!) che  usa gli
esponenziali (si va sull'ordine delle  decine di cicli macchina se non
ricordo  male),   se  non  ricordo  male,  la   seconda  utilizza  due
moltiplicazioni FP che sul pentium usano 1 ciclo macchina.
s> Poichč sono alle prese con un progetto che
s> di calcoli deve farne veramente tanti, mi chiedevo
s> se ci siano delle particolari regole da seguire per
s> rendere il codice piů efficiente.
Oltre al codice di Roal ed  al suggerimento di H.P.L. (che richiede un
po' di profiling del programma, non  so se c'e` un profiler per il VB)
c'e`  il consiglio  di cercare  di non  fare mai  due volte  lo stesso
calcolo,  cerca per  quanto  possibile di  usare variabili  dichiarate
nello stesso posto,  cosi` si spera che VB le  metta vicine in memoria
(questo  aumenta   la  probabilita`   che  la  variabile   rimanga  in
cache). _Forse_ a  questo giova usare gli array  con indici fissi, che
forse l'ottimizzatore del VB non si comporta da scemo (e fa "decadere"
l'accesso ad un elemento dell'array  ad una semplice variabile). Il VB
per questo non e` molto  ben carrozzato. Andrebbero meglio C o FORTRAN
(meglio il primo),  magari una DLL in  C che fa i calcoli  ed un front
end VB.
-- 
Gian  | main(){printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);}
Uberto|                        David Korn, 1987 ioccc best one liner 
Lauri |-------------------------------------------------------------------
(aka saint) >>Vedere X-Nospam nell'header - See X-Nospam field in Header<<

osti, questa non la sapevo........
quindi esiste sia la funzione Mid che Mid$ ? E che se lavoro sulle stringhe
è meglio usare la seconda?
Bella Roal, questa mi giunge nuova.......
la prossima volta premerò davvero F1, ma questa cosa sulle funzioni di base
di VB non pensavo esistesse!!!!
good coding davvero anche a te!!!!
--
Damiani Liborio Igor
idam...@hotmail.com
 - 
igor.d...@light.it
http://www.igordamiani.it
ICQ : 11847262

 (s="") ma (Len(s)=0)
e se e' un txtbox o simili,
    len(trim(text1))=0

Grazie a tutti!

 writes:
s> Il mio manuale (VB6 - F. Balena) afferma che tra
s> x ^ 3
s> e
s> x * x * x
s> quest'ultima soluzione č circa 20 volte piů veloce!!!
s> Poichč sono alle prese con un progetto che
s> di calcoli deve farne veramente tanti, mi chiedevo
s> se ci siano delle particolari regole da seguire per
s> rendere il codice piů efficiente.
Un'altra cosetta. Se hai un ciclo che viene ripetuto molte volte
puo` essere utile, invece di fare 
for i = 1 to moltissimo
   elaborazione
next i
fare
for i = 1 to moltissimo / 8 ' o altro valore
   elaborazione
   elaborazione
   elaborazione
   elaborazione
   elaborazione
   elaborazione
   elaborazione
   elaborazione
next i
(loop unrolling - diminuisce il numero di test e salti).
Dato che raramente hai un  ciclo che viene eseguito un multiplo esatto
del valore X  che hai scelto, puoi usare questo  orrore (che e` tratto
da un pezzo  di codice che in C  e` una meraviglia - non  c'e` un goto
esplicito a pagarlo):
dim n as long
dim count as long
n = (count + 7) / 8
select case (count % 8)
    case 0
        goto start:
    case 1
        goto l1
    case 2
        goto l2
    case 3
        goto l3
    case 4
        goto l4
    case 5
        goto l5
    case 6
        goto l6
    case 7
        goto l7
end select
start:
    elaborazione
l7:
    elaborazione
l6:
    elaborazione
l5:
    elaborazione
l4:
    elaborazione
l3:
    elaborazione
l2:
    elaborazione
l1:
    elaborazione
n = n - 1
if n > 0 then goto start:
elaborazione NON e` una chiamata a sub, se no tiri il freno a mano.
Il codice qui sopra e` orrido  e per essere manutenibile ha bisogno di
una bella documentazione, ma ti permette di fare il loop unrolling con
un numero a piacere di interazioni.
Ah, ecco  l'originale C, scritto  da Tom Duff  (da cui il  nome Duff's
Device):
        register n = (count + 7) / 8;      /* count > 0 assumed */
 
        switch (count % 8)
        {
        case 0:        do {  *to = *from++;
        case 7:              *to = *from++;
        case 6:              *to = *from++;
        case 5:              *to = *from++;
        case 4:              *to = *from++;
        case 3:              *to = *from++;
        case 2:              *to = *from++;
        case 1:              *to = *from++;
                           } while (--n > 0);
        }
(anche se lui stava sparando dati su una porta, lo statement
        *to = *from++;
 puo` essere sostituito da qualsiasi elaborazione...


 linguaggi (C/C++/Delphi/...).
Infatti.
Ciao.

 ...preparateVI a 
VB.NET
, e dimenticatevi le property di default.
Dopo che ci hanno detto per anni di usarle perché era più veloce ed
efficiente... :-( Bah.
Btye, G.