Quelle quantité d'assemblage est vraiment utilisée dans le code de jeu moderne? [fermé]

En moyenne, à quelle fréquence l'assembly est-il utilisé dans le code de jeu moderne?

Spécifiquement sur les plates-formes qui ont déjà de bons compilateurs C ++, comme x86, PPC ou ARM - parce que je suppose que les jeux sur les systèmes embarqués utilisent largement l'assemblage.

La réponse dépend un peu de ce que vous entendez par «jeu» et de «utilisé». Je suppose que «utilisé» signifie «écrit au cours du projet de jeu spécifique».

D'après mon expérience et des données anecdotiques de personnes à qui j'ai parlé:

• dans les jeux sur navigateur? Aucun.
• dans les jeux PC typiques? Aucun. (Mais vous pourriez en voir dans les bibliothèques de bas niveau.)
• dans les jeux iOS et Android? Aucun.
• Des jeux PC et des jeux sur console "AAA"? Peut-être un peu, peut-être 0,05% de la base de code. (Avec un peu plus dans les bibliothèques.)

La connaissance du langage d'assemblage n'est pas attendue pour le travail dans l'industrie des jeux, mais selon le type de jeux que vous créez, cela peut être avantageux.

Il y avait autrefois un argument selon lequel le compilateur optimisait le code C mieux qu'un humain avec un assemblage écrit à la main. Habituellement, c'est vrai, parfois c'est faux. Mais de nos jours, une combinaison de la complexité croissante du processeur et de la nécessité d'évoluer (c'est-à-dire de séparer les processeurs) signifie que les efforts d'optimisation sont généralement dépensés ailleurs.

Ces dernières années, la seule fois où j'ai vu l'assemblage dans le code du jeu était des __asm int 3déclarations pour forcer les points d'arrêt, et ma seule utilisation personnelle de l'assemblage était de regarder le désassemblage d'une fonction pour diagnostiquer des bogues de plantage inhabituels.

La majeure partie du code haute performance dans les jeux de console modernes est écrite en utilisant une sorte de compromis entre l'assemblage et C ++: les intrinsèques du compilateur . Ces constructions ressemblent et analysent les fonctions C ++, mais sont en fait traduites en instructions sur une seule machine . Ainsi, par exemple, ma fonction "pince chaque valeur du vecteur V pour être> = a et <= b" ressemble

// for each v.x, ensure v.x >= a.x && v.x <= b.x
inline __m128 ClampSIMD( const __m128 &v, const __m128 & a, const __m128 & b )
{
    return _mm_max_ps( a, _mm_min_ps( v, b ) );
}

Dans des fonctions comme celles-ci, je pense toujours en termes d' instructions spécifiques à la machine , mais j'ai la commodité de les écrire en C pour ne pas avoir à me soucier de la coloration et de la planification des registres et du chargement des opérations et d'autres détails ennuyeux.

Vous devez toujours savoir quelles instructions le processeur prend en charge, en particulier parce que les compilateurs modernes sont terribles pour vectoriser du code, par rapport à la façon dont un humain intelligent peut faire le travail. Parfois, des détails subtils sur la façon dont vous organisez votre code peuvent avoir d'énormes implications pour les performances qui ne sont pas évidentes sans comprendre ce que fait la machine.

Bien que nous ne puissions pas coder dans l'assembly, nous déboguons toujours beaucoup dans l'assembly. L'optimisation des compilateurs réorganise agressivement le code d'une manière que les débogueurs ne peuvent pas suivre, si souvent lors du débogage d'un "mode de sortie", la meilleure chose à faire est d'ouvrir le désassembleur et de parcourir le code de cette façon. Cette conférence de GDC sur le «débogage judiciaire» des plantages illustre bon nombre des tenants et aboutissants du débogage à ce niveau.

Les problèmes qui nécessitaient auparavant un assemblage roulé à la main sont de moins en moins nombreux. Ce que vous "pourriez" gagner en vitesse vous perdez en lisibilité et en capacité de débogage. Cela ne devrait également être fait que comme l'une des toutes dernières étapes d'optimisation sur des sections de code car dans la plupart des cas, les problèmes de vitesse ne peuvent pas être améliorés avec l'assemblage. De nos jours, les processeurs sont devenus beaucoup plus rapides, contrairement aux vitesses de la mémoire, il est souvent plus important de contrôler la façon dont les données transitent par le processeur qu'autre chose.

Avec les compilateurs modernes, ils ont également du mal à optimiser le code d'assemblage car ils doivent gérer les registres que vous avez touchés et ils ne peuvent généralement pas réorganiser les instructions dans votre code fabriqué à la main. Pour réduire le besoin d'assemblage, il y a aussi maintenant des intrinsèques qui aident à accéder aux concepts de bas niveau, mais d'une manière qui est conviviale pour le compilateur et leur permet de travailler avec vous plutôt que contre.

Cela dit, le SPU sur la PS3 est un domaine où les gens doivent encore utiliser l'assemblage pour tirer le meilleur parti du processeur, avec un pipeline d'instructions manuelles, par exemple, comme expliqué ici .

Le fait est que nous vivons dans un monde multiplateforme, et certaines parties de notre code de jeu doivent être adaptées à la plate-forme locale - enfin pas à le faire, mais il y a des avantages si nous profitons du matériel local!

Il ne s'agit pas de jeux ou de logique de jeu, il s'agit de la localisation matérielle pour des performances optimales du code sur lequel repose la logique de jeu, nous pouvons en effet envelopper des sections de code, par exemple en utilisant des macros, de sorte qu'il existe un code source, qui s'exécute bien sur le plate-forme contre laquelle il a été construit.