= Il modulo xtime =

Il modulo ntk.wrap.xtime ('''''TODO''': replicato in ntk.lib.xtime, perché? Da rimuovere?'') risponde al problema dell'uso di sleep in un ambiente di multithread cooperativo.

Quando un microthread ha la necessità di attendere alcuni istanti prima di eseguire una certa azione, come lo fa?
<<BR>>
Supponiamo si vuole attendere una certa condizione.

Può eseguire
{{{
    while not my_condition():
        pass
}}}

Questa è una cosidetta busy-wait. Il sistema viene appesantito, perché fino a quando la condizione non diventa vera il processo impegna la CPU.

Di norma si evita questo spreco inserendo dei piccoli {{{sleep}}}. Ad esempio
{{{
    while not my_condition():
        time.sleep(0.01)
}}}

Durante questa attesa la CPU non è impegnata. Soltanto una volta ogni 0.01 secondi, che per il processore è molto tempo, fa qualcosa per verificare se la condizione è divenuta vera.
<<BR>>
Questa non è più una busy-wait, nel senso che l'intero sistema non viene appesantito. Ma in un ambiente di microthread cooperativi, questo approccio non istruisce lo schedulatore di passare il comando ad altri microthread. Così, anche se il sistema appare scarico, il nostro programma non va avanti.

Va quindi aggiunta una chiamata alla {{{stackless.schedule}}}, che nel nostro programma è nel metodo {{{micro.micro_block()}}}.
{{{
    while not my_condition():
        time.sleep(0.01)
        micro.micro_block()
}}}

''Nota'': la chiamata a time.sleep resta necessaria, altrimenti ritorneremo ancora ad una situazione di busy-wait.

Qui ci si trova davanti ad una scelta. Quanto tempo aspettare nella chiamata bloccante {{{time.sleep}}}?
<<BR>>
Se la '''verifica della condizione''' è '''molto impegnativa''', allora '''un tempo basso''' nella sleep è controproducente per l'intero sistema. Infatti ogni pochi istanti la CPU viene impegnata per verificare la condizione, mentre forse sarebbe sufficiente al programma effettuare una verifica ad intervalli più ampi.
<<BR>>
Si sarebbe portati quindi a usare '''un tempo alto''' nella sleep. Ma questa chiamata è bloccante per tutto il programma, quindi un tempo alto ostacola inutilmente il procedere degli altri microthread.

Se invece la '''verifica della condizione''' risultasse '''non impegnativa''', allora usare un tempo basso sarebbe la risposta ottimale.

Il '''modulo xtime''' facilita questo lavoro  implementando una funzione {{{swait}}} che automaticamente intervalla uno sleep di 0.001 secondi con una chiamata micro_block fino a quando non è passato il tempo richiesto. La verifica da fare è poco onerosa, si tratta di leggere l'ora del sistema.

Notare inoltre che nel modulo '''xtime''' sia la funzione {{{swait}}} sia la funzione {{{time}}} usano come unità il millisecondo, invece del secondo come nel modulo standard '''time'''. ('''''TODO''': C'è un motivo particolare?'')

In conclusione:
 * se la condizione da verificare è poco onerosa, intervallarla con una chiamata a {{{time.sleep}}} con un tempo basso espresso in secondi e una chiamata a {{{micro_block}}};
 * se la condizione da verificare è molto onerosa, intervallarla con una chiamata a {{{xtime.swait}}} con un tempo più alto espresso in millisecondi;
 * se non ci sono condizioni da verificare, ma solo si vuole attendere un certo tempo, usare {{{xtime.swait}}} con il tempo esatto che si vuole attendere espresso in millisecondi.