KernelCraft: Benchmarking for Agentic Close-to-Metal Kernel Generation on Emerging Hardware

Le papier présente KernelCraft, le premier benchmark évaluant la capacité des agents LLM à générer et optimiser des noyaux bas niveau pour des accélérateurs émergents via un processus itératif guidé par des retours automatiques, démontrant ainsi leur potentiel pour réduire les coûts de développement sur de nouvelles architectures matérielles.

L'essentiel

🛠️ KernelCraft : L'Artisan Automatique des Moteurs de l'IA

Imaginez que vous êtes un architecte qui vient de construire une nouvelle voiture de course, totalement révolutionnaire. Elle a un moteur unique, des roues magnétiques et un système de direction qui n'existe nulle part ailleurs. C'est génial, mais il y a un gros problème : personne ne sait comment conduire cette voiture.

Pour faire rouler cette voiture (votre nouvelle puce d'IA), il faut écrire des instructions très précises, au niveau le plus bas possible (le "code assembleur"). C'est comme si vous deviez écrire manuellement chaque mouvement des pistons du moteur. C'est long, difficile, et si vous faites une erreur, la voiture ne démarre pas.

C'est là que KernelCraft entre en jeu.

🤖 Le Problème : Le Mur de la Programmation

Aujourd'hui, pour créer de nouvelles puces d'IA (les "accélérateurs"), les ingénieurs doivent souvent écrire ces instructions manuellement. C'est comme essayer de construire un meuble IKEA sans notice, juste en devinant comment les vis s'assemblent.

• C'est lent (ça prend des mois).
• C'est cher (il faut des experts très payés).
• C'est dangereux (une petite erreur peut tout casser).

Les ordinateurs actuels (comme les GPU NVIDIA) ont de "vieilles" instructions bien connues, donc les logiciels savent déjà comment les utiliser. Mais les nouvelles puces ont des instructions totalement nouvelles. Les logiciels existants ne les comprennent pas.

🚀 La Solution : KernelCraft, le "Mécanicien Robot"

Les chercheurs ont créé KernelCraft. Ce n'est pas un simple logiciel, c'est un agent intelligent (une IA capable de réfléchir et d'agir) qui apprend à écrire ces instructions complexes tout seul.

Imaginez KernelCraft comme un apprenti mécanicien robot ultra-intelligent :

1. Il reçoit la notice : On lui donne le plan de la nouvelle voiture (la spécification du matériel) et le manuel d'utilisation des outils (la documentation technique).
2. Il essaie de construire : Il écrit le code (les instructions pour le moteur).
3. Il teste et se corrige : Il lance le moteur. Si ça ne marche pas (erreur de syntaxe ou de logique), il regarde le tableau de bord, comprend pourquoi ça a raté, et réécrit le code.
4. Il répète : Il continue d'essayer, de tester et d'améliorer jusqu'à ce que la voiture roule parfaitement et vite.

🎯 Comment ça marche ? (L'analogie du Chef Cuisinier)

Pour bien comprendre, imaginons que notre nouvelle puce est une cuisine futuriste avec des fourneaux magiques que personne n'a jamais utilisés.

• La tâche : Le patron demande un plat complexe (par exemple, un "Attention" pour l'IA, qui est crucial pour les chatbots).
• L'agent (KernelCraft) : Au lieu de donner une recette toute faite, on dit à l'IA : "Voici les ingrédients et les outils magiques. Cuisine ce plat."
• Le processus :
  • L'IA écrit la recette (le code).
  • Elle essaie de cuisiner.
  • Si le plat est brûlé (erreur), elle regarde ce qui s'est passé.
  • Elle demande à un assistant (un outil) de vérifier la température du four.
  • Elle ajuste la recette et réessaie.
  • Finalement, elle produit un plat non seulement bon, mais meilleur que celui qu'un chef humain aurait pu faire avec les mêmes outils, car elle a trouvé des astuces que personne n'avait vues.

📊 Ce que les chercheurs ont découvert

Ils ont testé ce robot sur trois types de nouvelles "voitures" (puces) et avec quatre cerveaux d'IA différents (les modèles de langage les plus avancés).

1. C'est possible ! Les IA les plus intelligentes (comme GPT-5.2 ou Gemini) ont réussi à écrire le code pour ces nouvelles puces, même sans avoir jamais vu ces instructions auparavant. C'est du "zéro-shot" (apprendre sans exemple).
2. La difficulté varie :
   • Pour des tâches simples (comme ajouter deux nombres), l'IA réussit très bien (comme un enfant qui apprend à marcher).
   • Pour des tâches complexes (comme des systèmes entiers de reconnaissance d'images), c'est encore difficile, mais l'IA progresse vite.
3. L'IA peut être plus rapide que l'humain : Dans certains cas, le code écrit par l'IA était plus rapide que celui écrit par des experts humains ou par les compilateurs standards. L'IA a trouvé des raccourcis magiques que les humains n'avaient pas pensés.
4. Le secret : La boucle de rétroaction. Ce qui rend l'IA si forte, ce n'est pas juste sa capacité à écrire du code, mais sa capacité à utiliser des outils pour tester son code, voir les erreurs, et se corriger elle-même. C'est comme un joueur qui joue, perd, regarde la replay, et recommence.

💡 Pourquoi c'est important pour nous ?

Aujourd'hui, le développement de nouvelles puces d'IA est un goulot d'étranglement. On invente des puces géniales, mais on ne peut pas les utiliser car il n'y a pas de logiciels pour les piloter.

KernelCraft change la donne :

• Il accélère le développement.
• Il réduit les coûts (moins besoin d'armées d'experts).
• Il permet aux entreprises de lancer de nouvelles technologies beaucoup plus vite.

En résumé, KernelCraft est le premier "benchmark" (test de référence) qui prouve que les intelligences artificielles peuvent devenir des ingénieurs de bas niveau, capables de parler directement le langage des machines les plus récentes, rendant le futur de l'IA plus rapide et plus accessible.

Résumé technique

Résumé Technique : KernelCraft – Benchmark pour la Génération de Kernels Proches du Matériel par des Agents Autonomes

1. Problématique

L'émergence de nouveaux accélérateurs d'IA dotés d'architectures et d'ensembles d'instructions (ISA) personnalisés pose un défi majeur : le manque d'outils de compilation matures. Contrairement aux écosystèmes GPU établis (CUDA, Triton), ces nouvelles plateformes nécessitent souvent que les développeurs écrivent manuellement des kernels de bas niveau (assembly) pour exploiter efficacement le matériel. Ce processus est :

• Lourd et lent : Il exige une expertise profonde de l'architecture cible.
• Non évolutif : Il ne peut pas suivre le rythme rapide de l'innovation matérielle.
• Propice aux erreurs : La complexité des contraintes matérielles (hiérarchie mémoire, mouvements de données) rend la génération manuelle difficile.

Les solutions existantes basées sur les LLM (Large Language Models) se concentrent principalement sur des langages de haut niveau (CUDA, Triton) ou des écosystèmes matures. Elles échouent souvent face au défi de la génération "zero-shot" de kernels assembly pour des ISA inconnus, où les modèles ne disposent pas de données d'entraînement spécifiques.

2. Méthodologie : KernelCraft

Pour combler ce vide, les auteurs proposent KernelCraft, le premier benchmark conçu pour évaluer la capacité des agents LLM autonomes à générer et optimiser des kernels assembly pour des accélérateurs personnalisés.

Architecture du Framework

KernelCraft fonctionne comme une boucle de rétroaction automatisée (diagnostic et réparation) :

1. Entrées : Le système reçoit une description de la charge de travail (ex: GEMM, Attention), la spécification de l'ISA, et la configuration matérielle (taille des tableaux systoliques, mémoire, etc.).
2. Agent Autonome : Un LLM (agent) génère le code assembly.
3. Boucle d'Outillage (Tool-Use) : L'agent n'agit pas seul ; il utilise une série d'outils natifs pour itérer :
   • write_code : Sauvegarde le code.
   • check_syntax : Vérifie la compilation.
   • run_evaluation : Exécute le kernel sur un simulateur ou du matériel réel.
   • view_output : Compare les résultats avec une vérité terrain (ground truth).
   • grep_docs : Interroge la documentation de l'ISA pour corriger les erreurs.
4. Itération : Si le kernel échoue (erreur de syntaxe, de fonctionnalité ou de performance), l'agent analyse les logs, diagnostique le problème (ex: décalage de mémoire, instruction incorrecte) et génère une version corrigée. Ce processus se répète jusqu'à ce que le kernel soit fonctionnellement correct et optimisé.

Périmètre du Benchmark

• Plateformes cibles : Trois accélérateurs émergents (PLENA, AMD NPU, Coral NPU) et un cœur CPU RISC-V (BOOM).
• Tâches : Plus de 33 tâches couvrant trois niveaux de complexité :
  • Niveau 1 : Opérations primitives (SiLU, Softmax, GEMM).
  • Niveau 2 : Opérations composites (MLP, Attention, FlashAttention).
  • Niveau 3 : Systèmes end-to-end (Blocs de Transformers, CNNs).
• Modèles évalués : Quatre modèles de pointe (GPT-5.2, Gemini-3-Flash, Claude Sonnet 4, DeepSeek R1).

3. Contributions Clés

1. Premier Benchmark "Close-to-Metal" : KernelCraft est la première évaluation systématique de la génération de code assembly natif pour des ISA personnalisés via des agents LLM.
2. Validation de l'approche Agentique : Le papier démontre que les agents capables d'utiliser des outils (tool-use) et de raisonner sur plusieurs tours (multi-turn) surpassent largement les approches de génération unique (one-shot), en particulier pour les ISA nouveaux.
3. Découverte d'Optimisations : Les agents ne se contentent pas de corriger des bugs ; ils découvrent des optimisations matérielles spécifiques (ex: fusion de BatchNorm, préchargement de données) qui surpassent parfois les compilateurs de base.
4. Co-conception ISA : Le framework permet d'identifier les lacunes d'une ISA. Dans une étude de cas, l'agent a proposé de nouvelles instructions pour un workload de diffusion (dLLM) que l'ISA ne supportait pas nativement, validant son potentiel pour la co-conception matériel-logiciel.

4. Résultats Expérimentaux

Taux de Succès

• Performance Globale : GPT-5.2 se distingue comme le modèle le plus performant, atteignant un taux de succès global de 55 % sur PLENA, 17 % sur AMD NPU et 47 % sur Coral NPU.
• Impact de la Complexité : Le taux de succès chute drastiquement avec la complexité.
  • Niveau 1 (Primitives) : Jusqu'à 74 % de succès pour GPT-5.2 sur PLENA.
  • Niveau 2 (Composites) : Chute à ~45 % sur PLENA et <10 % sur les autres plateformes.
  • Niveau 3 (End-to-End) : Presque aucun succès (seul un bloc ConvBlock a été généré avec succès sur Coral NPU).
• Rôle du Raisonnement : L'ablation montre que l'activation du "réflexion" (thinking tokens) est cruciale. Sans elle, les modèles échouent systématiquement sur les tâches complexes (0 % de succès).

Performance et Optimisation

• Comparaison avec les Compilateurs : Les kernels générés par les agents peuvent égaler ou surpasser les bases de référence des compilateurs.
  • Sur Coral NPU, l'agent a atteint un speedup de 7,93x sur un bloc ConvBlock par rapport au compilateur RVV-O2, grâce à une fusion intelligente de la normalisation (BatchNorm folding) en arithmétique entière.
  • Sur PLENA, des gains de 1,06x à 1,22x sont observés sur les tâches de normalisation.
• Qualité du Code : Les agents réussissent à produire du code assembly correct et performant en quelques itérations (souvent < 15 tours pour les tâches primitives), réduisant considérablement le temps de développement manuel.

Limites

• La qualité de la documentation de l'ISA est un facteur déterminant. AMD NPU, avec une documentation plus courte, a montré des taux de succès plus faibles.
• Les tâches complexes (Niveau 3) restent hors de portée des modèles actuels sans assistance humaine ou itérations massives.

5. Signification et Impact

KernelCraft marque un tournant dans le développement des accélérateurs d'IA :

• Réduction de la barrière à l'entrée : Il démontre que l'écriture de kernels assembly pour des architectures exotiques peut être automatisée, rendant viable le déploiement rapide de nouveaux matériels.
• Nouveau Paradigme de Développement : Il valide l'approche "Agentique" (LLM + Outils + Boucle de rétroaction) comme supérieure à la simple génération de code pour les tâches de bas niveau complexes.
• Co-design Matériel-Logiciel : La capacité des agents à identifier les goulots d'étranglement et à proposer de nouvelles instructions ouvre la voie à une conception de processeurs plus agile, où le logiciel guide l'évolution du matériel.

En conclusion, KernelCraft prouve que les agents LLM autonomes sont capables de naviguer dans la complexité des ISA personnalisées pour produire du code de performance, offrant une solution prometteuse au goulot d'étranglement de la programmation des futurs accélérateurs d'IA.