Loi d'Amdahl
Un programme parallèle à 95 % va environ 5,93 fois plus vite sur 8 processeurs, pas 8 fois, et ne dépassera jamais 20 fois, quel que soit leur nombre. Servez-vous-en pour dimensionner un cluster ou contrer une promesse de gain par N avant d'investir. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Fraction parallèle
- 0,95
- Processeurs
- 8
- Fraction séquentielle
- 0,05
- Accélération
- 5,9259259259
- Efficacité
- 0,7407407407
- Limite série
- 20
La loi d'Amdahl nomme le plafond que le travail série restant impose à l'accélération parallèle. Si une fraction P d'un programme peut s'exécuter de façon concurrente et que le reste doit rester séquentiel, ajouter des processeurs ne multiplie jamais le temps d'exécution par N. L'accélération théorique vaut un sur un moins P plus P sur N : le reste série demeure au dénominateur, si grand que soit N. Ce calculateur de la loi d'Amdahl accepte la fraction parallélisable et le nombre de processeurs, puis renvoie le facteur d'accélération, la fraction série, l'efficacité parallèle et la limite asymptotique série un sur un moins P dès qu'il reste du travail série. L'arithmétique est une identité sous forme fermée, entièrement déterministe, sans simulation et sans modèle de langage. Servez-vous-en pour dimensionner un cluster, réfuter une affirmation naïve de N fois, ou vérifier une courbe d'accélération de manuel avant d'acheter du matériel.
Ce que mesure la loi d'Amdahl et comment le facteur d'accélération se dérive
La loi d'Amdahl est l'observation de Gene Amdahl en 1967 : le travail série restant borne l'accélération d'un programme entier, quel que soit le nombre de processeurs appliqués à la partie parallèle. Notez P la fraction du temps d'horloge d'un processeur unique qui peut s'exécuter de façon concurrente, et N le nombre de processeurs. La fraction séquentielle vaut un moins P.
Après avoir divisé le travail parallèle en N parts, le temps relatif devient un moins P plus P sur N, si bien que l'accélération théorique S de N est l'inverse de cette somme : un divisé par un moins P plus P sur N. Lorsque P vaut un, chaque cycle se parallélise et l'accélération égale N. Lorsque P vaut zéro, le travail est purement série et l'accélération reste un pour tout N.
Entre ces extrêmes, l'accélération croît avec N mais s'aplatit vers la limite série un sur un moins P. Ce plafond est tout l'enjeu de la loi : un programme qui n'est série qu'à cinq pour cent ne peut jamais dépasser une accélération de vingt fois, même sur un million de cœurs, car les cinq pour cent série demeurent une fois l'océan parallèle tranché à l'infini. L'efficacité parallèle est l'accélération divisée par N ; elle diminue quand N croît, sauf si P vaut exactement un.
Ce calculateur évalue ces identités directement. Ce n'est ni un profileur, ni un simulateur à événements discrets, ni le modèle d'accélération mise à l'échelle de Gustafson, qui pose une autre question en faisant croître le problème avec la machine. Si vous connaissez P par mesure ou par une estimation de coin de table séparant boucles chaudes et préparation, la formule d'Amdahl donne l'accélération théorique à attendre avant que les effets de cache, la contention de verrous ou le trafic NUMA n'aggravent la courbe réelle.
Où un calculateur de la loi d'Amdahl gagne sa place
Utilisez l'outil du navigateur lorsque vous dimensionnez un cluster, examinez une affirmation de performance selon laquelle l'accélération suivra le nombre de cœurs, ou expliquez en cours pourquoi quatre-vingt-quinze pour cent parallèle plafonne encore à vingt fois. Augmentez N jusqu'à ce que l'accélération approche la limite série, puis cessez d'acheter des cœurs que vous ne pourrez pas récolter.
Contrastez le résultat avec la loi de Gustafson si la charge croît avec la machine ; Amdahl maintient la taille du problème fixe, ce qui est la borne conservative pour les lots, les compilateurs et les noyaux scientifiques qui n'enflent pas par magie quand on ajoute des sockets. Les résultats sont entièrement déterministes : les mêmes P et N produisent toujours le même vecteur d'accélération, si bien que vous pouvez figer des exemples dans les tests et les supports de cours.
Il n'y a ni modèle de langage, ni service externe de profilage, ni aléa.
Cas d’usage
Dimensionnement de cluster et nombre de cœurs
Saisissez la fraction parallélisable mesurée et parcourez les nombres de processeurs jusqu'à ce que l'accélération théorique approche la limite série, puis cessez d'acheter des cœurs que vous ne pourrez pas récolter.
Contrôles de réalisme lors des revues de performance
Remplacez une affirmation naïve d'accélération N fois par la borne d'Amdahl, afin que les revues d'architecture montrent le reste série plutôt qu'une courbe linéaire sans plafond.
Questions fréquentes
Que se passe-t-il si la fraction parallélisable sort de 0 à 1 ?
P est une fraction du temps d'un processeur unique, donc les valeurs sous 0 ou au-dessus de 1 sont rejetées et non facturées. Envoyez 0.95 pour 95 pour cent, pas 95.
En quoi cela diffère-t-il de la loi de Gustafson ?
Amdahl maintient la taille du problème fixe et demande combien plus vite le même travail s'exécute sur N processeurs. Gustafson laisse le problème croître avec la machine.
Quelle est la formule de la loi d'Amdahl ?
L'accélération vaut un divisé par la fraction séquentielle plus la fraction parallèle répartie entre les processeurs. Avec 0,95 de parallèle et 8 processeurs, on obtient un sur 0,05 plus 0,95 divisé par 8, soit environ 5,93.
Que mesure l'efficacité parallèle ?
C'est l'accélération divisée par le nombre de processeurs. Avec 5,93 fois sur 8 processeurs, elle vaut environ 0,74 : chaque processeur fournit à peu près les trois quarts de sa part idéale, et cette part baisse quand on en ajoute.
Mon programme réel atteindra-t-il cette accélération ?
En général, non. Le résultat est un plafond théorique pour une charge de travail fixe. Les caches, les verrous et le trafic mémoire dégradent les courbes réelles : prenez-le comme le meilleur cas à comparer avec vos mesures.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre 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)Exemple de requête
{
"parallel_fraction": 0.95,
"processors": 8
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.amdahls_law",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_processors | 1000000000000 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Contrat d'entrée, forme de la réponse et comportement d'erreur
Après validation, le moteur calcule la fraction série comme un moins P, le dénominateur d'Amdahl comme ce reste série plus P sur N, l'accélération comme un sur le dénominateur et l'efficacité comme accélération sur N. Lorsque P vaut un, la limite série n'est pas bornée, si bien que cette clé est omise plutôt qu'émise comme null. Exemple : P égal à 0.95 et N égal à huit donne une accélération d'environ 5.93, une efficacité d'environ 0.74 et une limite série de vingt. C'est un oracle d'accélération théorique sous le modèle à charge fixe d'Amdahl, non une mesure de votre binaire ni un calculateur d'accélération mise à l'échelle de Gustafson. Envoyez par POST un corps JSON avec deux champs obligatoires. parallel_fraction est la fraction parallélisable P, un nombre fini de zéro à un inclus ; envoyez 0.95 pour quatre-vingt-quinze pour cent, jamais quatre-vingt-quinze. Les alias p, parallelizable_fraction et f sont acceptés. processors est le nombre de processeurs N, un entier de un à un billion. Les alias n, cores et n_processors sont acceptés. Les champs manquants, les valeurs non finies, les nombres de processeurs non entiers, N inférieur à un, N au-dessus du maximum publié et une fraction parallélisable hors de zéro à un échouent avec invalid_input en nommant le champ et ne sont pas facturés. Le corps JSON répète parallel_fraction et processors, puis renvoie serial_fraction, speedup, efficiency et une chaîne formula qui reformule S de N égal à un sur un moins P plus P sur N. Lorsque P est strictement inférieur à un, il renvoie aussi serial_limit, la borne asymptotique un sur un moins P.
Où un calculateur de la loi d'Amdahl gagne sa place
Utilisez l'API lorsqu'un script, un bac à sable d'entretien, un carnet d'architecture ou une vérification d'intégration continue a besoin d'un JSON stable pour de nombreux couples (P, N) sous un même contrat. Chaque requête réussie est un article facturable à $0.002 ; une validation en échec ne consomme pas le solde. La plage de processeurs publiée maintient l'évaluation sous forme fermée dans des doubles IEEE-754 ordinaires tout en couvrant toute machine pratique que l'on dimensionnerait à la main. Branchez le endpoint sur des tutoriels de calcul parallèle, des planificateurs de capacité, des revues d'architecture ou des oracles d'entretien de programmation où vous préférez l'identité exacte d'Amdahl à des tableaux anecdotiques d'accélération qui masquent le reste série.
Cas d'intégration
Enseignement du calcul parallèle
Offrez aux étudiants un oracle déterministe pour S(N)=1/((1-P)+P/N), y compris les cas P=0, P=1 et la limite série, sans déployer un profileur.
Questions techniques
Quelle est la formule de la loi d'Amdahl pour l'accélération ?
Envoyez parallel_fraction P dans [0, 1] et processors N comme entier ≥ 1. L'API renvoie S(N)=1/((1-P)+P/N), plus la fraction série 1-P et l'efficacité S/N.
Qu'est-ce que la limite série renvoyée par le calculateur ?
serial_limit vaut 1/(1-P), l'accélération maximale lorsque N tend vers l'infini. Elle est omise lorsque P=1 car un programme pleinement parallèle n'a pas de borne série.
Combien coûte le calculateur de la loi d'Amdahl ?
L'outil du navigateur est gratuit. Les requêtes API utilisent un solde KIT prépayé à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.