Newsgroup: it.comp.lang.visual-basic
Titolo: OverHead

Cosa si intende con l'aumento di OverHead nelle chiamate di funzione?
Grazie
Simo

 Cosa si intende con l'aumento di OverHead nelle chiamate di funzione?
Lo "sforzo in più" che il sistema deve fare per eseguire la funzione...
Per essere più chiaro: quando il tuo codice è lineare, ad esempio:
______________
istruzione 1
istruzione 2
istruzione 3
istruzione 4
istruzione 5
istruzione 6
istruzione 7
______________
Il processore si limita ad eseguire le istruzioni nella sequenza in cui le trova.
Se il tuo codice è strutturato in routine separate, invece, così:
______________
-------------
istruzione 1
Chiama SubRoutine A
istruzione 4
Chiama SubRoutine B
istruzione 7
-------------
SubRoutine A:
istruzione 2
istruzione 3
End Sub
SubRoutine B()
istruzione 5
istruzione 6
End Sub
______________
il sistema deve "perdere tempo" per andare alla sub giusta,
eseguirla, e tornare al punto di prima.
Attenzione, però: se il prog è stato strutturato in unità coerenti e logiche,
in moduli, con function  e sub ben parametrizzate e ben commentate, sarà
_molto_  più facile da comprendere e gestire, e soprattutto da modificare
in caso di necessità. Il codice _lineare_ è consigliabile solo ed se hai problemi
di velocità tali da costringerti a "limare" anche l'ultimo millisecondo.
Esempio stupido, una funzione come:
Function Somma(a As Integer, b As Integer) As Integer
    Somma = a + b
End Function
oltre ad essere errata, (perchè non ha controllo di errore su un eventuale
overflow), è solo una perdita di tempo.
Una funzione come:
Function Dec2Bin(ByVal Dec As Long) As String
' Conversione di un numero decimale in binario
    Do While Dec <> 0
        Dec2Bin = Dec Mod 2 & Dec2Bin
        Dec = Dec \ 2
    Loop
End Function
può essere utile, invece... e se ti accorgi che vuoi passare un Double, anziché
un Long, basta cambiare la definizione.
Attenzione: anche questa non ha controlli di errore !
Per tornare all'overhead, prova queste righe:
_________________________
    Dim N As Long
    Dim Inizio As Single
    Dim a As Integer, b As Integer
    Dim c As Integer
    Inizio = Timer
    For N = 0 To 2000000
        c = a + b
    Next N
    Debug.Print Timer - Inizio
    Inizio = Timer
    For N = 0 To 2000000
        c = Somma(a, b) ' inserisci anche la funzione di prima !
    Next N
    Debug.Print Timer - Inizio
_________________________
Se la funzione, come questa, è particolarmente semplice, il sistema
impiegherà più tempo ad eseguire la chiamata che la funzione....
Bye, G.
--
---------------------------------------------
    Le risposte alle tue domande le trovi
    sul Sito Comune di questo NewsGroup:
 
http://www.murialdo.it/it_lang_vb
       ... e nell'help in linea !
---------------------------------------------
Real E-address: 
gaet...@hotmail.com


considera questo esempio:
Sub Test1
Dim i As Long
Dim x As Long
x = i + 1
End Sub
e analogamente:
Sub Test2
Dim i As Long
Dim x As Long
x = Succ(i)
End Sub
Function Succ(a as long) as long
Succ = a + 1
End Function
Test1 e Test2 producono esattamente lo stesso risultato; nel primo caso hai
scritto la somma direttamente nella tua sub, nel secondo hai demandato la somma
alla funzione 'Succ'; in questo caso ottieni un "overhead" cioe' un aumento del
carico di lavoro e quindi un peggioramento delle prestazioni dovuto ai
meccanismi di chiamata della funzione, al passaggio dei parametri ecc...
In questo caso ovviamente la differenza e' assolutamente impercettibile ma se
provi a eseguire la somma, ad esempio, in un ciclo da 1 a 100.000 e a
"cronometrare" con la funzione Timer vedrai che comincia a notarsi un lieve
rallentamento; piu' complichi la tua funzione (come numero e "grandezza" dei
parametri) e peggio e'.
Non farti spaventare comunque, a parte casi particolari tipo lunghi cicli in cui
devi "limare" fino all'ultimo millisecondo non vale la pena farsi problemi
nell'uso delle funzioni, anzi!
Ciao
--
Luca Dormio
l...@sig-la.com
ldo...@tin.it


Per "overhead", relativo alle chiamate di funzione, si intende
l'appesantimento (in termini di dimensione del codice eseguibile e di tempo
di esecuzione) dovuti ai passaggi necessari per chiamare una funzione.
Analizzando la situazione a basso livello (codice macchina e registri del
processore) per chiamare una funzione e' necessario fare una serie di
operazioni piu' o meno lunghe, ad esempio:
- salvare il contenuto di alcuni registri sullo stack
- mettere nello stack i valori (o i puntatori) degli eventuali parametri
necessari alla funzione
- altre operazioni eventuali di setup.
Le stesse (o simili) operazioni devono essere ripetute al contrario
all'uscita dalla funzione.
Chiaramente cio' comporta un appesantimento variabile (e dipendente, tra
l'altro, dal tipo e  numero di parametri della funzione, dalla convenzione
di chiamata utilizzata e altro).
--
Roal Zanazzi
z...@iol.it