Yop, si un processeur implémente un pipeline avec disons un fetch, decode, execute, memory, et write back, à chaque fois qu'il passera au fetch d'une nouvelle instruction (à partir d'un certain nombre d'instruction déjà commencées) il va y avoir un aléa structurel avec l'accès mémoire d'une des instructions qui a été commencé quelques cycles avant, non ?

Comment on règle ce problème ? Je connais les bulles de pipeline et je sais que ça va retarder l'instruction d'après, mais dans un exemple de pipeline à 5 étages si on exécute 10 instructions il va y avoir beaucoup de bulles, ou alors est-ce qu'on se débrouille simplement pour éviter ce genre d'aléas en séparant bien les étages du pipeline au niveau de la mémoire par exemple..

La reponse a cette question a autant de reponse que d'architecture. mais globalement il n'y a que peu de type de solution a ce probleme:

-Tu dimensionne le cache L1 d'instruction pour que ca n'arrive pas
-Tu fais du prefetching d'instruction
-Tu authorise l'execution d'instruction out of order
-Tu integre deux pipeline d'execution sur un seul jeu de ressource (une version evolue de ca etant hyper threading)
-Tu mets des claques aux gens qui ecrivent des codes long et sans boucle.
-Tu dimensionne le cache L1 de donnee pour que ca n'arrive pas
-Tu fais du prefetching de donnee.

"ou alors est-ce qu'on se débrouille simplement pour éviter ce genre d'aléas en séparant bien les étages du pipeline au niveau de la mémoire par exemple.. "

c'est le cas pour les cpu x86 intel/amd qui ont plusieurs ordonnanceurs (scheduler):

l’ordonnanceur du reorder buffer ordonne les instructions en fonction de leur inter-dépendance[1], alloue les registres privés et sépare les instructions mémoire des autres
sur deux file d’attente FIFO. la file mémoire sert a nourrir l’ordonnanceur mémoire qui s'occupe de gérer les load-store unit, l'autre file sert a nourrir les ordonnanceurs alu lent, alu rapide, fpu rapide, et fpu lent/simd (chaque ordonnanceur possède sa propre file d'attente).

donc, en gros, seul l'ordonnanceur du reorder buffer s'occupe de l’exécution dans le désordre alors que les 4 sous-ordonnanceurs prennent les instructions dans l'ordre (queue FIFO) mais peuvent les exécuter parallèlement (si ya plusieurs unités d’exécution).

pour alimenter le reorder buffer de façon constante, le frontend utilise un trace-cache[2] qui peut contenir plus de 12 000 instructions décodées.

[1] http://en.wikipedia.org/wiki/Tomasulo_algorithm
[2] http://en.wikipedia.org/wiki/CPU_cache#Trace_cache

merci pour vos réponses, je vais essayer d'approfondir ça.

je suis tombé sur cette page, pas encore lu, juste vite fait ici et la, ca a l'air pas mal.

http://www.lighterra.com//papers/modernmicroprocessors/

Je viens de la lire c'est pas mal en effet. Ca survole a peu pres 25% du cours de hpc que j'ai donne le semestre dernier. Pas mal.

je tombe dessus que maintenant mais super sympa le lien !

si vous avez d'autres pdf intéressants sur le sujet (cours/articles) vous pouvez me les envoyer en mp ça serait cool.

un mooc d'archi processeur viens de commencer sur coursera

https://www.coursera.org/course/comparch

c'est un cours avancé