Parallelismo

canale(capacità = 0)#

Un canale per mandare messaggi da un lavoro in parallelo all'altro.

c.invia(messaggio) mette in fondo una copia del messaggio, c.ricevi() toglie il primo (aspettando se non ce n'è), c.chiudi() dice che non ne arriveranno altri; per ogni m in c fai riceve finché il canale è chiuso e vuoto. Con capacità > 0 invia aspetta quando il canale è pieno (chi produce non corre più di chi consuma). Funziona anche fra lavori che girano in processi diversi.

variabile risultati = canale()

aspetta_tutti(lavori, secondi = nulla)#

Aspetta che finiscano tutti i lavori e dà la lista dei risultati.

I risultati sono nell'ordine della lista. Se un lavoro finisce con un errore, gli altri vengono annullati e l'errore si ripete qui; se dai secondi e il tempo scade, i lavori non finiti vengono annullati e c'è un errore.

variabile parti = aspetta_tutti([l1, l2, l3], 10)

aspetta_il_primo(lavori, secondi = nulla, annulla_gli_altri = falso)#

Il primo lavoro della lista che finisce.

Dà il lavoro (il suo risultato si legge con aspetta(lavoro)). Con annulla_gli_altri = vero ferma tutti gli altri: utile per chiedere la stessa cosa a più fonti e tenere la risposta più veloce.

variabile vincitore = aspetta_il_primo([a, b], annulla_gli_altri = vero)

ricevi_dal_primo(canali, secondi = nulla)#

Il primo messaggio che arriva da uno dei canali: [canale, messaggio].

Aspetta finché uno dei canali ha un messaggio (al massimo secondi); se sono tutti chiusi e vuoti c'è un errore.

variabile da, messaggio = ricevi_dal_primo([ordini, annulli])

annulla(lavori)#

Ferma un lavoro in parallelo (o una lista di lavori).

Con un lavoro dà vero se era ancora in corso; con una lista dà quanti ne ha fermati. Un lavoro annullato non ha un risultato: aspetta dà un errore.

annulla(ricerca)

processori()#

Quanti processori può usare il programma (per dividere un calcolo in parti).

variabile numeri = [4, 8, 15, 16, 23, 42]   # valore di provavariabile parti = dividi_in_parti(numeri, processori())

informazioni_parallelismo()#

Come lavorano qui i lavori in parallelo.

Dà un dizionario con modo ("processi": più processori per davvero; "fili": un processore, per esempio su Android), processori, processi (vero se si possono usare), motivo (perché no), lavoratori (processi pronti) e gil.

prepara_processi(quanti = nulla)#

Avvia subito i processi che faranno i lavori (predefinito: uno per processore).

Di solito non serve: i processi partono da soli al primo lavoro. Prepararli prima toglie quella breve attesa (utile prima di misurare i tempi o in un gioco). Dà quanti processi sono pronti (0 dove i processi non si possono usare, per esempio su Android).