[Corsopoc] =?iso-8859-1?Q?=5BOT=5D_Stiamo_per_passare_alla_programmazione_concorrent?= =?iso-8859-1?Q?e_..._una_curiosit=E0_per_gli_amanti_del_pinguino:_i_bogom?= =?iso-8859-1?Q?ips.?=

[Michele Favara Pedarsi]

OFF-TOPIC: E' solo una curiosità... un'applicazione concreta di quello
che c'e' stato detto a lezione. Se non avete passione per queste cose,
saltate il messaggio.

Giovedì a lezione il prof ci ha introdotto il concetto di thread
appoggiandosi al GiocoDiBiglie e dimostrandoci che un loop fatto per
controllare una biglia, avrebbe compromesso la funzionalità delle altre
dato che il programma comunque viene eseguito linearmente ed un loop lo
ferma su un determinato task (il controllo di una determinata biglia)
per un determinato ammontare di tempo, durante il quale magari le altre
sono andate fuori dalle coordinate minime e massime; da qui la necessità
di thread separati per ogni biglia ovvero di processi che girano
contemporaneamente (o concorrentemente) al processo padre
...etc...etc...
Tornando al discorso del loop; la difficoltà di usare un loop è nel
calibrarlo, ovvero di sapere in maniera assoluta quanto "tempo" il
programma deve rimanere su quel loop... cosa praticamente impossibile
perché dipende dall'hardware, dalla velocità del/i processore/i,
dall'impegno istantaneo delle risorse, quindi dal tipo di macchina e da
quell'irripetibile istante in cui quel loop viene eseguito.

Bene, a lezione mi è venuta in mente una curiosità del kernel di linux:
i bogomips.
Anni fa, attratto dalla parola "mips" che scorre in fase di caricamento
del kernel e sta per milioni di operazioni per secondo, ho pensato che
questi potessero rappresentare una misura della potenza del mio
processore e da bravo tecnofilo ho provato a compararli con quelli di
altri pc: "aaaargh... sul computer del mio amico che ha 100MHz in meno,
il kernel misura più bogomips...devo ottimizzare qualcosa". Ingenuo...
sulla documentazione si negava che i BogoMIPS fossero una misura della
"potenza" del processore, ma non ho mai capito perché, la definizione
riportata era:

"the number of million times per second a processor can do absolutely
nothing."

Ora ho capito: il calcolo dei BogoMIPS serve proprio a calibrare (in
parte,l'altra parte va per forza fatta runtime) l'esecuzione dei
processi che per forza di cose non possono fare a meno di usare loop di
quel tipo (in sostanza tutte le applicazioni "a tempo continuo", per
esempio alcuni driver delle periferiche).

Il kernel controlla "quanti loop vuoti si possono fare al secondo su
quel processore", ovvero per avere una costante temporale
sufficientemente approssimata da mettere a disposizione alle
applicazioni che richiedono una sincronia con il tempo reale.
Infatti a seguito di questo calcolo (dei loops_per_jiffies), il kernel
mette a disposizione la variabile loops_per_sec ; e direi che i
sec(ondi) sono meglio dei jiffies... altrimenti per lavorare su un
computer toccherebbe comprarsi un orologio che misura i jiffies invece
dei secondi :)))))

In calce c'e' il codice che ho estratto dal kernel di linux (2.4.19 ed
in particolar modo da init/main.c ), notate il while più interno, esegue
solo... il commento /* nothing */ , maestoso, che a me è sembrato dire:
1) La tua ricerca è finita: hai trovato cosa sono i bogomips.
2) I bogomips sono il calcolo dello 0 cosmico informatico
3) Io ho calcolato i bogomips, ora tu calcola quanto tempo hai perso
alla ricerca dei bogomips.

:))))))))

Spero che approfondiremo in qualche corso futuro.

Ciao

Mik

n.b.: credo che fino a 3-4 anni fa questo era l'unico modo per avere una
sincronia tra tempo macchina e tempo reale (su linux), infatti il
multithreading (pthreads?) è stato sviluppato recentemente ed ha assunto
un ruolo concreto solo dopo che la grande industria ha investito su
linux.

void __init calibrate_delay(void)
{ 
// cut VARIABILI VARIE
// IL CALCOLO DEI BOGOMIPS
        printk("Calibrating delay loop... ");
        while (loops_per_jiffy <<= 1) {
                /* wait for "start of" clock tick */
                ticks = jiffies;
                while (ticks == jiffies)
                        /* nothing */;
                /* Go .. */
                ticks = jiffies;
                __delay(loops_per_jiffy); 
                ticks = jiffies - ticks;
                if (ticks)
                        break;  
        }
// cut APPROSSIMAZIONI VARIE
// STAMPA A VIDEO DEI BOGOMIPS 
/* Round the value and print it */
        printk("%lu.%02lu BogoMIPS\n",
                loops_per_jiffy/(500000/HZ),
                (loops_per_jiffy/(5000/HZ)) % 100);
}