Parallelismo controllato e policy risorse

di Giux GX-TXT, python-it, scripts-it 2 min di lettura

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.

Script che consulta la policy delle risorse.
Script che consulta la policy delle risorse.
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.

Output del Job: un worker ammesso e percorso seriale.
Output del Job: un worker ammesso e percorso seriale.

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

  1. Perché lo script ha scelto il ramo seriale nell’esecuzione mostrata?
  2. Che cosa garantisce il context manager del pool rispetto al suo ciclo di vita?
  3. Un risultato parallelo uguale al seriale dimostra uno speed-up?

Soluzione ragionata

  1. La policy riportava un massimo di un worker.
  2. Gestisce la chiusura del pool all’uscita dal blocco.
  3. No. Dimostra l’accordo per i casi confrontati; la velocità richiede una misurazione adeguata.

Nel modulo finale realizzeremo uno studio sintetico completo.

Scarica gli script del Modulo 09 (ZIP)

#Debugging #GX-TXT #Python

Altre tappe del progetto

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *