Écrire en assembleur ne vous donnerait pas une augmentation magique de la vitesse, car en raison de la quantité de détails (allocation de registre, etc.), vous écrirez probablement l'algorithme le plus trivial de tous les temps.
De plus, avec les processeurs modernes (conçus après 70-80), l’assemblage des processeurs ne vous donnera pas un nombre suffisant de détails pour savoir ce qui se passe (c’est-à-dire sur la plupart des processeurs). Les PU modernes (CPU et GPU) sont assez complexes en ce qui concerne les instructions de planification. Connaître les bases de l'assemblage (ou pseudo-assemblage) permettra de comprendre les manuels / cours d'architecture informatique qui fourniraient des connaissances supplémentaires (caches, exécution dans le désordre, MMU, etc.). Habituellement, vous n'avez pas besoin de connaître les ISA complexes pour les comprendre (MIPS 5 est un IIRC très populaire).
Pourquoi comprendre le processeur? Cela pourrait vous donner beaucoup plus de compréhension de ce qui se passe. Supposons que vous écrivez la multiplication matricielle de manière naïve:
for i from 0 to N
for j from 0 to N
for k from 0 to N
A[i][j] += B[i][k] + C[k][j]
Il peut être «assez bon» pour votre objectif (si c'est une matrice 4x4, il pourrait être compilé en instructions vectorielles de toute façon). Cependant, il existe des programmes très importants lorsque vous compilez des tableaux massifs - comment les optimiser? Si vous écrivez le code en assembleur, vous obtiendrez peut-être quelques améliorations (à moins que vous ne fassiez comme la plupart des gens - également de manière naïve, sous-utiliser les registres, charger / stocker en mémoire en permanence et avoir un programme plus lent que dans le langage HL) .
Cependant, vous pouvez inverser les lignes et gagner magiquement de la performance (pourquoi? Je le laisse comme «devoir») - IIRC en fonction de divers facteurs pour les grandes matrices, il peut même être 10x.
for i from 0 to N
for k from 0 to N
for j from 0 to N
A[i][j] += B[i][k] + C[k][j]
Ceci dit - des compilateurs sont en mesure de le faire ( graphite pour gcc et Polly pour tout ce qui utilise LLVM). Ils sont même capables de le transformer en (désolé - j'écris en bloquant de mémoire):
for i from 0 to N
for K from 0 to N/n
for J from 0 to N/n
for kk from 0 to n
for jj from 0 to n
k = K*n + kk
j = J*n + jj
A[i][j] += B[i][k] + C[k][j]
Pour résumer, connaître les bases d'un assemblage vous permet d'explorer divers «détails» de la conception du processeur, ce qui vous permettrait d'écrire des programmes plus rapidement. Il peut être intéressant de connaître les différences entre les architectures RISC / CISC ou VLIW / processeur vectoriel / SIMD / .... Cependant, je ne commencerais pas avec x86 car ils ont tendance à être assez compliqués (peut-être aussi avec ARM) - savoir ce qu’est un registre, etc.