a) scrivere il programma interamente in C richiederebbe 100 mesi con un 
tempo di esecuzione x.

b) scrivere il programma interamente in linguaggio assembly richiederebbe 
1000 mesi (tenendo conto che il codice in assembly risulta 10 volte piu' 
difficile) e verrebbe eseguito in un tempo x/4 (visto che l'esecuzione del 
codice assembly e' 4 volte piu' veloce di quella del codice in C).

c) introdurre il processo di "tuning" nella produzione del codice 
richiederebbe un tempo di produzione di 110 mesi e un tempo di esecuzione 
pari a 5x/8.


In conclusione l'ultima strategia sembra la migliore:
infatti per quanto riguarda il tempo di produzione del codice si rileva un 
aumento del 10% rispetto alla prima strategia ed un (ovvio) grosso risparmio 
rispetto alla seconda strategia.
Per quanto riguarda il tempo di esecuzione del codice, si rileva un lieve  
aumento (di 3x/8) rispetto alla seconda strategia contro un grande risparmio 
rispetto alla prima.

[By Firrincieli]





In seguito indicheremo con:

- P il programma in questione;
- T il tempo di esecuzione del programma scritto in linguaggio C;
- Ec grado di efficienza del codice scritto in C
- Ea grado di efficienza del codice scritto in Linguaggio Assemblatore

I dati in nostro possesso sono i seguenti:

Risorse necessarie a realizzare P in lingiuaggio C:            100 uomini / mese.

Risorse necessarie a realizzare P in linguaggio Assemblatore: 1000 uomini / mese.

Rapporto di efficienza tra le due diverse implementazioni: Ea = 4 * Ec.
(Il codice scritto in linguaggio assemblatore e' 4 volte piu' veloce di quello scritto in C)

L' 1% del codice di P e' responsabile del 50% di T;
dunque il restante 99% di P e' anch'esso responsabile del 50% di T.

Sono possibili 3 diverse realizzazioni:

1 - Realizzazione in linguaggio C.

                      Risorse (in uomini/mese) | Tempo di esecuzione
                      ------------------------ | -------------------
Codice critico    1%:                        1 |                 T/2
Codice rimanente 99%:                       99 |                 T/2
                                           --- |                 ---
Totale                                     100                     T

2 - Realizzazione in linguaggio Assemblatore.

                      Risorse (in uomini/mese) | Tempo di esecuzione
                      ------------------------ | -------------------
Codice critico    1%:                       10 |                 T/8
Codice rimanente 99%:                      990 |                 T/8
                                          ---- |                 ---
Totale                                    1000                   T/4

3 - Riscrittura della parte critica in linguaggio Assemblatore.

                      Risorse (in uomini/mese) | Tempo di esecuzione
                      -------------------------|--------------------
Codice critico    1%:                       11 |                 T/8
Codice rimanente 99%:                       99 |                 T/2
                                           --- |              ------
Totale                                     110                (5/8)T

- Tabella Riass. |Risorse|Tempo di esecuzione
  Soluzione 1    |    100|                  T
  Soluzione 2    |   1000|                T/4
  Soluzione 3    |    110|             (5/8)T

Considerazioni: 

La soluzione numero 1 e' sicuramente una scelta equilibrata, probabilmente e' quella che 
farebbero molte software house moderne che sfruttano in minima parte le potenzialita' 
dell'hardware oggi disponibile.
Nel caso in cui il programma dovesse realizzare i calcoli per il rendering di una recente 
scheda video che deve sfornare milioni di pixel allora non importerebbe la quantita' 
di risorse da impiegare, quanto le performances e la soluzione piu' probabile sarebbe la 2.
Ma per la maggior parte delle applicazioni, la soluzione numero 3 e' quella che presenta 
un buon margine di miglioramento, poiche' e' quasi piu' veloce del codice scritto 
interamente in C del 50% con un aumento di risorse alquanto esiguo.

by Carlo Mongelli.