En architecture des ordinateurs, un pipeline est une technique de conception des processeurs où l'exécution des plusieurs instructions se chevauchent à l'intérieur même du processeur. Le premier ordinateur à utiliser cette technique est l'IBM Stretch, conçu en 1958.

Soit un microprocesseur où 4 cycle sont nécessaires pour accomplir une instruction :

1. I.F (Instruction Fetch) charge l'instruction à exécuter depuis la mémoire.
2. ALU (Arithmetic Logic Unit) exécute l'instruction.
3. M.A (Memory Access), dénote un transfert depuis un registre vers la mémoire dans le cas d'une instruction du type STORE (accès en écriture) et de la mémoire vers un registre dans le cas d'un LOAD (accès en lecture).
4. W.B (Write Back) stocke le résultat dans un registre.

En supposant que chaque étape met 1 cycle d'horloge pour s'exécuter, il faut normalement 4 cyles pour exécuter une instruction, 12 pour 3 instructions :

Si on insére des registres tampons (pipeline registers) entre chaque étape, on fait chevaucher les exécutions de chaque cycle. Les 3 instructions s'exécuteront en 6 cycles, et le processeur sera capable de produire une instruction par cycle à partir du quatrième :

Au 4ème cycle, tous les étages sont en cours d'exécution.

Cette technique ne diminue pas le temps d'exécution d'une instruction, mais permet de multiplier le débit avec lequel elles sont exécutées par le processeur.

Aujourd'hui tous les microprocesseurs sont pipelinés :

Les pipelines provoquent de nouveaux problèmes, en particulier d'interdépendance : par exemple une instruction ne peut récupérer le résultat de la précédente car celui-ci n'est pas encore disponible. Ainsi, la séquence :

ADD   R1, R2, R3  // R1 = R2 + R3
STORE R1, 1000    // C(1000) = R1

Ne stocke pas à l'emplacement mémoire 1000 la valeur de R1 contenant la somme R2 + R3, mais la valeur de R1 contenu avant l'instruction ADD.

Se pose le mème problème avec les sauts :

 MOV R1, #1000 // R1 = 1000
 JUMP R1       // Saut inconditionel

R1 ne contient pas encore la valeur 1000 au moment où l'instruction de saut va s'exécuter.

Une solution possible à ces deux problèmes est d'insérer une instruction entre les deux qui sont inter-dépendantes. Prenons par exemple la séquence suivante :

1: A = B + C
2: D = A + C
3: E = F + B

qui comporte une dépendance directe simple, A ne pouvant être disponible pour la partie droite de la seconde instruction.

• la première solution, triviale, est d'insérer des NOP (No Operation), c'est ce que font les compilateurs quand on ne précise pas d'option d'optimisation du code :

 1: A = B + C
1b: NOP
 2: D = A + C
 3: E = F + B

• la seconde solution consiste à réarranger les instructions. Dans cet exemple, l'operation de la troisième ligne n'a aucune interdépendance avec les deux précédentes. Le code modifié sera :

 1: A = B + C
 2: E = F + B
 3: D = A + C