Compteur de programme

Le compteur de programme ( PC ), communément appelé pointeur d'instruction ( IP ) dans les microprocesseurs Intel x86 et Itanium , et parfois appelé registre d'adresse d'instruction ( IAR ), le compteur d'instructions , ou simplement une partie du séquenceur d'instructions, est un registre de processeur qui indique où se trouve un ordinateur dans sa séquence de programme .

Habituellement, le PC est incrémenté après avoir récupéré une instruction et conserve l' adresse mémoire de (« pointe vers ») la prochaine instruction qui serait exécutée.

Les processeurs récupèrent généralement les instructions de manière séquentielle à partir de la mémoire, mais les instructions de transfert de contrôle modifient la séquence en plaçant une nouvelle valeur dans le PC. Il s'agit notamment de branches (parfois appelées sauts), d'appels de sous-programmes et de retours . Un transfert conditionné à la véracité d'une assertion permet à l'ordinateur de suivre une séquence différente dans des conditions différentes.

Une branche permet de récupérer l'instruction suivante ailleurs dans la mémoire. Un appel de sous-programme non seulement crée une branche, mais enregistre également le contenu précédent du PC quelque part. Un retour récupère le contenu enregistré du PC et le replace dans le PC, reprenant l'exécution séquentielle avec l'instruction suivant l'appel de sous-programme.

Dans une unité centrale de traitement (CPU) simple, le PC est un compteur numérique (qui est à l'origine du terme « compteur de programme ») qui peut être l'un des plusieurs registres matériels . Le cycle d'instruction commence par une extraction , dans laquelle le CPU place la valeur du PC sur le bus d'adresses pour l'envoyer à la mémoire. La mémoire répond en envoyant le contenu de cet emplacement mémoire sur le bus de données . (Il s'agit du modèle d'ordinateur à programme enregistré , dans lequel un seul espace mémoire contient à la fois des instructions exécutables et des données ordinaires. ) Après l'extraction, le CPU passe à l'exécution , en prenant certaines mesures en fonction du contenu de la mémoire qu'il a obtenu. À un moment donné de ce cycle, le PC sera modifié de sorte que la prochaine instruction exécutée soit différente (généralement, incrémentée de sorte que l'instruction suivante soit celle commençant à l'adresse mémoire suivant immédiatement le dernier emplacement mémoire de l'instruction en cours).

Comme d'autres registres de processeur, le PC peut être une banque de verrous binaires, chacun représentant un bit de la valeur du PC. Le nombre de bits (la largeur du PC) est lié à l'architecture du processeur. Par exemple, un processeur « 32 bits » peut utiliser 32 bits pour pouvoir adresser 2 ³² unités de mémoire. Sur certains processeurs, la largeur du compteur de programme dépend plutôt de la mémoire adressable ; par exemple, certains microcontrôleurs AVR ont un PC qui s'enroule après 12 bits.

Si le PC est un compteur binaire, il peut s'incrémenter lorsqu'une impulsion est appliquée à son entrée COUNT UP, ou le CPU peut calculer une autre valeur et la charger dans le PC par une impulsion à son entrée LOAD.

Pour identifier l'instruction en cours, le PC peut être combiné avec d'autres registres qui identifient un segment ou une page . Cette approche permet d'obtenir un PC avec moins de bits en supposant que la plupart des unités de mémoire d'intérêt se trouvent dans le voisinage actuel.

L'utilisation d'un PC qui incrémente normalement suppose que ce que fait un ordinateur est d'exécuter une séquence généralement linéaire d'instructions. Un tel PC est au cœur de l' architecture von Neumann . Ainsi, les programmeurs écrivent un flux de contrôle séquentiel même pour les algorithmes qui ne doivent pas nécessairement être séquentiels. Le « goulot d'étranglement von Neumann » qui en a résulté a conduit à des recherches sur le calcul parallèle , y compris des modèles non von Neumann ou de flux de données qui n'utilisaient pas de PC ; par exemple, plutôt que de spécifier des étapes séquentielles, le programmeur de haut niveau pourrait spécifier la fonction souhaitée et le programmeur de bas niveau pourrait la spécifier en utilisant la logique combinatoire .

Ces recherches ont également permis de trouver des moyens permettant d'accélérer les processeurs conventionnels basés sur PC, notamment :

• Pipelining , dans lequel différents matériels du processeur exécutent différentes phases de plusieurs instructions simultanément.
• L' architecture de mot d'instruction très long (VLIW), où une seule instruction peut produire plusieurs effets.
• Techniques permettant de prédire l'exécution dans le désordre et de préparer les instructions ultérieures à exécuter en dehors de la séquence régulière.

Les langages de programmation modernes de haut niveau suivent toujours le modèle d'exécution séquentielle et, en effet, une façon courante d'identifier les erreurs de programmation consiste à utiliser une « exécution de procédure » dans laquelle le doigt du programmeur identifie le point d'exécution comme le ferait un PC. Le langage de haut niveau est essentiellement le langage machine d'une machine virtuelle , trop complexe pour être construit en tant que matériel mais plutôt émulé ou interprété par un logiciel.

Cependant, de nouveaux modèles de programmation transcendent la programmation à exécution séquentielle :

• Lors de l'écriture d'un programme multithread , le programmeur peut écrire chaque thread sous la forme d'une séquence d'instructions sans spécifier le timing d'une instruction par rapport aux instructions des autres threads.
• Dans la programmation pilotée par événements , le programmeur peut écrire des séquences d'instructions pour répondre aux événements sans spécifier une séquence globale pour le programme.
• Dans la programmation de flux de données , le programmeur peut écrire chaque section d'un pipeline de calcul sans spécifier le timing par rapport aux autres sections.