Añade y prueba kernels en una biblioteca de kernels de GPU con compilación JIT

## Prepara una instalación editable en la que editar un kernel lo recompile solo Usa una instalación editable que conserve las versiones existentes del entorno para el framework y el acelerador. Desactiva la resolución aislada de dependencias cuando pueda incorporar paquetes de ejecución incompatibles. Inicializa todos los submódulos fuente requeridos antes de compilar o realizar pruebas. Trata la compilación justo a tiempo como el ciclo de desarrollo predeterminado. Edita los archivos fuente del kernel, ejecuta una prueba específica y deja que el hash del código fuente active la recompilación. No reinstales el paquete después de cada edición del kernel, salvo que haya cambiado el propio código de empaquetado. Vacía la caché JIT solo cuando los artefactos obsoletos formen parte del diagnóstico. Usa paquetes de kernels precompilados solo cuando se requiera un primer uso más rápido o la distribución. Mantén los artefactos precompilados como opcionales durante el desarrollo normal. Establece explícitamente las arquitecturas objetivo cuando compiles para dispositivos distintos de la GPU local detectada. Limita los hilos del compilador y los trabajos de compilación paralelos según la memoria disponible. Estima la memoria total de compilación multiplicando los trabajos por los hilos del compilador y la demanda de cada hilo. No permitas que el tamaño de los parámetros de prueba agote innecesariamente la memoria del dispositivo. Instala la compatibilidad con perfiles solo cuando necesites mediciones precisas del hardware. Ejecuta el formateo y los ganchos del repositorio antes de la revisión. ## Escribe los archivos generados solo en espacios de trabajo con escritura, no en la instalación Representa cada cadena de herramientas de compilación mediante una interfaz común de especificación. Asigna a cada especificación un nombre único, una lista de fuentes, indicadores del compilador, indicadores del enlazador y arquitecturas compatibles. Usa una plantilla compartida de compilación y carga para coordinar la búsqueda en caché, el bloqueo, la compilación y la carga. Mantén explícito el ciclo de vida: intenta cargar desde la caché, compila cuando sea necesario y después carga el módulo compilado. Rechaza la compilación JIT cuando se haya establecido un indicador de desactivación y no exista un módulo válido en caché o precompilado. Nunca escribas archivos generados en los directorios de paquetes instalados, ya que pueden ser de solo lectura. Mantén como datos de solo lectura las plantillas de código fuente y los paquetes precompilados. Escribe el código fuente renderizado y las unidades de compilación copiadas únicamente en un espacio de trabajo para código fuente generado. Escribe archivos objeto, bibliotecas compartidas, metadatos y archivos de compilación únicamente en el espacio de trabajo de artefactos JIT. Genera el manifiesto de compilación a partir de la lista exacta de fuentes y los indicadores de compilación. Permite sobrescribir las ubicaciones de los espacios de trabajo para entornos compartidos, temporales o restringidos. Usa el contexto de arquitectura para combinar los dispositivos detectados con los objetivos solicitados explícitamente. Limita un módulo a las familias de arquitecturas compatibles antes de iniciar la compilación. Falla de forma clara cuando ninguna arquitectura solicitada sea compatible. No compiles silenciosamente para una familia de dispositivos diferente. ## Añade un kernel nuevo desde el código de dispositivo hasta la API pública Implementa código de dispositivo independiente del framework sobre punteros sin abstracción y tipos de kernel portátiles. Mantén las cabeceras del framework fuera de la capa reutilizable de inclusiones del kernel. Añade un iniciador en la capa de vinculaciones para validar tensores y preparar los parámetros de invocación. Exporta el iniciador mediante la FFI tipada y multilingüe del proyecto. Calcula un URI de operación determinista a partir de los parámetros de especialización. Crea un directorio de generación por operación dentro del espacio de trabajo de fuentes con permiso de escritura. Usa una plantilla solo cuando necesites una especialización concreta de tipo o parámetro. Escribe la configuración renderizada únicamente cuando su contenido sea diferente. Copia las unidades de compilación requeridas en el directorio de generación. Devuelve una especificación de compilación que contenga el URI, los archivos fuente, los indicadores y los límites de arquitectura. Ofrece una API de alto nivel con caché que reutilice los módulos cargados. Registra la operación para generar paquetes con compilación anticipada cuando la distribución lo requiera. Exporta la API pública desde el punto de entrada del paquete. Adjunta una plantilla de seguimiento que defina ejes, entradas, salidas y una referencia opcional. En las API de planificación y ejecución, adjunta el seguimiento al método que realice la ejecución. Añade un ejemplo realista de seguimiento, regenera los artefactos de definición de comparativas y confirma las salidas esperadas. Ejecuta pruebas de coherencia del seguimiento y de extremo a extremo después de la regeneración. ## Omite en las pruebas las GPU no compatibles y respalda la velocidad con comprobaciones de resultados Ejecuta la suite completa de pruebas para una validación amplia y pruebas específicas durante la iteración. Omite de forma deliberada el hardware no compatible mediante funciones auxiliares centrales de capacidad. Comprueba tanto la capacidad de cálculo del dispositivo como la compatibilidad del motor cuando una API exponga esos predicados. Mantén explícitos los requisitos de arquitectura de cada función. No conviertas una arquitectura no compatible en un fallo de prueba. No omitas una arquitectura compatible porque el dispositivo local sea diferente. Elige formas de prueba que ejerciten el contrato sin provocar omisiones evitables por falta de memoria. Abarca las rutas de atención, multiplicación de matrices, mezcla de expertos, comunicación y utilidades afectadas por un cambio. Usa herramientas de inicio multidispositivo para pruebas colectivas o distribuidas. Realiza las comparativas con un entorno unificado que admita motores comparables y configuraciones por lotes. Prefiere la medición con perfiles a nivel de hardware y recurre a eventos del acelerador cuando no esté disponible. Registra qué mecanismo de medición produjo cada resultado de la comparativa. Informa de la mediana, la variación, el número de iteraciones, la forma de la carga de trabajo, el tipo de datos, la arquitectura y el motor. Activa la comprobación de referencias cuando compares kernels. No presentes afirmaciones de velocidad sin comprobaciones de corrección y parámetros reproducibles. Exige pruebas de comparativas y de funcionamiento antes de aprobar un kernel sensible al rendimiento. ## Recompila los kernels en caché cuando cambien sus fuentes o la GPU de destino Usa una caché dentro del proceso para los módulos cargados y una caché en disco para los artefactos compilados. Invalida los módulos en caché cuando cambien los archivos fuente, los indicadores, la arquitectura, los parámetros o la versión de la biblioteca. Deriva la identidad de la caché del tipo de operación, los parámetros, los hashes de los archivos fuente, los indicadores y la arquitectura objetivo. Mantén las claves de caché únicas entre variantes de especialización y cadenas de herramientas. Almacena los metadatos de compatibilidad junto a los artefactos y valídalos antes de cargarlos. Protege la compilación con bloqueos para que los procesos simultáneos no dañen los artefactos compartidos. Para las salidas DSL de una sola arquitectura, almacena un directorio de módulo con metadatos y un objeto por especialización. Deriva la arquitectura del objetivo de compilación DSL o del dispositivo activo. Invalida un módulo DSL cuando cambie la versión del paquete del compilador o el hash de los archivos fuente del kernel. Permite desactivar la caché para el diagnóstico, pero mantén activada la reutilización de forma predeterminada. Usa macros de despacho o código generado para gestionar los espacios combinatorios de tipos de datos y tamaños de bloque. Mantén explícitas las opciones de despacho y prueba las combinaciones no compatibles. No añadas plantillas cuando sea suficiente el código fuente directo. No permitas que los paquetes precompilados obsoletos eludan las comprobaciones de compatibilidad de versiones. Omite las comprobaciones de versión solo en un experimento intencionado y diagnosticado con versiones mezcladas. ## Registra las entradas de la API antes de ejecutar kernels para poder reproducir fallos Registra las entradas de la API antes de ejecutar el kernel para que los parámetros que provocan un fallo sobrevivan a un error del dispositivo. Mantén el registro sin sobrecarga cuando esté desactivado. Ofrece niveles graduales para los nombres de las llamadas, las entradas y salidas y las estadísticas costosas. Reserva las estadísticas y la búsqueda de valores no válidos para diagnósticos explícitos de gran detalle. Omite la recopilación de estadísticas incompatibles durante la captura de gráficos. Limita los volcados de diagnóstico por cantidad de eventos y tamaño total. Admite filtros de inclusión y exclusión para que la captura costosa se dirija únicamente a las API relevantes. Elige un formato de tensor portátil cuando los volcados deban trasladarse entre entornos. Usa un directorio de volcado específico con permiso de escritura. Activa la salida detallada de compilación y los símbolos de depuración solo durante el diagnóstico de fallos. Examina conjuntamente los archivos fuente generados, los manifiestos de compilación, los módulos compilados y los metadatos de caché. Registra las formas, los tipos de datos, la arquitectura, los indicadores y el motor seleccionado cuando reproduzcas un fallo. Usa la información de líneas cuando necesites asignar el código fuente en un analizador de rendimiento o un depurador. Mantén los ajustes de optimización normales separados de las compilaciones de depuración. Trata las selecciones forzadas de algoritmos o motores como controles de diagnóstico, no como valores predeterminados de producción. Documenta todos los controles no predeterminados utilizados para reproducir un resultado. ## Verifica los artefactos descargados y publica para una lista explícita de GPU Falla de forma terminante cuando falten artefactos locales en entornos sin conexión o bloqueados. Permite que un espejo de confianza sustituya al repositorio de artefactos predeterminado. Verifica de forma predeterminada las sumas de comprobación de los artefactos descargados. Desactiva la validación de las sumas de comprobación solo como ayuda temporal de depuración. Limita las descargas paralelas de artefactos. Prefiere una fuente local configurada antes de intentar una descarga. Mantén explícitos y observables los indicadores de compilación y las sustituciones del iniciador. Mantén separados los controles de registro del cargador de artefactos y los controles de registro de llamadas a la API. Usa una medición estable para el ajuste automático, incluido un temporizador global de hardware cuando la medición por eventos no sea fiable. Permite sustituir la detección de computación confidencial para realizar diagnósticos controlados de integración continua. Conserva los resultados del ajuste automático solo con una ubicación explícita de caché y un entorno compatible. Carga una lista de bloqueo de tácticas para evitar kernels que se sabe que se bloquean o fallan en el conjunto actual. Mantén las sustituciones experimentales de enrutamiento y selección de kernels en sus valores predeterminados documentados. Compila paquetes con compilación anticipada para una lista explícita de arquitecturas. Genera los metadatos de versión del paquete a partir de una única fuente autoritativa de versiones. Usa incrementos de versión compatibles con versiones anteriores para kernels, compatibilidad con dispositivos y correcciones de errores. Reserva los cambios de API incompatibles para un límite de versión arquitectónico. ## Mantén la API pública y la documentación alineadas con el código de los kernels Usa una ABI tipada y multilingüe para que los mismos kernels sirvan a varios frameworks anfitriones. Mantén el tratamiento de tensores específico del framework en las vinculaciones, no en las cabeceras del dispositivo. Registra operaciones personalizadas en el framework anfitrión solo cuando lo requieran la compilación y la captura de gráficos. Mantén sincronizados la API de Python, el generador JIT, la exportación de vinculaciones, el registro de compilación anticipada y las exportaciones de paquetes. Parte del patrón de kernel funcional más sencillo antes de adoptar diseños avanzados de espacios de trabajo o de planificación y ejecución. Actualiza conjuntamente las firmas de funciones, las plantillas, los iniciadores y las pruebas cuando cambien los parámetros. Aprende el estilo, la complejidad, las defensas y la eficiencia establecidos a partir de ejemplos funcionales cercanos. Documenta las desviaciones intencionadas y las decisiones algorítmicas críticas para el rendimiento junto con las alternativas consideradas. Consulta la documentación autoritativa del conjunto de instrucciones y la cadena de herramientas para el comportamiento específico de cada arquitectura. Prefiere el código fuente de las dependencias incluido en el proyecto cuando la documentación externa esté obsoleta. Mantén sincronizadas con las API públicas las plantillas de seguimiento y las definiciones generadas de comparativas. Actualiza los ejemplos y tutoriales de infraestructura cuando cambien los patrones de registro, requisitos, FFI o generación de código. Marca claramente los enfoques obsoletos o retíralos de las orientaciones actuales. Declara cualquier ayuda relevante de la IA de acuerdo con la política de contribuciones. Aprueba únicamente cuando coincidan los archivos fuente, los artefactos generados, las cachés, las pruebas, las comparativas, las exportaciones y la documentación.