Parallelismo controllato e policy risorse
Corso Python scientifico in GX-TXT · Modulo 9 · Lezione 54
Il parallelismo può essere utile per compiti indipendenti, ma consuma risorse e introduce costi di coordinamento. Prima di avviare worker leggiamo la policy comunicata da GX-TXT e manteniamo un percorso seriale.
Obiettivi
- Consultare la policy delle risorse.
- Limitare i worker richiesti al massimo ammesso.
- Usare un pool con context manager quando consentito.
- Confrontare i risultati con un calcolo seriale.
Esecuzione
Importa parallelismo.py nella
Sessione corso_python, salvalo ed eseguilo nel Runner.

from concurrent.futures import ThreadPoolExecutor
from gxtxt import gxtxt_api_call, gxtxt_api_require
gxtxt_api_require("PARALLEL_EXECUTION_API_v1@1")
policy = gxtxt_api_call("PARALLEL_EXECUTION_API_v1", "resources", [])
richiesti = 2
ammessi = max(1, min(richiesti, int(policy["max_workers"])))
if not int(policy["enabled"]):
ammessi = 1
def quadrato(x):
return x * x
valori = [1, 2, 3, 4]
seriale = list(map(quadrato, valori))
if ammessi > 1:
with ThreadPoolExecutor(max_workers=ammessi) as executor:
risultato = list(executor.map(quadrato, valori))
modalita = "thread"
else:
risultato = list(map(quadrato, valori))
modalita = "seriale"
print("Worker richiesti:", richiesti, "ammessi:", ammessi)
print("Modalita:", modalita)
print("Risultati:", risultato)
print("Confronto con seriale:", risultato == seriale)
Lo script chiede due worker ma limita il numero al massimo riportato.
Se la policy disabilita il parallelismo o ammette un solo worker, esegue
il ramo seriale. Con più worker ammessi, ThreadPoolExecutor
usa un context manager che attende la chiusura del pool. La funzione
quadrato è pura: non modifica stato condiviso e non chiama
il Bridge dai thread.

In questa installazione è ammesso un solo worker: l’output mostra
modalità seriale, risultati [1, 4, 9, 16] e
accordo con il riferimento seriale. Non abbiamo misurato uno speed-up.
Il lavoro è volutamente piccolo; l’overhead di un pool potrebbe superare
il beneficio.
Thread, processi e risultati
I thread condividono memoria e richiedono attenzione allo stato modificabile; i processi isolano la memoria ma hanno costi di avvio e trasferimento. La scelta dipende dal carico, dal runtime e dalla policy, non solo dal numero di core. Per calcoli casuali occorre assegnare seed e flussi in modo esplicito e riproducibile; per scritture condivise bisogna prevenire race. Questo esempio è deterministico e non usa numeri casuali.
Esercizio
- Perché lo script ha scelto il ramo seriale nell’esecuzione mostrata?
- Che cosa garantisce il context manager del pool rispetto al suo ciclo di vita?
- Un risultato parallelo uguale al seriale dimostra uno speed-up?
Soluzione ragionata
- La policy riportava un massimo di un worker.
- Gestisce la chiusura del pool all’uscita dal blocco.
- No. Dimostra l’accordo per i casi confrontati; la velocità richiede una misurazione adeguata.
Nel modulo finale realizzeremo uno studio sintetico completo.