Lei de Amdahl
Um programa 95% paralelo roda cerca de 5,93 vezes mais rápido com 8 processadores, não 8 vezes, e nunca passa de 20 vezes, por mais que você acrescente. Use para dimensionar um cluster ou rebater uma promessa de multiplicar por N antes de comprar hardware. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Fração paralela
- 0,95
- Processadores
- 8
- Fração serial
- 0,05
- Aceleração
- 5,9259259259
- Eficiência
- 0,7407407407
- Limite serial
- 20
A lei de Amdahl nomeia o teto que o trabalho serial restante impõe à aceleração paralela. Se uma fração P de um programa pode rodar de forma concorrente e o restante precisa ficar sequencial, acrescentar processadores nunca multiplica o tempo de execução por N. A aceleração teórica é um sobre um menos P mais P sobre N: o resto serial permanece no denominador por maior que N se torne. Esta calculadora da lei de Amdahl aceita a fração paralelizável e a contagem de processadores e então devolve o fator de aceleração, a fração serial, a eficiência paralela e o limite assintótico serial um sobre um menos P sempre que reste trabalho serial. A aritmética é uma identidade de forma fechada, plenamente determinística, sem simulação e sem modelo de linguagem. Serve para dimensionar um cluster, rebater uma afirmação ingênua de N vezes ou conferir uma curva de aceleração de livro antes de comprar hardware.
O que a lei de Amdahl mede e como se obtém o fator de aceleração
A lei de Amdahl é a observação de Gene Amdahl de 1967: o trabalho serial que sobra limita o quanto um programa inteiro pode ficar mais rápido, por mais processadores que se apliquem à parte paralela. Escreva P para a fração do tempo de relógio de um único processador que pode rodar de forma concorrente, e N para a contagem de processadores. A fração sequencial é um menos P.
Depois de dividir o trabalho paralelo em N partes, o tempo relativo passa a ser um menos P mais P sobre N, de modo que a aceleração teórica S de N é o recíproco dessa soma: um dividido por um menos P mais P sobre N. Quando P vale um, cada ciclo se paraleliza e a aceleração é igual a N. Quando P vale zero, a tarefa é puramente serial e a aceleração permanece um para qualquer N.
Entre esses extremos, a aceleração cresce com N mas achata em direção ao limite serial um sobre um menos P. Esse teto é o ponto da lei: um programa que é só cinco por cento serial nunca ultrapassa uma aceleração de vinte vezes, mesmo em um milhão de núcleos, porque os cinco por cento seriais continuam depois que o oceano paralelo foi fatiado até o infinito. A eficiência paralela é a aceleração dividida por N; ela cai conforme N cresce, salvo se P for exatamente um.
Esta calculadora avalia essas identidades de forma direta. Não é um profiler, nem um simulador de eventos discretos, nem o modelo de aceleração escalada de Gustafson, que formula outra pergunta ao fazer o problema crescer com a máquina. Se você conhece P por medição ou por uma estimativa de envelope que separa laços quentes e preparação, a fórmula de Amdahl dá a aceleração teórica que se deve esperar antes que efeitos de cache, contenção de locks ou tráfego NUMA piorem a curva real.
Onde uma calculadora da lei de Amdahl rende o investimento
Use a ferramenta do navegador quando estiver dimensionando um cluster, revisando uma afirmação de desempenho de que a aceleração acompanhará a contagem de núcleos, ou mostrando em aula por que noventa e cinco por cento paralelo ainda estanca em vinte vezes. Aumente N até a aceleração se aproximar do limite serial e pare de comprar núcleos que você não consegue colher.
Contraste o resultado com a lei de Gustafson se a carga crescer com a máquina; Amdahl mantém o tamanho do problema fixo, que é o limite conservador para lotes, compiladores e kernels científicos que não aumentam por mágica quando se acrescentam soquetes. Os resultados são plenamente determinísticos: os mesmos P e N sempre produzem o mesmo vetor de aceleração, de modo que você pode fixar exemplos em testes e materiais de aula. Não há modelo de linguagem, nem serviço externo de profiling, nem aleatoriedade.
Casos de uso
Dimensionamento de cluster e contagem de núcleos
Informe a fração paralelizável medida e percorra contagens de processadores até a aceleração teórica se aproximar do limite serial; então pare de comprar núcleos que você não consegue colher.
Checagens realistas em revisões de desempenho
Substitua uma afirmação ingênua de aceleração N vezes pelo limite de Amdahl, para que as revisões de arquitetura mostrem o resto serial em vez de uma curva linear sem teto.
Perguntas frequentes
O que acontece se a fração paralelizável ficar fora de 0 a 1?
P é uma fração do tempo de um único processador, então valores abaixo de 0 ou acima de 1 são rejeitados e não cobrados. Envie 0.95 para 95 por cento, não 95.
Em que isso difere da lei de Gustafson?
Amdahl mantém o tamanho do problema fixo e pergunta o quanto o mesmo trabalho fica mais rápido em N processadores. Gustafson deixa o problema crescer com a máquina.
Qual é a fórmula da lei de Amdahl?
A aceleração é um dividido pela fração sequencial mais a fração paralela dividida entre os processadores. Com 0,95 de parte paralela e 8 processadores, fica um sobre 0,05 mais 0,95 dividido por 8: cerca de 5,93 vezes.
O que a eficiência paralela indica?
É a aceleração dividida pelo número de processadores. Com 5,93 vezes em 8 processadores, a eficiência fica perto de 0,74: cada processador entrega uns três quartos do ideal, e essa parte cai quando você acrescenta mais.
Meu programa real vai chegar a essa aceleração?
Em geral, não. O resultado é um teto teórico para uma carga de trabalho fixa. Cache, travas e tráfego de memória pioram as curvas reais, então trate o número como o melhor caso para comparar com as suas medições.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"parallel_fraction": 0.95,
"processors": 8
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.amdahls_law",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_processors | 1000000000000 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Contrato de entrada, forma da resposta e comportamento de erro
Depois da validação, o motor calcula a fração serial como um menos P, o denominador de Amdahl como esse resto serial mais P sobre N, a aceleração como um sobre o denominador e a eficiência como aceleração sobre N. Quando P vale um o limite serial não é limitado, de modo que essa chave é omitida em vez de emitida como null. Exemplo: P igual a 0.95 e N igual a oito produz aceleração de cerca de 5.93, eficiência de cerca de 0.74 e um limite serial de vinte. É um oráculo de aceleração teórica no modelo de carga fixa de Amdahl, não uma medição do seu binário nem uma calculadora de aceleração escalada de Gustafson. Envie por POST um corpo JSON com dois campos obrigatórios. parallel_fraction é a fração paralelizável P, um número finito de zero a um inclusive; envie 0.95 para noventa e cinco por cento, nunca noventa e cinco. Os alias p, parallelizable_fraction e f são aceitos. processors é a contagem de processadores N, um inteiro de um até um trilhão. Os alias n, cores e n_processors são aceitos. Campos ausentes, valores não finitos, contagens de processadores não inteiras, N abaixo de um, N acima do máximo publicado e uma fração paralelizável fora de zero a um falham com invalid_input nomeando o campo e não são cobrados. O corpo JSON ecoa parallel_fraction e processors e então devolve serial_fraction, speedup, efficiency e uma cadeia formula que reafirma S de N igual a um sobre um menos P mais P sobre N. Quando P é estritamente menor que um também devolve serial_limit, o limite assintótico um sobre um menos P.
Onde uma calculadora da lei de Amdahl rende o investimento
Use a API quando um script, um sandbox de entrevista, um caderno de arquitetura ou uma verificação de integração contínua precisar de JSON estável para muitos pares (P, N) sob um mesmo contrato. Cada solicitação bem-sucedida é um item faturável a US$ 0,002; a validação falha não consome saldo. A faixa publicada de processadores mantém a avaliação de forma fechada dentro de doubles IEEE-754 ordinários e cobre toda máquina prática que se dimensionaria à mão. Ligue o endpoint a tutoriais de computação paralela, planejadores de capacidade, revisões de arquitetura ou oráculos de entrevista de programação em que se prefira a identidade exata de Amdahl a tabelas anedóticas de aceleração que escondem o resto serial.
Casos de integração
Ensino de computação paralela
Ofereça aos estudantes um oráculo determinístico para S(N)=1/((1-P)+P/N), inclusive os casos P=0, P=1 e o limite serial, sem montar um profiler.
Perguntas técnicas
Qual é a fórmula da lei de Amdahl para a aceleração?
Envie parallel_fraction P em [0, 1] e processors N como inteiro ≥ 1. A API devolve S(N)=1/((1-P)+P/N), mais a fração serial 1-P e a eficiência S/N.
O que é o limite serial devolvido pela calculadora?
serial_limit é 1/(1-P), a aceleração máxima quando N tende ao infinito. É omitido quando P=1 porque um programa plenamente paralelo não tem limite serial.
Quanto custa a calculadora da lei de Amdahl?
A ferramenta do navegador é gratuita. As solicitações à API usam saldo KIT pré-pago a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.