Parallelismo e Concorrenza
In questa pagina
Attendere insieme non significa calcolare insieme
Una chiamata alle API di OpenAI è un’operazione limitata dall’I/O: il tuo programma non sta macinando numeri, sta aspettando una risposta di rete. Questa natura determina lo strumento giusto. Il parallelismo, inteso come multiprocessing, distribuisce il calcolo su più core; costa un processo intero per unità di lavoro ed eseguire cento processi che aspettano tutti la rete è puro spreco. La concorrenza, offerta da asyncio, permette a un singolo processo di gestire centinaia di attese simultanee a costo trascurabile. È questo che massimizza il throughput delle tue chiamate.
La distinzione non è solo accademica: un team che parallelizza le chiamate LLM con un pool di processi consumerà diversi gigabyte di memoria per zero guadagno rispetto a poche righe di asyncio.
Avviare chiamate concorrenti
L’SDK espone un client asincrono, AsyncOpenAI, le cui chiamate vengono attese con await. Raccogliere più coroutine in un asyncio.gather permette loro di progredire tutte simultaneamente, con una durata totale che si avvicina a quella della chiamata più lenta invece che alla loro somma.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Una singola chiamata API asincrona."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Avvia tutte le chiamate in modo concorrente."""
tasks = [single_call(prompt) for prompt in prompts]
results = await asyncio.gather(*tasks, return_exceptions=True)
for i, result in enumerate(results):
if isinstance(result, Exception):
print(f"Errore sul prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Il flag return_exceptions=True è ciò che distingue un prototipo da un’elaborazione di livello production. Senza di esso, la prima eccezione interrompe il gather e perdi i novantanove risultati già ottenuti. Con esso, gli errori diventano valori che ispezioni, registri e ritenti ai tuoi tempi.
Tuttavia, questa versione grezza ha un difetto immediato: lanciare mille chiamate tutte insieme supererà i tuoi rate limit in pochi secondi. Un semaforo risolve il problema permettendo solo un numero fisso di chiamate simultanee, lasciando le altre in attesa paziente del loro turno. Venti è un punto di partenza ragionevole, da aggiustare in base alle quote effettive della tua organizzazione.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Limita il numero di chiamate simultanee."""
semaphore = asyncio.Semaphore(max_concurrency)
async def limited_call(prompt: str) -> str:
async with semaphore:
return await single_call(prompt)
tasks = [limited_call(prompt) for prompt in prompts]
return await asyncio.gather(*tasks, return_exceptions=True)
Il pattern Map-Reduce applicato al testo
Un documento di duecento pagine non può essere riassunto in una singola chiamata e sezionarlo sequenzialmente richiederebbe minuti. Il pattern map-reduce si applica naturalmente qui: dividi in chunk, riassumi ogni chunk in modo concorrente, poi chiedi al modello una sintesi dei riassunti. La fase di map beneficia pienamente della concorrenza, mentre la fase di reduce è una singola chiamata su un testo diventato breve.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Riassume un documento lungo tramite map-reduce parallelo."""
# Fase MAP: divisione e riassunto in parallelo
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Riassumi questo passaggio in 3 punti chiave:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fase REDUCE: combinazione dei riassunti
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Sintetizza questi riassunti parziali in un riassunto coerente "
f"di 5 punti chiave:\n\n{summary_text}"
)
return final_summary
Il filtro if isinstance(r, str) è tanto una decisione di prodotto quanto una precauzione tecnica: significa che la sintesi finale verrà prodotta anche se tre chunk sono falliti, silenziosamente. A seconda del contesto, è esattamente ciò che vuoi, oppure è inaccettabile. Decidi esplicitamente e, in ogni caso, registra il numero di chunk persi.
Quando il multiprocessing torna rilevante
Restano rare situazioni in cui il calcolo riprende il controllo: post-elaborazione pesante sulle risposte, estrazione di entità, scoring, parsing strutturato. Questo lavoro è limitato dalla CPU e non guadagna nulla da asyncio. La combinazione elegante è concatenare i due regimi in un’unica pipeline: chiamate di rete in concorrenza, poi calcolo distribuito su un pool di processi tramite run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Elaborazione limitata dalla CPU sul risultato (NLP, parsing, ecc.)."""
# Esempio: estrazione di entità, scoring, ecc.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: chiamate LLM asincrone + post-elaborazione CPU parallela."""
# Passo 1: chiamate LLM concorrenti
llm_results = await calls_with_limit(prompts)
# Passo 2: post-elaborazione parallela (CPU)
loop = asyncio.get_event_loop()
with ProcessPoolExecutor(max_workers=4) as pool:
tasks = [
loop.run_in_executor(pool, heavy_post_processing, r)
for r in llm_results
if isinstance(r, str)
]
final_results = await asyncio.gather(*tasks)
return final_results
Verifica che il calcolo giustifichi davvero il pool prima di introdurlo: serializzare i dati verso un altro processo ha un costo e, per trattamenti che durano pochi millisecondi, questo costo supera il guadagno.
Verificare il throughput reale
Ottimizzare max_concurrency non è un tiro a indovinare. Troppo basso e lasci throughput sul tavolo; troppo alto e attivi rate limit che ti costano più tempo di quanto ne facciano risparmiare. Misura sul tuo carico reale, variando il valore, e guarda sia il throughput che il conteggio dei successi: una pipeline velocissima che fallisce una volta su cinque non è veloce.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Misura il throughput reale della tua pipeline."""
prompts = [
f"Dai un fatto interessante numero {i}."
for i in range(num_requests)
]
start = time.perf_counter()
results = await calls_with_limit(prompts, max_concurrency=20)
duration = time.perf_counter() - start
successes = sum(1 for r in results if isinstance(r, str))
print(f"Richieste: {num_requests}")
print(f"Successi: {successes}")
print(f"Durata: {duration:.1f}s")
print(f"Throughput: {successes / duration:.1f} req/s")
Punti chiave
- Usa
AsyncOpenAIeasyncio.gatherper la concorrenza I/O - Limita la concorrenza con un semaforo per rispettare le quote
- Il pattern map-reduce parallelizza l’elaborazione di documenti lunghi
- Riserva
ProcessPoolExecutorper la post-elaborazione intensiva sulla CPU