Legge di Amdahl
Un programma parallelo al 95% va circa 5,93 volte più veloce con 8 processori, non 8 volte, e non supererà mai le 20 volte, comunque ne aggiunga. Lo usi per dimensionare un cluster o smontare una promessa di moltiplicare per N prima di comprare hardware. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Frazione parallela
- 0,95
- Processori
- 8
- Frazione seriale
- 0,05
- Speedup
- 5,9259259259
- Efficienza
- 0,7407407407
- Limite seriale
- 20
La legge di Amdahl nomina il tetto che il lavoro seriale residuo impone all'accelerazione parallela. Se una frazione P di un programma può eseguire in modo concorrente e il resto deve restare sequenziale, aggiungere processori non moltiplica mai il tempo di esecuzione per N. L'accelerazione teorica è uno su uno meno P più P su N: il resto seriale resta al denominatore per quanto grande diventi N. Questo calcolatore della legge di Amdahl accetta la frazione parallelizzabile e il numero di processori, poi restituisce il fattore di accelerazione, la frazione seriale, l'efficienza parallela e il limite asintotico seriale uno su uno meno P ogni volta che rimane lavoro seriale. L'aritmetica è un'identità in forma chiusa, pienamente deterministica, senza simulazione e senza modello linguistico. Serve a dimensionare un cluster, confutare un'affermazione ingenua di N volte o verificare una curva di accelerazione da manuale prima di acquistare hardware.
Cosa misura la legge di Amdahl e come si ricava il fattore di accelerazione
La legge di Amdahl è l'osservazione di Gene Amdahl del 1967: il lavoro seriale rimasto limita quanto più veloce può diventare un programma intero, quanti processori si applichino alla parte parallela. Scriva P per la frazione del tempo di orologio di un singolo processore che può eseguire in modo concorrente, e N per il numero di processori. La frazione sequenziale è uno meno P.
Dopo aver diviso il lavoro parallelo in N parti, il tempo relativo diventa uno meno P più P su N, così l'accelerazione teorica S di N è il reciproco di quella somma: uno diviso per uno meno P più P su N. Quando P vale uno, ogni ciclo si parallelizza e l'accelerazione è uguale a N. Quando P vale zero, il lavoro è puramente seriale e l'accelerazione resta uno per ogni N.
Tra quegli estremi, l'accelerazione cresce con N ma si appiattisce verso il limite seriale uno su uno meno P. Quel tetto è il senso della legge: un programma che è solo il cinque per cento seriale non può mai superare un'accelerazione di venti volte, nemmeno su un milione di core, perché il cinque per cento seriale resta dopo che l'oceano parallelo è stato affettato all'infinito. L'efficienza parallela è l'accelerazione divisa per N; scende al crescere di N a meno che P non sia esattamente uno.
Questo calcolatore valuta quelle identità in modo diretto. Non è un profiler, né un simulatore a eventi discreti, né il modello di accelerazione scalata di Gustafson, che pone un'altra domanda facendo crescere il problema con la macchina. Se Lei conosce P da una misura o da una stima sul retro della busta che separa i loop caldi dalla preparazione, la formula di Amdahl dà l'accelerazione teorica da attendersi prima che effetti di cache, contesa di lock o traffico NUMA peggiorino la curva reale.
Dove un calcolatore della legge di Amdahl rende il proprio valore
Usi lo strumento del browser quando dimensiona un cluster, esamina un'affermazione di prestazione secondo cui l'accelerazione seguirà il numero di core, o guida una classe sul perché il novantacinque per cento parallelo si fermi comunque a venti volte. Incrementi N finché l'accelerazione si avvicina al limite seriale, poi smetta di acquistare core che non potrà sfruttare.
Confronti il risultato con la legge di Gustafson se il carico cresce con la macchina; Amdahl tiene fissa la dimensione del problema, che è il limite conservativo per lotti, compilatori e kernel scientifici che non si ingrandiscono per magia quando si aggiungono socket. I risultati sono pienamente deterministici: gli stessi P e N producono sempre lo stesso vettore di accelerazione, così può fissare esempi in test e materiali didattici. Non c'è modello linguistico, né servizio esterno di profiling, né casualità.
Casi d'uso
Dimensionamento di cluster e numero di core
Inserisca la frazione parallelizzabile misurata e scorra i conteggi di processori finché l'accelerazione teorica si avvicina al limite seriale; poi smetta di acquistare core che non potrà sfruttare.
Controlli di realismo nelle revisioni di prestazione
Sostituisca un'affermazione ingenua di accelerazione N volte con il limite di Amdahl, così le revisioni di architettura mostrano il resto seriale invece di una curva lineare senza tetto.
Domande frequenti
Che succede se la frazione parallelizzabile esce da 0 a 1?
P è una frazione del tempo di un singolo processore, quindi i valori sotto 0 o sopra 1 vengono rifiutati e non fatturati. Invii 0.95 per il 95 per cento, non 95.
In che cosa differisce dalla legge di Gustafson?
Amdahl tiene fissa la dimensione del problema e chiede quanto più veloce lo stesso lavoro gira su N processori. Gustafson lascia crescere il problema con la macchina.
Qual è la formula della legge di Amdahl?
L'accelerazione è uno diviso la frazione seriale più la frazione parallela ripartita tra i processori. Con 0,95 di parte parallela e 8 processori si ottiene uno su 0,05 più 0,95 diviso 8, circa 5,93 volte.
Che cosa indica l'efficienza parallela?
È l'accelerazione divisa per il numero di processori. Con 5,93 volte su 8 processori l'efficienza è circa 0,74: ogni processore rende più o meno tre quarti del suo ideale, e la quota scende quando se ne aggiungono altri.
Il mio programma reale raggiungerà questa accelerazione?
Di solito no. Il risultato è un tetto teorico per un carico di lavoro fisso. Cache, blocchi e traffico di memoria peggiorano le curve reali, quindi lo consideri il caso migliore da confrontare con le sue misure.
Strumenti correlati
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/amdahls-law \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"parallel_fraction":0.95,"processors":8}'const res = await fetch("https://api.kit.forhosting.com/dev/amdahls-law", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"parallel_fraction": 0.95,
"processors": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/amdahls-law",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"parallel_fraction": 0.95,
"processors": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/amdahls-law", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"parallel_fraction":0.95,"processors":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"parallel_fraction":0.95,"processors":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/amdahls-law", 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": 8
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.amdahls_law",
"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.
Limiti
max_processors | 1000000000000 |
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. |
Note tecniche
Contratto di ingresso, forma della risposta e comportamento di errore
Dopo la convalida il motore calcola la frazione seriale come uno meno P, il denominatore di Amdahl come quel resto seriale più P su N, l'accelerazione come uno sul denominatore e l'efficienza come accelerazione su N. Quando P vale uno il limite seriale non è limitato, così quella chiave viene omessa invece di essere emessa come null. Esempio: P uguale a 0.95 e N uguale a otto produce un'accelerazione di circa 5.93, un'efficienza di circa 0.74 e un limite seriale di venti. È un oracolo di accelerazione teorica nel modello a carico fisso di Amdahl, non una misura del Suo binario né un calcolatore di accelerazione scalata di Gustafson. Invii con POST un corpo JSON con due campi obbligatori. parallel_fraction è la frazione parallelizzabile P, un numero finito da zero a uno incluso; invii 0.95 per il novantacinque per cento, mai novantacinque. Si accettano gli alias p, parallelizable_fraction e f. processors è il numero di processori N, un intero da uno a un bilione. Si accettano gli alias n, cores e n_processors. Campi assenti, valori non finiti, conteggi di processori non interi, N sotto uno, N sopra il massimo pubblicato e una frazione parallelizzabile fuori da zero a uno falliscono con invalid_input nominando il campo e non vengono fatturati. Il corpo JSON ripete parallel_fraction e processors, poi restituisce serial_fraction, speedup, efficiency e una stringa formula che riformula S di N uguale a uno su uno meno P più P su N. Quando P è strettamente minore di uno restituisce anche serial_limit, il limite asintotico uno su uno meno P.
Dove un calcolatore della legge di Amdahl rende il proprio valore
Usi l'API quando uno script, una sandbox di colloquio, un taccuino di architettura o un controllo di integrazione continua necessita di JSON stabile per molte coppie (P, N) sotto un unico contratto. Ogni richiesta riuscita è un articolo fatturabile a $0.002; la convalida fallita non consuma saldo. L'intervallo di processori pubblicato mantiene la valutazione in forma chiusa entro double IEEE-754 ordinari e copre ogni macchina pratica che si dimensionerebbe a mano. Colleghi l'endpoint a tutorial di calcolo parallelo, pianificatori di capacità, revisioni di architettura o oracoli di colloquio di programmazione in cui preferisce l'identità esatta di Amdahl a tabelle aneddotiche di accelerazione che nascondono il resto seriale.
Casi di integrazione
Didattica del calcolo parallelo
Offra agli studenti un oracolo deterministico per S(N)=1/((1-P)+P/N), compresi i casi P=0, P=1 e il limite seriale, senza allestire un profiler.
Domande tecniche
Qual è la formula della legge di Amdahl per l'accelerazione?
Invii parallel_fraction P in [0, 1] e processors N come intero ≥ 1. L'API restituisce S(N)=1/((1-P)+P/N), più la frazione seriale 1-P e l'efficienza S/N.
Che cos'è il limite seriale restituito dal calcolatore?
serial_limit è 1/(1-P), l'accelerazione massima quando N tende all'infinito. Viene omesso quando P=1 perché un programma pienamente parallelo non ha limite seriale.
Quanto costa il calcolatore della legge di Amdahl?
Lo strumento del browser è gratuito. Le richieste API usano saldo KIT prepagato a $0.002 per chiamata riuscita; l'ingresso non valido non viene fatturato.