Savez-vous quelle ligne de code C++ vaut des millions de dollars ?
C’était cette ligne magique de C++ : i = 0x5f3759df – (i >> 1);
Cette ligne est apparue pour la première fois dans le code de Quake pour optimiser le calcul de la racine carrée inverse.
float Q_rsqrt(float number)
{
long i;
float x2, y;
const float threehalfs = 1.5F;
x2 = number * 0.5F;
y = number;
i = * ( long * ) &y; // evil floating point bit level hacking
i = 0x5f3759df - ( i >> 1 ); // what the fuck?
y = * ( float * ) &i;
y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed
return y;
}Pourquoi l’optimisation de la racine carrée inverse est-elle si importante ?
Les racines carrées inverses sont largement utilisées dans les graphismes de jeux vidéo, en particulier dans les moteurs 3D. De nombreux aspects de la programmation de jeux, comme le pathfinding, l’éclairage et les reflets, reposent fortement sur la normalisation de vecteurs, un processus qui nécessite une racine carrée inverse. Or, ce calcul, qui implique des opérations en virgule flottante, peut être coûteux en ressources.
Dans des jeux rapides et visuellement immersifs comme Quake III Arena, ces calculs s’effectuent des millions de fois par seconde. Même une légère amélioration de leurs performances pouvait donc accélérer significativement le traitement graphique et, au final, améliorer la fréquence d’images du jeu. Pour contourner le coût élevé de la fonction de racine carrée inverse, les programmeurs du moteur id Tech 3 ont conçu une approximation exceptionnellement précise et rapide.
Sans cette optimisation ingénieuse, Quake n’aurait peut-être jamais acquis son statut de référence dans l’industrie du jeu vidéo.
Quel est l’esprit brillant derrière cette solution innovante ?
Rys Sommerfeldt, Senior Manager de l’équipe européenne d’ingénierie jeu vidéo chez AMD RTG, a lancé une enquête sur les origines de la fonction en 2004. Au final, il semblerait que Greg Walsh en soit l’auteur. Greg Walsh est un monument du monde de l’informatique. Il a contribué à la conception du premier traitement de texte WYSIWYG (« what you see is what you get ») chez Xerox PARC et a participé à la fondation d’Ardent Computer. Greg a travaillé en étroite collaboration avec Cleve Moler, l’auteur de Matlab, chez Ardent, et c’est Cleve que Greg désignait comme sa source d’inspiration pour la fonction Fast Inverse Square Root.
Cette ligne de code est cryptique, ingénieuse, et s’accompagne de l’un des commentaires les plus emblématiques de l’histoire du logiciel. Mais elle soulève une question de plus en plus pertinente à l’ère du développement assisté par IA :
Une IA pourrait-elle écrire cela ? Le devrait-elle ? Et sinon, pourquoi ?
Réponse courte : Pas exactement. Mais… presque.
Les outils de génération de code par IA — comme GitHub Copilot, ChatGPT ou Google Gemini — peuvent tout à fait reproduire cette ligne si on leur donne suffisamment de contexte.
Mais le mot clé ici est reproduire, pas inventer.
Pourquoi ? Décortiquons la question.
1. Cette ligne n’a pas été « découverte » — elle a été façonnée
La constante 0x5f3759df est un nombre magique obtenu par essais, erreurs et une compréhension profonde des formats à virgule flottante (IEEE 754). Il a fallu une connaissance fine de :
- La représentation binaire des flottants
- Les techniques d’approximation binaire
- Les goulots d’étranglement de performance des moteurs de jeu
Une IA n’a pas « besoin » de comprendre ces choses comme les humains — et sans données d’entraînement montrant exactement cette astuce, il est peu probable qu’elle la synthétise à partir de rien.
2. L’IA excelle dans la synthèse de motifs, pas dans l’invention
Les LLM (grands modèles de langage) apprennent à partir de code écrit par des humains. Ils généralisent à partir d’exemples, mais ils sont fondamentalement dépourvus de créativité au sens mathématique. Ils :
- Combinent des concepts connus
- Optimisent des structures connues
- Prédisent les tokens suivants les plus probables
À moins que le jeu de données d’entraînement ne contienne quelque chose comme cette ligne, il est peu probable qu’elle émerge naturellement dans un contexte inédit.
3. Cette ligne est un anti-pattern dans le code moderne
D’un point de vue génie logiciel, cette ligne est :
- Non portable
- Non sûre (à cause du type punning)
- Difficile à lire et à maintenir
Les outils d’IA modernes (surtout ceux alignés sur les idéaux de code « sûr » ou « propre ») sont peu susceptibles de produire cela, sauf si on leur demande explicitement le « hack de la racine carrée inverse rapide ».
Quand l’IA peut la recréer
Si vous demandez à ChatGPT quelque chose comme :
« Écris la fonction de racine carrée inverse rapide de Quake III en C »
Vous obtiendrez probablement :
float Q_rsqrt(float number) {
long i;
float x2, y;
const float threehalfs = 1.5F;
x2 = number * 0.5F;
y = number;
i = * ( long * ) &y;
i = 0x5f3759df - ( i >> 1 );
y = * ( float * ) &i;
y = y * ( threehalfs - ( x2 * y * y ) );
return y;
}
Les outils d’IA entraînés sur du code provenant de GitHub et StackOverflow l’ont déjà vue, et la partageront volontiers si on la leur demande.
Mais ils ne l’inventeront pas d’eux-mêmes comme optimisation pour 1.0f / sqrt(x) à moins que leur jeu d’entraînement n’inclue ce hack ou qu’on les y invite très spécifiquement.
Ce que cela nous apprend sur la créativité humaine face à l’IA
Cette ligne — et le commentaire génial qui la suit — rappelle ce que les développeurs humains apportent :
- La perspicacité: savoir où se situe le coût et quelles astuces peuvent le corriger
- La prise de risque: faire quelque chose de « diabolique » parce que ça marche
- L’exploration: trouver des nombres magiques qui font vraiment le travail
Aujourd’hui, l’IA peut assister, traduire et optimiser — mais des lignes comme celle-ci naissent de la curiosité et l’intuition, quelque chose que nous apprenons encore à enseigner aux machines.
Réflexions finales
Alors : une IA pourrait-elle écrire à partir de rien i = 0x5f3759df - (i >> 1);?
Pas encore.
Tant que l’IA ne pourra pas réellement explorer les arcanes de la virgule flottante, les hacks de performance et les opérations mémoire non sûres à partir de principes premiers, ce sont les humains qui continueront d’écrire des lignes comme celle-ci.