Newsgroup: it.comp.lang.c++
Titolo: Problema o curiosità

Ciao a tutti,
Spero di riuscire ad esporre la mia domanda (curiosità) in modo
chiaro:
supponiamo di avere n funzioni in un programma. Ogni funzione, una
volta chiamata, deve eseguire dei calcoli su una stessa variabile X.
Cosa conviene di più, dal punto di vista dell'efficienza:
	1) fare prima i calcoli in base alla funziona da richiamare e
poi passare il risultato come parametro;
 
	2) chiamare la funzione e lasciare che ognuna svolga i suoi
calcoli?
Forse è la stessa cosa?
Come ci si deve regolare per valutare l'efficienza di una scelta di
programmazione? Esistono delle regole generali o va ad esperienza?
Grazie
Robby

 programmazione? Esistono delle regole generali o va ad esperienza?
A parte che non ho capito praticamente niente di quello che chiedi.
Comunque, secondo me, c'è un solo modo sicuro per testare l'efficienza
relativa di scelte diverse: utilizzare un profiler.
EMG


 Grazie
Robby

 calcoli?
Proprio non ho capito!
Se il software e' su un sistema embedded ed il problema e' la velocita'
di esecuzione, puoi dichiarare le funzioni come inline e lasciare
l'ottimizzazione al compilatore.
In altri casi non so poiche' non ho ben compreso il problema.
Fausto

[zak]
: c'è qualche differenza importante tra questi due metodi o sono
: sostanzialmente equivalenti? (per importante intendo che
possano
: influire sull'efficienza del programma)
Ti dò alcune risposte:
1 - programma single thread
    (il programma viene eseguito 1 volta, gli
    accessi ad X sono in sequenza), la
    variabile (od oggetto) X è dichiarata
    in main a viene passato come const type& X
2 - programma multithread
    (possono esservi diversi accessi ad X
    contemporaneamente) se il valore di X può
    cambiare tra una chiamata e l'altra, la
    soluzione più efficiente e sicura è il
    lock su X, a meno che le varie func_n(x)
    non utilizzino il valore senza modificarlo,
    caso in cui vale il metodo precedente
3 - X Oggetto shared
    se X è in una libreria condivisa (DLL o .so)
    è necessario considerare la cosa come il caso 2
4 - X variabile globale
    questa soluzione non è c++, è c. In c++ usa un
    oggetto con un metodo statico che ti fornisca
    il valore di X
5 - Altro tipo
    Se ne esiste fammi un fischio
: Se i calcoli su X sono gli stessi per tutte le N funzioni, la
cosa
: migliore è fare il calcolo con un solo set di istruzioni
esternamente
: alle funzioni e fare il passaggio tramite parametro del valore,
ma se
: le elaborazioni su X sono diverse?
Se il tipo di calcoli è ESATTAMENTE lo stesso, allora crea una
funzione che faccia tali calcoli, possibilmente inline. Esempio:
lo stato di un sistema è rappresentato dalla temperatura, a cui
corrisponde un certo valore di risposta, mettiamo velocità
se la formula è la stessa (es: V = V_MAX_su_T_MAX * T ), puoi
ridefinire temp_type::operator const velocity_type() per
effettuare la conversione.
Nella func_n(t)
    ...
    velocità = (velocity_type)t;
    ...
Altrimenti ricadi nei casi precedenti.
[zak]
: Te ne sarei grato se mi potessi fornire qualche altro elemento
sui
: profiler, perchè non ne ho mai sentito parlare (sono nuovo
 :-) )
il profiling è supportato da tutti i compilatori attulai: va
abilitato con un'opzione di compilazione, e poi un programma,
esterno od interno, valcola il tempo speso in ogni funzione.
in alternativa puoi effettuare delle chiamate a clock() e a
time() prima e dopo le funzioni, per avere il tempo di esecuzione
spero di esserti stato d'aiuto
--
       __    __      __
      / /   / / __  / /
     / /   / / /_ \/ /
    / /___/ /___/ / //\    e-mail : 
blak...@tiscalinet.it
   / __  / / __  /    /   ICQ    : 59394345
  / /_/ / / /_/ / /| |   Home   : (under construction)
 /_____/_/_____/_/ |_|__
 \ \the one     \ \ / __\
  \ \and    _____\ \| |_     It is better to reign in Hell
   \ \only _\  __ \ \  _\     Than serve in heaven.
    \ \  _ \ \ \ \ \ \ \       MILTON
     \ \_\\_\ \ \_\ \ \ \
      \________\_____\_\_\
The UNIX Guru's View of Sex:
$unzip ; strip ; touch ; finger ; mount ; fsck ; more ; yes ;
umount; sleep

 profiler, perchè non ne ho mai sentito parlare (sono nuovo  :-) )
Il profiler è uno strumento che misura la velocità delle varie parti del
tuo codice mentre è in esecuzione e te ne mostra alla fine una
statistica completa, evidenziandone quindi gli eventuali colli di
bottiglia. Lo dovresti trovare compreso nel pacchetto di ogni
compilatore decente.
EMG

 Il senso di tutto questo però mi sfugge...
Il fatto è che è una curiosità che mi è sorta, quindi magari non ha
alcuna vera importanza..........
Ti ringrazio molto per il tuo tempo e la tua disponibilità.
Saluti
Robby