ForHosting KIT · Outils pour développeurs

Calculateur de la loi d’Amdahl et limite d’accélération

La loi d’Amdahl estime l’accélération théorique maximale lorsqu’une partie d’un programme peut s’exécuter en parallèle tandis que le reste demeure séquentiel.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Saisissez la fraction parallélisable et le nombre de processeurs pour obtenir l’accélération prévue, leur efficacité et la part du temps accéléré encore consacrée au travail séquentiel. Le calculateur indique aussi la limite asymptotique imposée par cette partie, afin que vous puissiez déterminer s’il convient d’ajouter des processeurs ou d’optimiser d’abord le code séquentiel.

Ce que mesure la loi d’Amdahl

La loi d’Amdahl sépare le temps d’exécution initial en une fraction parallélisable et une fraction séquentielle. Si p est parallélisable et si N processeurs se répartissent parfaitement ce travail, le temps normalisé devient (1 − p) + p/N. L’accélération théorique maximale est l’inverse de ce temps. Ce calculateur applique directement cette équation en supposant un ordonnancement idéal : le travail parallèle est réparti équitablement, les processeurs n’ajoutent aucun coût de communication et la partie séquentielle ne bénéficie pas de ressources supplémentaires. Le résultat constitue donc une borne supérieure, et non une prévision de benchmark. Une réalisation concrète peut être moins rapide à cause de la synchronisation, des conflits mémoire, du lancement des tâches, du déséquilibre de charge et des transferts de données. Cette borne reste utile pour vérifier la plausibilité d’une mesure et évaluer la marge d’amélioration. Saisissez la fraction parallèle sous forme décimale : 95 pour cent devient 0.95.

Interpréter le goulot et la limite de montée en charge

La fraction séquentielle vaut un moins la fraction parallèle et fixe le plafond à long terme. Avec 95 pour cent de travail parallèle, il reste 5 pour cent de travail séquentiel : même un nombre illimité de processeurs ne permet pas de dépasser une accélération de 20. Le champ d’accélération asymptotique indique ce plafond lorsqu’une partie séquentielle existe. La part du goulot séquentiel répond à une autre question : avec le nombre de processeurs choisi, quelle proportion du nouveau temps réduit reste séquentielle ? Cette proportion augmente souvent fortement avec les processeurs. Une section qui ne représentait que 5 pour cent du temps initial peut dominer après la répartition de la partie parallèle. L’efficacité parallèle correspond à l’accélération divisée par le nombre de processeurs. Lorsqu’elle baisse, chaque processeur supplémentaire apporte moins. Ces indicateurs révèlent ensemble les rendements décroissants de la mise à l’échelle forte et distinguent un manque de processeurs d’une contrainte fondamentalement séquentielle.

Exploiter le résultat pour planifier les performances

Commencez par un profil mesuré sur une charge représentative plutôt que par une estimation optimiste. Ne classez du temps comme parallélisable que si l’architecture de production permet réellement son exécution concurrente. Calculez ensuite plusieurs nombres de processeurs et comparez le gain supplémentaire au coût de l’infrastructure. Si doubler les processeurs modifie à peine le résultat, la fraction séquentielle indique déjà la priorité : optimisez le chemin séquentiel, changez d’algorithme, réduisez la coordination ou augmentez le travail indépendant par exécution. Le calcul est particulièrement utile avant une migration vers davantage de cœurs, de travailleurs, de GPU ou de nœuds distribués, car il évite de supposer une progression linéaire. Il sert aussi de référence dans les rapports de régression : comparez l’accélération mesurée au maximum théorique et analysez l’écart. La loi d’Amdahl concerne une charge fixe ; si la charge augmente avec les ressources, la loi de Gustafson répond à une autre question.

Cas d’usage

Planifier une optimisation multicœur

Estimez le meilleur gain possible avec le nombre de processeurs envisagé avant d’investir dans la parallélisation d’une charge fixe.

Expliquer les rendements décroissants

Montrez pourquoi ajouter des travailleurs apporte des gains toujours plus faibles lorsqu’une requête, un coordinateur ou une autre étape séquentielle reste inchangé.

Comparer théorie et benchmarks

Utilisez la borne théorique comme référence pour l’accélération mesurée et analysez les coûts d’ordonnancement, de communication ou de contention.

Questions fréquentes

Que signifie la fraction parallèle ?

Il s’agit de la part du temps initial qui peut être répartie entre les processeurs. Saisissez un nombre décimal compris entre 0 et 1.

Pourquoi parle-t-on d’accélération théorique maximale ?

L’équation suppose une répartition parfaite, sans coût de communication, synchronisation, lancement, contention ni ordonnancement. Le gain réel est généralement inférieur.

Qu’est-ce que l’accélération asymptotique ?

C’est le plafond lorsque le nombre de processeurs tend vers l’infini. Pour une fraction séquentielle s non nulle, il vaut 1/s.

Que montre la part du goulot séquentiel ?

Elle indique la part du temps accéléré occupée par le travail séquentiel avec le nombre de processeurs choisi et révèle quand celui-ci devient dominant.

Un seul processeur donne-t-il toujours une accélération de un ?

Oui. Dans le modèle idéal d’Amdahl, un processeur exécute les deux parties durant le temps normalisé initial ; accélération et efficacité valent donc un.

Combien coûte le calcul par API ?

Chaque requête API coûte $0.002. Le même calcul déterministe est disponible dans l’interface du navigateur.

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

POSThttps://api.kit.forhosting.com/dev/amdahl

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/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)

Exemple de requête

{
  "parallel_fraction": 0.95,
  "processors": 16
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.amdahl",
  "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

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

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.

Consulter la documentation complète du KIT →