Newsgroup: it.comp.lang.c++
Titolo: Funzioni

Quando richiamo una funzione posso avere una seppur piccola perdita di tempo
(dell'ordine di alcuni millisecondi)?
Se scrivo il contenuto della funzione al posto della chiamata di tale
funzione ho un tempo inferiore rispetto a prima oppure è sotanzialmente
uguale?
Ciao :)

 wrote in message
Rryqa.69189$iy5.2...@twister2.libero.it...

Si. La chiamata di una funzione comporta perdita di tempo, poichè il sistema
deve interrompere l'esecuzione del codice, modificare le informazione nei
registri e riprendere l'esecuzione del codice in un altro punto della
memoria. E ovviamente rifare le operazioni inverse all'uscita della
funzione. Per evitare ciò esiste la possibilità di dichiarare una funzione
inline anteponendo la parola chiave inline prima della
dichiarazione/definizione della funzione. Tale operazione è un "consiglio"
al compilatore di sostituire ogni chiamata della funzione in codice in
linea, senza eseguire la chiamata di funzione. E' molto utile per funzioni
molto piccole (ad esempio metodi che si limitano ad accedere ad un dato
membro di una classe o funzioni di una sola riga, nelle quali l'overhead per
il context-switch è troppo elevato rispetto alle effettive istruzioni
richieste). Bisogna evitare le funzioni inline per le funzioni troppo grandi
(in cui non solo i benefici sono limitati se non nulli ma in più si rischia
anche l'esplosione del codice) e nelle funzioni ricorsive anche brevi (per
il fatto che vengono gestite male dai compilatori, sostituite parzialmente o
affatto).
Ciao.

 richieste).
