Calcula la aceleración real según la fracción paralela, los núcleos que exige un objetivo y los que pide una tasa de peticiones, con el techo de Amdahl.
Indica qué parte del trabajo se ejecuta en paralelo y cuántos núcleos tienes. Obtendrás la aceleración, la eficiencia por núcleo y el techo que ningún número de núcleos puede superar.
Aceleración para cada número de núcleos y fracción paralela, calculada a partir de la ley. Los encabezados de columna coinciden con la tabla publicada en el Introduction to Parallel Computing Tutorial del LLNL.
| Núcleos | P = 50 % | P = 90 % | P = 95 % | P = 99 % |
|---|---|---|---|---|
| 10 | 1,81 | 5,26 | 6,89 | 9,17 |
| 100 | 1,98 | 9,17 | 16,80 | 50,25 |
| 1000 | 1,99 | 9,91 | 19,62 | 90,99 |
| 10.000 | 1,99 | 9,99 | 19,96 | 99,01 |
| 100.000 | 1,99 | 9,99 | 19,99 | 99,90 |
También podrías encontrar útiles estas calculadoras
Cuántos usuarios admite un servidor y qué lo limita
La máquina que necesitan N usuarios, y cuántas
Calcula la RAM óptima para tu PC, estación de trabajo o servidor
Descubre qué pieza limita tu PC, medida en fps
Añadir núcleos deja de servir mucho antes de que se acabe el presupuesto, y la ley de Amdahl dice exactamente dónde. Indica qué parte de tu trabajo se ejecuta en paralelo y esta calculadora te da la aceleración real con cualquier número de núcleos, el techo que ninguna máquina puede superar y los núcleos que exige un objetivo; o te dice sin rodeos que ese objetivo es inalcanzable. Dos modos de dimensionado convierten una carga medida en un número de núcleos con la ley de utilización, mostrando al lado lo que cuesta cada margen elegido.
Divide un programa en la parte que puede ejecutarse en muchos núcleos a la vez (la fracción paralela P) y la que no (la fracción serie, 1 − P). Añadir núcleos solo acorta la primera; la segunda tarda lo mismo en un núcleo que en mil. Así que la aceleración está acotada por 1 ÷ (1 − P) por mucho hardware que compres. Con P = 0,95 ese límite es 20×, y llegar siquiera a 19× exige cientos de núcleos. Por eso un número de núcleos elegido a partir de una etiqueta de carga, y no de una fracción paralela medida, suele estar mal en ambos sentidos.
Ley de Amdahl
Un ingeniero con un trabajo paralelo al 95 % consulta el techo, ve 20× y descubre que 64 núcleos ya llegan a 15,4×: el 77 % de todo lo que podría dar un hardware ilimitado.
A un equipo le piden que un servicio paralelo al 60 % vaya el doble de rápido. El techo es 2,5× y ya están en 2,1×, así que la respuesta es subir P, no comprar hardware.
Un ingeniero de plataforma convierte 500 peticiones por segundo con 40 ms de CPU cada una en un número de núcleos a la utilización elegida, con el coste en cola de esa elección a la vista.
Una base de datos al 92 % se convierte en demanda de CPU y se redimensiona a un objetivo, que es la misma aritmética al revés.
La misma respuesta se da en milinúcleos, que es la unidad que toma realmente una petición de contenedor.
Un objetivo por encima de 1 ÷ (1 − P) no se compra a ningún precio. Conocer el techo antes de comprar vale más que cualquier número de núcleos recomendado.
La aceleración por núcleo baja de forma constante a medida que sube N. La tabla muestra dónde deja de compensar cada núcleo extra, con tus propias cifras.
«Base de datos» y «servidor web» no tienen fracción paralela; los programas sí. Los dos modos de dimensionado toman lo que puedes medir de verdad.
La utilización objetivo no es un estándar que publique nadie. La página la toma como dato y muestra los núcleos y la espera en cola que cuesta cada opción.
SMT expone dos hilos de hardware por núcleo físico. La página informa de ambos y nunca presenta el número de hilos como rendimiento adicional.
Núcleos físicos para una máquina, hilos de hardware para un planificador y milinúcleos para una petición de Kubernetes: la misma respuesta en las tres.
Depende de dos cosas que puedes medir: cuánta CPU consume tu trabajo y qué parte puede ejecutarse en paralelo. Para un servicio, multiplica la tasa de peticiones por el tiempo de CPU que cuesta una petición — 500 peticiones por segundo a 40 ms cada una son 20 núcleos de demanda — y divide por la utilización en la que quieras estar. Para un solo programa lo decide la fracción paralela: pasado cierto número de núcleos, los adicionales apenas devuelven nada, y esta calculadora muestra exactamente dónde está ese punto para tu P.
Dice que la aceleración que se obtiene al paralelizar un programa está limitada por la parte que sigue siendo serie. Con P como fracción paralela y N núcleos, aceleración = 1 ÷ ((1 − P) + P ÷ N). Al crecer N, el segundo término se desvanece y la aceleración se acerca a 1 ÷ (1 − P): un techo duro fijado por completo por la parte serie.
Porque solo se acelera la parte paralela. Con P = 0,90, ocho núcleos dan 4,71× y dieciséis dan 6,40×: el doble de hardware para un 36 % más de velocidad. La décima parte serie del trabajo tarda lo mismo en ambos casos, y crece como proporción del tiempo total a medida que todo lo demás se encoge.
1 ÷ (1 − P). Con P = 0,50 es 2×; con 0,90 es 10×; con 0,95 es 20× y con 0,99 es 100×. El tutorial de computación paralela del LLNL lo resume así: puedes pasarte la vida logrando que el 95 % de tu código sea paralelo y nunca superarás 20×, uses los procesadores que uses.
Ejecútalo en un núcleo y en N núcleos, y anota ambos tiempos. La aceleración medida S da P = (1 − 1 ÷ S) ÷ (1 − 1 ÷ N), que es el planteamiento de Karp–Flatt al revés. Un perfilador también sirve: todo lo que se ejecuta mientras solo hay un hilo ocupado pertenece a la fracción serie.
Dos, en todas las implementaciones habituales de multihilo simultáneo: Hyper-Threading de Intel y SMT de AMD exponen dos hilos de hardware por núcleo físico. Son ranuras de planificación, no el rendimiento de dos núcleos; la ganancia real varía según la carga y en algunas puede ser negativa. Esta calculadora informa del número de hilos como un recuento, nunca como un multiplicador de rendimiento.
Normalmente no. Kubernetes define su propia unidad con precisión: una unidad de CPU es un núcleo físico o un núcleo virtual, según el nodo. En la mayoría de nubes públicas una vCPU es un hilo de hardware, así que dos vCPU comparten un núcleo físico. Si dimensionas en núcleos físicos y despliegas en vCPU, comprueba a qué se refiere tu proveedor antes de dividir o multiplicar nada.
Dividiendo entre 1.000. Kubernetes escribe 0,1 CPU como 100m, que se lee como cien milicpu o milinúcleos, y ambas formas significan lo mismo. El valor más fino que acepta es 1m, es decir 0,001 CPU: 0,5m no es una petición válida. Esta calculadora da cada resultado de dimensionado tanto en milinúcleos como en núcleos.
Ningún organismo de normalización publica una cifra, y por eso esta página la toma como dato en lugar de imponer una. El equilibrio es concreto: para una cola única, el tiempo medio de respuesta es el tiempo de servicio ÷ (1 − utilización), así que el 70 % cuesta unas 3,3× el tiempo de servicio y el 90 % unas 10×. El tráfico en picos, la capacidad de conmutación por error y el trabajo en segundo plano salen todos del mismo margen.