Ideas clave
Trata el entorno de ejecución de .NET como un aliado, no como un lastre para el rendimiento.
Que el código sea administrado no significa que sea lento. .NET ofrece servicios como la recolección de basura, la seguridad de tipos y la compilación justo a tiempo, pero sus costes suelen ser menores de lo que se supone. El autor sostiene que el mal diseño de las aplicaciones, las estructuras de datos inadecuadas y la codificación ineficiente son causas más frecuentes que el entorno de ejecución. El código administrado incluso puede ser beneficioso: la asignación rápida, la compactación del montón y la ubicación del código pueden favorecer a las aplicaciones. El código nativo se justifica cuando lo exige una necesidad real, como el acceso directo al hardware o el control de la disposición de la memoria, no solo porque se dé por hecho que es más rápido.
Optimiza para el entorno de ejecución. El CLR tiene reglas y expectativas, sobre todo en lo relativo a la vida útil de los objetos, la asignación de memoria y la concurrencia. El código que se ajusta a esas reglas puede conservar la seguridad y la productividad de .NET y, a la vez, ofrecer un alto rendimiento. La pregunta útil no es si el código administrado tiene sobrecostes, sino si estos importan en la carga de trabajo medida.
El argumento más sólido a favor del código administrado no es que sus costes desaparezcan, sino que el coste total de ingeniería incluye los defectos, la depuración y el mantenimiento, no solo el número de instrucciones. Esto se asemeja a la distinción entre optimización local y optimización del sistema: un pequeño coste del entorno de ejecución puede compensarse con menos errores de memoria y un desarrollo más sencillo. La matización es importante. El comportamiento del entorno de ejecución cambia según la versión y el hardware, así que ni afirmar que .NET es rápido ni afirmar que es lento puede sustituir las pruebas en el entorno de despliegue real.
Fija objetivos medibles y optimiza después la ruta más lenta que tenga consecuencias.
Empieza por fijar un objetivo. Un requisito como «que responda bien» no ofrece al equipo un límite que pueda comprobar. Un objetivo concreto, como mantener por debajo de 20 milisegundos una operación de la interfaz de usuario, puede orientar la implementación y la verificación. Las métricas también deben especificar las condiciones: medir la memoria residente bajo una carga máxima determinada es más útil que establecer un límite de memoria sin explicar. El autor relata el caso de un equipo de servidores que seguía los bytes privados y descubrió que gran parte de esa memoria se había paginado. Al cambiar a la memoria residente, aclararon cuál era el recurso que realmente estaba en cuestión.
Mide antes de cambiar el código. Usa perfiles y pruebas de rendimiento para localizar el cuello de botella, y prioriza después la arquitectura y los algoritmos antes que los retoques mínimos al código. La ley de Amdahl explica por qué: acelerar una fracción pequeña del trabajo total impone un límite estricto a la mejora global. Las pruebas de rendimiento requieren calentamiento, compilaciones Release, aislamiento y suficientes muestras para tener en cuenta el ruido.
Esto es ingeniería del rendimiento entendida como control por retroalimentación: especificar el estado deseado, observar el sistema, ajustarlo y volver a observarlo. La medición elegida determina lo que ve el equipo, así que un indicador indirecto puede generar una falsa sensación de seguridad. Los bytes privados y la memoria residente, por ejemplo, responden a preguntas distintas. También importan los percentiles, porque los promedios pueden ocultar pausas intermitentes. Las pruebas de rendimiento sirven para aislar causas, pero el comportamiento en producción incluye contención, E/S y variaciones de carga que una microprueba pequeña excluye deliberadamente.
Haz que los objetos comunes tengan una vida corta y reutiliza los búferes grandes.
Asignar memoria es barato; que los objetos sobrevivan sale caro. El recolector de basura (GC) asigna rápidamente la mayoría de los objetos pequeños en la generación 0, la región más joven del montón. Los objetos que siguen siendo accesibles cuando se produce una recolección pueden ascender a generaciones más antiguas, cuyas recolecciones son más costosas. La regla práctica del libro es dejar que los objetos temporales desaparezcan pronto y reutilizar los que, de forma natural, sobreviven a varias recolecciones. Los objetos grandes, normalmente matrices, pasan al montículo de objetos grandes (Large Object Heap, LOH) al alcanzar unos 85.000 bytes y se recolectan junto con la generación 2, por lo que las asignaciones grandes repetidas resultan especialmente problemáticas.
Un ejemplo de producción permite apreciar el coste. Un servidor descubrió que los búferes de MemoryStream representaban casi el 90 % de las asignaciones y que el GC consumía alrededor del 25 % del tiempo de CPU. Un reemplazo basado en un grupo de objetos redujo en un 99 % las asignaciones de objetos grandes y dejó el tiempo del GC por debajo del 1 %. Los grupos deben tener límites y restablecer los objetos de forma segura; de lo contrario, la reutilización puede convertirse en una fuga de memoria encubierta.
La distinción clave está entre el volumen de asignaciones y la memoria viva. Un pico de objetos temporales puede ser relativamente inocuo si desaparecen antes de la recolección; una cantidad menor de objetos retenidos puede encarecerla, porque el recolector debe rastrearlos. Esto concuerda con el diseño de la gestión de memoria generacional. Sin embargo, agrupar objetos para reutilizarlos no siempre es mejor. Se sustituye la recuperación automática por una gestión explícita de la vida útil, la sincronización y la lógica de restablecimiento. Un grupo solo justifica su complejidad cuando el perfil de rendimiento identifica la reutilización como una mejora significativa.
Mantén todos los hilos productivos sustituyendo las esperas por flujos asíncronos.
Esperar consume capacidad. Un hilo bloqueado a la espera de la red, el disco o el resultado de una tarea no puede realizar trabajo útil. Bajo carga, los trabajadores bloqueados del grupo de hilos pueden hacer que el grupo añada más hilos, lo que incrementa la sobrecarga de planificación y de los cambios de contexto. Para la E/S, usa API verdaderamente asíncronas que devuelvan tareas, en lugar de envolver lecturas síncronas en Task.Run. El sistema operativo puede completar la E/S asíncrona sin reservar un hilo trabajador para que permanezca inactivo.
Usa las tareas con disciplina. La Biblioteca de paralelismo de tareas (Task Parallel Library, TPL) planifica el trabajo mediante el grupo de hilos y admite continuaciones, cancelación y gestión de errores. La sintaxis async y await facilita seguir el código basado en tareas, pero no hace que bloquear sea inocuo. Evita llamar rutinariamente a Wait o acceder a un resultado antes de que esté listo. En los bucles paralelos, asigna estado local a cada trabajador y combina los resultados por lotes. El ejemplo del libro redujo un bucle de mil millones de elementos de unos 108 segundos a menos de uno, al dividir el trabajo y evitar una actualización compartida en cada iteración.
La asincronía y el paralelismo resuelven problemas distintos. La asincronía libera un hilo mientras el trabajo espera un evento externo; el paralelismo distribuye los cálculos entre procesadores. Mezclarlos sin cuidado puede añadir sobrecarga de planificación y coordinación de tareas sin aumentar el rendimiento. La teoría de colas explica por qué bloquear resulta especialmente perjudicial cuando el sistema se acerca a su capacidad: si los trabajadores están ocupados, las nuevas tareas esperan más y añadir trabajadores puede aumentar la contención en lugar de la tasa de servicio. El diseño adecuado depende de si la carga está limitada por la E/S, la CPU o un recurso compartido saturado.
Examina qué ejecutan las abstracciones antes de colocarlas en rutas críticas.
Una sintaxis práctica puede ocultar trabajo real. Una llamada a una API puede asignar memoria, encajonar un valor, invocar reflexión o realizar una operación de despacho adicional, aunque el código fuente parezca sencillo. En una prueba de rendimiento, una transformación con LINQ tardó unas 20 veces más que un bucle directo y asignó memoria. En el ejemplo, invocar un método mediante reflexión fue unas 100 veces más lento que llamar a través de una interfaz conocida. Estas proporciones no son universales, pero muestran por qué conviene investigar las rutas críticas.
Examina las capas que se generan. Usa herramientas de creación de perfiles para identificar los métodos costosos y, después, examina el IL o la implementación del marco de trabajo para comprender el motivo. Entre los ejemplos están evitar conversiones repetidas de cadenas a mayúsculas o minúsculas para compararlas, usar TryParse en lugar de Parse cuando se esperan entradas no válidas y no usar excepciones como flujo de control habitual. Conserva las abstracciones cuando aporten claridad; elimínalas o sustitúyelas solo si las mediciones muestran que su coste importa.
Esta es una forma útil de comprender las abstracciones. La lección no es que las herramientas expresivas sean malas, sino que sus costes pueden incluir asignaciones, operaciones de despacho y copias de datos que no se ven en el punto de llamada. Las optimizaciones del compilador y del entorno de ejecución pueden eliminar algunos de esos costes, por lo que no es fiable guiarse solo por sospechas sobre el código fuente. Una revisión sensata del rendimiento pregunta tanto qué aporta la abstracción como qué trabajo genera. Los mejores sistemas conservan la claridad de alto nivel fuera de las rutas críticas y concentran los detalles de implementación cuidadosamente optimizados allí donde las pruebas lo justifican.
Elige disposiciones de datos que se adapten al procesador, no solo a la API.
La representación determina la velocidad. Una instancia de clase incluye la sobrecarga de un objeto y se accede a ella mediante una referencia. Una estructura puede almacenar valores de forma contigua, lo que reduce el uso de memoria y mejora la localidad de caché, especialmente en matrices grandes. El libro compara un millón de valores de 16 bytes: una matriz de estructuras ocupa unos 16 MB, mientras que los objetos de clase separados y sus referencias ocupan unos 28 MB en un proceso de 32 bits y más de 40 MB en uno de 64 bits. Las estructuras no sustituyen a las clases en todos los casos: copiar valores grandes puede anular la ventaja y las estructuras mutables pueden resultar incómodas.
Elige las colecciones según su comportamiento. Las matrices y List<T> favorecen el acceso secuencial compacto. Un diccionario ofrece búsquedas de tiempo constante en promedio, mientras que las estructuras ordenadas intercambian memoria y costes de inserción por acceso ordenado. Preasigna capacidad a las colecciones cuando se conozca la capacidad prevista. Evita las colecciones no genéricas heredadas, que requieren conversiones y pueden encajonar tipos de valor. En las cargas de trabajo numéricas adecuadas, los vectores SIMD pueden procesar varios valores con una sola instrucción, pero el ejemplo muestra que no todos los algoritmos se benefician.
La disposición de la memoria conecta el diseño de software con la arquitectura del procesador. Un programa puede realizar menos operaciones abstractas y, aun así, ejecutarse más despacio si sus datos provocan fallos de caché y seguimiento de punteros. Por eso una matriz compacta de valores puede superar en rendimiento a una colección de objetos asignados individualmente. Aun así, la optimización orientada a los datos debe preservar la semántica: las estructuras se copian por valor y cambiar una representación pública puede complicar las API o la corrección. Del mismo modo, SIMD favorece las operaciones regulares e independientes, no simplemente el código que parece matemático. Es esencial comparar el rendimiento con tamaños de datos realistas.
Considera el inicio como un presupuesto de rendimiento aparte de la velocidad en régimen estable.
Las primeras llamadas tienen un coste adicional. El compilador justo a tiempo (JIT) convierte el lenguaje intermedio de un método en código máquina cuando el método se ejecuta por primera vez. Ese coste de inicio importa en los servicios con plazos estrictos para la primera solicitud, aunque a muchas aplicaciones les importa más el rendimiento en régimen estable. Cargar ensamblados y tipos también puede ser lento, así que no des por hecho que el JIT es la causa de un inicio prolongado.
Elige una solución a partir de las pruebas. El calentamiento guiado por perfiles puede preparar en segundo plano el código de uso frecuente. NGEN crea imágenes nativas administradas por adelantado, lo que reduce el trabajo del JIT, pero puede aumentar el tamaño de los archivos y sacrificar parte de la localidad o de la optimización entre ensamblados. El calentamiento explícito puede ser útil cuando el tráfico real no tolera retrasos durante el primer uso. El libro recomienda medir qué métodos consumen tiempo del JIT antes de elegir entre estas opciones y probar por separado la ruta de inicio y el rendimiento habitual.
El rendimiento de inicio y el rendimiento en régimen estable corresponden a experiencias distintas para el usuario, y optimizar uno puede perjudicar al otro. Es un principio más general de los sistemas: los promedios calculados a lo largo de la vida de un proceso pueden ocultar el coste de la primera solicitud, que es el que más notan los usuarios. Un presupuesto de inicio independiente hace visible esa disyuntiva. La compilación anticipada puede trasladar el trabajo a un momento anterior, en lugar de eliminarlo, mientras que el calentamiento puede consumir recursos antes de atender el tráfico. La elección adecuada depende del despliegue, del patrón de tráfico y de si la limitación principal es la latencia de inicio o la eficiencia sostenida.
Convierte el conocimiento sobre rendimiento en pruebas automatizadas, telemetría y reglas de código.
Haz del rendimiento una práctica de equipo. El libro recomienda establecer objetivos explícitos, realizar pruebas de rendimiento repetibles, centrar las revisiones de código en las rutas críticas y recopilar métricas de forma automatizada. Las regresiones de rendimiento deben tomarse tan en serio como los fallos funcionales. La supervisión en producción puede revelar comportamientos que no aparecen en entornos de prueba pequeños, mientras que las comparaciones controladas ayudan a evaluar una versión frente a su predecesora.
Usa las pruebas adecuadas en cada escala. Los contadores de rendimiento siguen métricas continuas, como la actividad de la CPU, la memoria y el GC. Event Tracing for Windows (ETW) registra eventos detallados que herramientas como PerfView pueden analizar en el CLR, el sistema operativo y la aplicación. Los analizadores estáticos pueden señalar patrones como el encajonamiento o el uso de API que tienen alternativas más seguras. La automatización reduce la dependencia de que alguien se acuerde de crear perfiles, y los datos históricos permiten verificar las afirmaciones de mejora.
El paso de la experiencia individual a la infraestructura tiene consecuencias importantes: un sistema de medición puede detectar regresiones incluso cuando no está presente el especialista en rendimiento original. Esto se asemeja a la observabilidad en otros sistemas de ingeniería, donde la telemetría convierte estados internos ocultos en señales que permiten diagnosticar problemas. Sin embargo, más datos no siempre son mejores. La instrumentación tiene un coste, los paneles pueden fomentar la optimización de indicadores indirectos y las pruebas ruidosas pueden minar la confianza. Un conjunto reducido de métricas pertinentes para la toma de decisiones, vinculado a cargas de trabajo realistas y a comparaciones automatizadas, vale más que un volumen impresionante de contadores sin analizar.
Optimiza la latencia de cola y los límites de recursos, no solo los promedios.
También importan las experiencias más lentas. Un servicio puede tener un promedio respetable y, aun así, una proporción significativa de solicitudes sufrir retrasos prolongados. El libro lo ilustra con las pausas de recolección de basura: una muestra con un promedio de 17 milisegundos tenía una pausa en el percentil 95 de 50 milisegundos. Los percentiles indican el valor por debajo del cual cae una proporción determinada de las observaciones, por lo que son útiles en sistemas sensibles a la disponibilidad. El equipo debe recopilar suficientes muestras para el percentil que le interesa; unas pocas decenas de observaciones no permiten hacer afirmaciones fiables sobre los extremos de la distribución.
Define también la carga de trabajo. Los objetivos de memoria deben especificar la métrica y las condiciones de funcionamiento —por ejemplo, la memoria residente con la tasa máxima de solicitudes—, en lugar de limitarse a decir que la memoria debe mantenerse por debajo de una cifra. Los límites de recursos incluyen la CPU, la memoria, la E/S y la sincronización. Sin el contexto de la carga de trabajo, es difícil interpretar un resultado, compararlo o convertirlo en una decisión de ingeniería.
El comportamiento de cola suele surgir de interacciones, no de una única función lenta: la recolección de basura, las colas, la E/S y la contención pueden combinarse y retrasar una minoría de las solicitudes. Los percentiles ponen de manifiesto esa experiencia desigual, mientras que los promedios describen la eficiencia general. Ninguna de las dos estadísticas basta por sí sola. Los percentiles extremos requieren muestras grandes y condiciones de medición estables, y perseguir la última fracción de un percentil puede costar más de lo que justifica el impacto en los usuarios. Por eso es importante que el libro insista en que los requisitos del negocio determinen el objetivo: no es una excusa para ignorar las pruebas técnicas.
Análisis
Este libro se entiende mejor como una guía práctica para razonar sobre el rendimiento en sistemas .NET administrados que como un catálogo de trucos de codificación milagrosos. Su argumento central es que la sobrecarga de un entorno de ejecución es solo una parte del rendimiento de una aplicación y, por lo general, no es lo primero que debe sospecharse. A menudo pesan más la arquitectura, los algoritmos, los patrones de asignación, la representación de los datos y los bloqueos. Este énfasis da un orden coherente a los capítulos técnicos: establecer objetivos medibles, localizar el cuello de botella, comprender el comportamiento del entorno de ejecución que subyace a él y cambiar la parte más pequeña que tenga consecuencias.
La idea más potente que se repite es que el rendimiento es una propiedad de las interacciones. La vida útil de los objetos influye en la recolección de basura; los patrones de asignación condicionan la latencia; la sincronización afecta al grupo de hilos; las abstracciones determinan el código generado y el movimiento de datos. Por eso, optimizar un método de forma aislada puede producir una mejora local y una pérdida en el sistema. Las reiteradas recomendaciones del libro de crear perfiles y realizar pruebas de rendimiento no son simples consignas de cautela. Son el método para distinguir las explicaciones plausibles de las causas reales.
Sus ejemplos concretos hacen visibles costes que de otro modo pasarían inadvertidos. El caso de MemoryStream relaciona los rastros de asignación con una gran reducción del tiempo del GC. El bucle dividido en partes muestra cómo la sincronización puede imponerse al cálculo útil. Las comparaciones de LINQ y reflexión demuestran que una sintaxis sencilla puede ocultar una cantidad considerable de trabajo. Estos ejemplos resultan más convincentes cuando se consideran demostraciones de mecanismos, no promesas transferibles de mejoras exactas en velocidad.
El libro también presenta el rendimiento como una responsabilidad organizativa: las métricas automatizadas, las pruebas de regresión, las revisiones de código y el análisis estático reducen la dependencia de una sola persona experta. Es un valioso paso de la optimización heroica al mantenimiento continuo. Una limitación es su antigüedad. El texto describe determinadas versiones de .NET Framework, del JIT y de las herramientas, y las API han evolucionado desde su publicación. Algunos consejos concretos y resultados de pruebas de rendimiento quizá ya no sean aplicables sin cambios. Su aportación duradera es el hábito de investigar: definir la carga de trabajo, medir los resultados pertinentes, inspeccionar la implementación y conservar la claridad salvo que los datos justifiquen la complejidad.
Resumen de reseñas
Writing High-Performance .NET Code recibe críticas positivas, con una valoración media de 4,31/5. Los lectores valoran sus consejos prácticos para optimizar aplicaciones .NET y destacan su utilidad para programadores avanzados de C#. Se elogia la variedad de temas relacionados con el rendimiento que aborda, entre ellos la recolección de basura y JIT. Algunos lo consideran esencial para sistemas donde el rendimiento es crítico, mientras que otros señalan que no todas las aplicaciones necesitan ese nivel de optimización. Unos pocos lectores esperaban análisis más profundos, dada la trayectoria del autor en Microsoft, pero, en general, se considera un recurso sólido para desarrolladores de .NET.
También leyeron
Glosario
Common Language Runtime (CLR)
Entorno de ejecución administradoEl entorno de ejecución que ejecuta código administrado de .NET y proporciona servicios como la recolección de basura, la carga de tipos y la compilación justo a tiempo. El código de la aplicación se ejecuta como instrucciones de máquina en este entorno. Su comportamiento y configuración afectan al rendimiento, por lo que los desarrolladores deben entender cómo interactúan con él sus decisiones sobre asignación de memoria, subprocesos y API.
montículo de objetos grandes (Large Object Heap, LOH)
Montículo para asignaciones grandesMontículo administrado utilizado para objetos cuyo tamaño alcanza o supera el umbral de objetos grandes del entorno de ejecución, aproximadamente 85 000 bytes en las versiones descritas en el libro. Los objetos grandes se gestionan de forma distinta a las asignaciones pequeñas generacionales y se recolectan con la generación 2. El montículo no se compacta automáticamente de la misma manera que el montículo de objetos pequeños, por lo que las asignaciones grandes repetidas pueden causar fragmentación.
Event Tracing for Windows (ETW)
Sistema de trazado de eventos de WindowsRecurso del sistema operativo para producir y recopilar eventos de diagnóstico tipados de aplicaciones, del CLR y de componentes de Windows. Los eventos pueden filtrarse por proveedor, nivel y palabras clave y, después, analizarse junto con pilas y datos de temporización. El libro utiliza ETW como base para investigaciones detalladas del rendimiento y para la instrumentación personalizada de aplicaciones.
Biblioteca de paralelismo de tareas (Task Parallel Library, TPL)
API de concurrencia basada en tareasBiblioteca de .NET para programar trabajo y coordinar operaciones asíncronas mediante objetos Task. Utiliza el grupo de subprocesos administrado y proporciona continuaciones, cancelación, bucles paralelos y otras funciones de coordinación. Las tareas pueden ayudar a evitar la gestión manual de subprocesos, pero bloquearse a la espera de sus resultados o programar demasiadas tareas diminutas puede desperdiciar recursos.
NGEN
Compilación administrada anticipadaNative Image Generator crea por adelantado imágenes nativas a partir de ensamblados de .NET, lo que reduce la cantidad de compilación justo a tiempo necesaria durante la ejecución. El código resultante sigue siendo administrado y se ejecuta bajo el CLR. NGEN puede mejorar el inicio, pero aumentar el uso de disco y perder algunas optimizaciones disponibles en la compilación JIT en tiempo de ejecución.
JIT multinúcleo (Multicore JIT)
Compilación en segundo plano guiada por perfilesOptimización de inicio de .NET que registra los métodos utilizados durante la ejecución de una aplicación y emplea ese perfil en los inicios posteriores para compilar en un subproceso independiente el código que probablemente se necesite. Su objetivo es reducir las demoras del primer uso y conservar las ventajas de la compilación JIT en tiempo de ejecución. Las aplicaciones con modos de ejecución distintos pueden utilizar perfiles separados.
ley de Amdahl
Límite a la aceleración totalPrincipio que describe cómo la parte de un programa que permanece sin cambios limita la mejora máxima que se puede lograr al optimizar o paralelizar otra parte. Si una operación lenta representa solo una pequeña proporción del tiempo total de ejecución, acelerarla drásticamente produce una mejora global modesta. Ayuda a priorizar el trabajo en los cuellos de botella que afectan de manera sustancial al rendimiento total.
encajonamiento (boxing)
Envolver un tipo de valor en el montónConversión de un tipo de valor, como un entero o una estructura, en una referencia a objeto. El entorno de ejecución crea un objeto en el montón y copia en él el valor. El encajonamiento repetido añade asignaciones y presión sobre la recolección de basura, y también puede perjudicar la localidad. Puede producirse implícitamente cuando se pasan tipos de valor a API que esperan un objeto o una interfaz.
Descargar PDF
Descargar EPUB
.epub es ideal para leer libros electrónicos en teléfonos, tabletas y lectores electrónicos.