una precisazione: con "context-switch" in genere si intende l'operazione per
cui il processore viene assegnato ad un altro "programma" (che a seconda
dei casi puo` essere un processo, un thread, una syscall del kernel...); in
effetti il context-switch e` un'operazione lenta, perche` deve copiare i
valori di tutti i registri del processore sullo stack, ma non ha nulla a
che vedere con una chiamata a funzione (che nel caso migliore comporta solo
una push in cima allo stack).
Cmq l'argomento qui e` abbastanza OT.
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

 wrote in message
479tn-...@anto.cuni.lan...

Ne sono a conoscenza, sono cose che abbiamo trattato perfino all'Università
(che di solito insegna ben poco ma qualche volta stupisce).
Ho usato quel termine perchè mi sembrava adatto all'occasione per rendere
l'idea e non me ne venivano altri migliori.
Complimenti per la pignoleria, se stai li a puntualizzare tutti i termini
che vengono usati nei post non devi avere molto tempo libero.
Ciao.
Gabriele.

 ha scritto...

Non penserai mica di voler ottimizzare la velocità del codice con una 
scrittura del genere... vero?
-- 
Luc.


A meno che tu non stia usando un Commodore 64, non penso
che la chiamata di una funzione possa portare ad una perdita
di alcuni millisecondi (tempo nel quale un processore moderno
esegue migliaia di operazioni...), ma piu' probabilmente
ritardi dell'ordine dei microsecondi.
Quello che puoi fare, se la funzione e' molto semplice
ed e' invocata migliaia di volte, e' definirla "inline":
che in pratica suggerisci al compilatore (se lui lo ritiene fattibile e
opportuno) di sostituire il codice alla chiamata.
ciao,
g.

 dichiarazione/definizione della funzione.
Da come lo descrivi questo sembra context-switching... non e' cosi'!
Riguardati l'argomento. Ti sei confuso.
Tommy

"Quintomondo82"  wrote

Allora se la funzione e' semplice, poche righe, etc.... e (importante) viene
chiamata spessissimo allora puoi valutare di farla inline (ma non farlo tu,
lascialo fare al compilatore!). Tu usa SOLO la keyword inline, poi ci pensa
lui... altrimenti il codice diventa illeggibile (o cmq perde leggibilita'!)
L'ordine di millisecondi, oggi, e' esagerato (se lavori su PC o cmq computer
moderni).
Il modo in cui vuoi ottimizzare il codice e': "assolutamente da evitare"
(nella maggior parte di casi).
Tommy

...

Una piccola differenza c'e'. In pratica pero' i casi in cui ha senso
porsi questo problema sono rari: ad esempio quando la funzione e'
chiamata all'interno di un ciclo eseguito un numero molto elevato di
volte, o nell'ambito della programmazione real time, quando i vincoli
temporali sono stringenti rispetto alle prestazioni dell'hardware
utilizzato.
Ciao,
Nicola

 che vengono usati nei post non devi avere molto tempo libero.
La nostra e' una disciplina precisa. Abituarsi ad utilizzare la
terminologia corretta e' fondamentale.
Ciao,
Nicola

 che vengono usati nei post non devi avere molto tempo libero.
Non e' pignoleria.
Hai usato un termine sbagliato e non solo il termine. La spiegazione,
imprecisa, riguarda quel termine errato (context-switching) e NON le
chiamate di funzione.
Hai sbagliato. Ti sei confuso. Non hai capito molto di cio' che ti e' stato
detto all'universita' e per cio' e necessario stopparti per evitare che
altri possano imparare cose errate da te.
Se sei ancora convinto di aver fatto un errore non grave vuole dire che non
comprendi l'argomento e quindi ti consiglio di ri-studiartelo (ma forse
dovrei dire solo studiartelo).
Tommy

 che vengono usati nei post non devi avere molto tempo libero.
non capisco il perche` della tua risposta sarcastica in cui si nota un certo
astio. Non ho certo risposto per "farmi bello" o per cercare di
screditarti, ma solo per evitare che qualcuno alle prime armi potesse fare
confusione. Altrimenti i lettori del thread che non sanno cos'e` un context
switch saranno portati a credere che e` l'operazione associata alla
chiamata a funzione, quando questo non e` vero.



Scusa l'intromissione, ma mi e' venuta in mente una curiosita'. La Latenza
di una chiamata a funzione e' dell'ordine della latenza generata dal ritorno
da un ciclo (while per esempio?) nel senso che nel loop e' presente una riga
ASSEMBLER del tipo 0x110
0x100    SET LABEL;
0x104    DO SOMETHING;
0x108    DO SOMETHING 2;
0x110    MOV PC LABEL;
Nella chiamata a funzione avrei invece due salti.
0x100    SET LABEL;
0x104    DO SOMETHING;
0x108    RETURN;                    // SALTO 2
0x1000    MOV PC LABEL;     //SALTO 1
0x1004    DO SOMETHING;
0x1008    END;
Se le cose stanno in questo modo non credo che sia critica l'esecuzione di
una funzione, almeno che non si stia lavorando con un codice che necessita
di particolari ottimizzazione senza preoccuparsi della quantita' di memoria
necessaria a farlo eseguire.
Attenzione l'ASSEMBLER e' completamente fittizio ;-P
Ciao Emanuele

 wrote in message
b8j2od$edp$1...@hercules.btinternet.com...

Vabbeh dai... lo so pure io che il context switch riguarda la gestione dei
processi del processore centrale da parte del sistema operativo e non centra
con la chiamata ad una funzione. Rimane il fatto che chiamare la funzione,
accedere ad un dato, ritornare il valore, richiede più tempo di accedere al
valore direttamente e si traduce in un maggior numero di istruzioni
assembly. Dal punto di vista elettronico/assembler non c'è context switch,
dal punto di vista logico ci assomiglia.....
Uffaaaaa..... non riesco mai a spiegarmi.....

 Attenzione l'ASSEMBLER e' completamente fittizio ;-P
Me ne sono accorto. Studiati l'istruzione mov, che copia l'operando sorgente
nell'operando destinazione. Esistono parecchi tipi di mov, ma nessuno di
questi funziona da "goto".
Tommy

 wrote in message
b8j9u9$oaq$1...@hercules.btinternet.com...

L'esame sul context switch è pure andato bene (29) e so che c'è differenza
tra un context switch (la cpu smette di elaborare un processo per dedicarsi
ad un altro processo) e una chiamata di funzione (che invece riguarda
l'ordine e i modi di esecuzione delle istruzioni di uno stesso processo, lo
stesso programma).
Diciamo piuttosto che faccio fatica (sono un cane) a spiegarmi.
Fate Vobis.

 wrote in message
l5ivn-...@anto.cuni.lan...

Ehi Ehi Ehi.... Vabbene ok, non cominciamo un flame... non è il caso.
Mea Culpa. Ho usato un termine sbagliato e, a causa della mia aborrente
capacità esplicativa, ho motivato con una cattiva spiegazione la mia
risposta e i miei consigli (fondamentalmente esatti, su questo almeno sarete
daccordo).
Chiedo scusa a tutti... però non è il caso di litigare.......
Pace... amici come prima.
Gabriele

 Tommy
Va be' sui processori ARM con la MOV puoi muovere il PC. Non nel modo in cui
ho scritto (ossia con la label) ma inserendo direttamente l'indirizzo di
dove vuoi andare a leggere la prossima istruzione ASSEMBLER. Non mi sembra
che ci sia niente di strano.

 che ci sia niente di strano.
Hai ragione, avrei dovuto capire cosa intendevi fare con MOV.... anche se
ripeto non mi sembra per nulla il modo migliore....  ma quello che dici ha
comunque senso!
Tommy