Calcolatore della legge di Amdahl e limite di speedup
La legge di Amdahl stima il massimo speedup teorico quando una parte del programma può essere eseguita in parallelo e la restante parte deve rimanere seriale.
Esegui gratis nel browser
Inserisca la frazione parallelizzabile e il numero di processori per conoscere lo speedup previsto, l’efficienza dei processori e quanto del tempo accelerato è ancora occupato dal lavoro seriale. Il calcolatore riporta inoltre il limite asintotico imposto da tale porzione, aiutandoLa a stabilire se convenga aggiungere processori oppure ottimizzare prima il codice sequenziale.
Che cosa misura la legge di Amdahl
La legge di Amdahl divide il tempo di esecuzione originale in una frazione parallelizzabile e una seriale. Se p è parallelizzabile e N processori si ripartiscono perfettamente il lavoro, il tempo normalizzato diventa (1 − p) + p/N. Il massimo speedup teorico è il reciproco di tale tempo. Questo calcolatore applica direttamente l’equazione e presume una pianificazione ideale: il lavoro parallelo viene distribuito uniformemente, i processori non introducono costi di comunicazione e la parte seriale non accelera aggiungendo unità di calcolo. Il risultato è quindi un limite superiore, non una previsione di benchmark. Un’implementazione reale può ottenere meno a causa di sincronizzazione, contesa della memoria, avvio delle attività, squilibrio del carico e trasferimento dei dati. Il limite rimane utile per verificare se una misura è plausibile e quanto margine di miglioramento resta. Inserisca la frazione parallela in forma decimale: 95 per cento corrisponde a 0.95.
Come leggere il collo di bottiglia e il limite
La frazione seriale è uno meno la frazione parallela e determina il tetto nel lungo periodo. Con 95 per cento di lavoro parallelo rimane 5 per cento seriale; neppure processori illimitati possono quindi superare uno speedup di 20 volte. Il campo dello speedup asintotico indica questo tetto quando esiste una parte seriale. La quota del collo di bottiglia seriale risponde a una domanda diversa: con il numero selezionato di processori, quale frazione del nuovo tempo ridotto è ancora seriale? Questa quota spesso cresce notevolmente aggiungendo processori. Una sezione che occupava solo 5 per cento del tempo originale può diventare dominante dopo aver suddiviso la parte parallela. L’efficienza parallela è lo speedup calcolato diviso per il numero di processori. Se diminuisce, ogni processore aggiuntivo offre un beneficio minore. Nel complesso, questi valori mostrano i rendimenti decrescenti dello scaling forte e distinguono la scarsità di processori da un vincolo intrinsecamente seriale.
Come usare il risultato nella pianificazione
Parta da un profilo misurato su un carico rappresentativo, non da una stima ottimistica. Classifichi il tempo come parallelizzabile solo se il progetto di produzione può davvero eseguirlo in concorrenza. Calcoli poi diversi numeri di processori e confronti lo speedup aggiuntivo con il costo dell’infrastruttura. Se raddoppiare i processori modifica appena il risultato, la frazione seriale indica già la priorità: ottimizzi il percorso sequenziale, cambi algoritmo, riduca il coordinamento oppure aumenti il lavoro indipendente per esecuzione. Il calcolo è particolarmente utile prima di passare a più core, worker, GPU o nodi distribuiti, perché evita di presumere una scalabilità lineare. Può inoltre fornire una base per i rapporti di regressione: confronti lo speedup misurato con il massimo teorico e analizzi la differenza. La legge di Amdahl descrive carichi fissi; se il carico cresce con le risorse, la legge di Gustafson affronta un’altra domanda.
Casi d'uso
Pianificare un’ottimizzazione multicore
Stimi il miglior guadagno possibile con il numero proposto di processori prima di investire nella parallelizzazione di un carico fisso.
Spiegare i rendimenti decrescenti
Mostri perché aggiungere worker produce benefici sempre minori quando una query, un coordinatore o un’altra fase seriale non cambia.
Confrontare teoria e benchmark
Usi il tetto teorico come riferimento per lo speedup misurato e analizzi i costi di pianificazione, comunicazione o contesa.
Domande frequenti
Che cosa significa frazione parallela?
È la quota del tempo originale che può essere distribuita tra i processori. La inserisca come numero decimale compreso tra 0 e 1.
Perché il risultato è un massimo speedup teorico?
L’equazione presume una ripartizione perfetta e nessun costo di comunicazione, sincronizzazione, avvio, contesa o pianificazione. Il guadagno reale è solitamente inferiore.
Che cos’è lo speedup asintotico?
È il tetto dello speedup quando il numero di processori tende all’infinito. Per una frazione seriale s diversa da zero, vale 1/s.
Che cosa mostra la quota del collo di bottiglia seriale?
Indica la parte del tempo accelerato occupata dal lavoro seriale con i processori selezionati e rivela quando l’esecuzione sequenziale diventa dominante.
Un processore restituisce sempre uno speedup pari a uno?
Sì. Nel modello ideale di Amdahl, un processore esegue entrambe le parti nel tempo normalizzato originale; speedup ed efficienza valgono uno.
Quanto costa il calcolo tramite API?
Ogni richiesta API costa $0.002. Lo stesso calcolo deterministico è disponibile nell’interfaccia del browser.
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/dev/amdahl \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"parallel_fraction":0.95,"processors":16}'const res = await fetch("https://api.kit.forhosting.com/dev/amdahl", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"parallel_fraction": 0.95,
"processors": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/amdahl",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"parallel_fraction": 0.95,
"processors": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/amdahl", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"parallel_fraction":0.95,"processors":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"parallel_fraction":0.95,"processors":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/amdahl", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"parallel_fraction": 0.95,
"processors": 16
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.amdahl",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |