PDP-11

PDP-11 à l'université du Michigan

PDP-11 équipé de DECtapes.

Un PDP-11 est un modèle d'ordinateur de la gamme des PDP (Programmable Data Processor) construit par Digital Equipment Corporation (DEC) entre 1970 et 1993.

Tous les PDP-11 sont 16 bits et entrent dans la classe des mini-ordinateurs. Ils furent extrêmement populaires car ils alliaient modularité et un excellent rapport qualité/prix. De fait, leur utilisation n'était pas cantonnée à un seul secteur d'application : on les retrouvait aussi bien dans les laboratoires de physique pour faire de l'acquisition de données que dans les cabinets comptables. Enfin, le monde universitaire a aussi fait l'acquisition d'un nombre important de ces machines.

Cette gamme est aussi populaire car elle a servi de base au développement du système d'exploitation Unix et du langage C. La pré-incrémentation (++i) et la post-incrémentation (i++) du C permettaient en particulier d'exploiter cette possibilité du langage-machine du PDP-11.

Elle arriva également quand l'IBM 1130 lancé en 1965, qui équipait beaucoup de laboratoires et d'écoles d'ingénieurs dans le monde, commençait à prendre de l'âge sans avoir de successeur proposé par IBM. Hormis son immense bibliothèque contributive de logiciels gratuits, le 1130 ne possédait pas d'avantage particulier sur le PDP-11 ni en vitesse, ni en coût.

Comme beaucoup d'autres, cette gamme a disparu car son espace d'adressage mémoire était trop limité (16 à 18 bits, 22 au maximum). Elle fut remplacée par les VAX, qui signifie Virtual Address eXtension (Extension de l'adressage virtuel), 32 bits. Les VAX possèdent un mode de fonctionnement « compatible PDP-11 ».

Architecture

Bus

Les premiers PDP-11 étaient architecturés autour du bus UNIBUS. Les derniers modèles, avec le jeu d'instruction compris sur quelques puces, et appelés LSI-11, sont basés sur le bus (moins large) appelé Q-BUS.

Registres

Le processeur du PDP-11 est doté de 8 registres, dont deux ont des utilisations spéciales : le registre 7, le PC (pour Program Counter ou compteur ordinal) et le registre 6, le pointeur de pile (SP, pour Stack Pointer ). Les autres registres R0, R1, ..., R5 et sont d'un usage général. Le dernier registre est le registre d'état.

 15                                                           0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R0                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R1                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R2                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R3                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R4                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R5                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R6 (SP)                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                                 R7 (PC)                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 \_____________________________________________________________/
                         registres (16 bits)

 15                                                           0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|  CM   |  PM   | R |           |    PRI    | T | N | Z | V | C |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 \_____________________________________________________________/
                       registre d'état(16 bits)

La signification des drapeaux du registre d'état sont :

• CM Current Mode, utilisateur (00), superviseur (01), noyau (11)
• PM Previous Mode, mêmes codes que ci-dessus
• R (ensemble de) Registres, utilisateur (0), superviseur (1)
• PRI niveau de priorité, entre 0 et 7
• T Trace
• NZVC codes conditions :

1. N Négatif
2. Z Zero
3. V (oVerflow) débordement
4. C (Carry) retenue

Tous les modèles de PDP-11 ne possèdent pas exactement le même type de registres d'état, celui présenté ici correspond aux modèles les plus avancés.

Types des données

On distingue trois classes :

• les entiers :

octet (8 bits)

mot (16 bits)

entier long (32 bits, deux registres)

• les nombres flottants (pour les modèles dotés de l'extension adéquate) :

simple précision

double précision

• chaînes de caractères

très nombreux formats différents...

Jeux d'instructions

Il y a trois jeux d'instructions possibles :

1. le jeu standard d'instruction PDP-11, dont on peut classer les instructions qui le composent en sept catégories :
   1. Opérande unique
   2. Double opérande
   3. Branchement
   4. Sauts et sous-programmes
   5. Trappes
   6. Instructions diverses
   7. Codes conditions
2. le jeu d'instructions pour l'arithmétique flottante pour le calcul scientifique (en option)
3. le jeu d'instructions pour l'informatique de gestion (en option)

Chaque instruction spécifie une opération à effectuer, éventuellement des opérandes (registres etc.) et un mode d'adressage.

Format des instructions

Le PDP-11 définit 7 formats. Dans tous les formats décrit ci-dessous :

• Rn désigne un registre
• mode décrit le mode d'adressage du registre Rn suivant
• source ou destination exprime lequel des opérandes sera accédé en lecture (respectivement en écriture).

Interprétation du champ mode

Le champ mode tient sur 3 bits. Par exemple une instruction à deux opérandes contient deux champs registres et deux champs mode, chacun décrivant comment interpréter le champ registre.

Si l'on considère uniquement les bits les plus à gauche (le troisième est le bit d'indirection, voir plus bas) :

• 000 adressage direct Rn : le paramètre est contenu dans le registre.
• 010 autoincrémentation (Rn)+ : le registre est interprété comme un pointeur vers une donnée en mémoire. Puis, il est incrémenté de 1 si l'instruction stipule un octet, ou de 2 si elle stipule un mot de 16 bits. Il est incrémenté de 2 pour les registres 6 et 7. (SP et PC).
• 100 autodécrémentation -(Rn). Comme ci-dessus, sauf que le registre est d'abord décrémenté avant d'être utilisé comme un pointeur.
• 110 adressage indexé X(Rn) X est ajouté à Rn pour produire l'adresse de l'opérande. Cette valeur index, X, est toujours placé à l'adresse qui suit l'instruction.

Le bit le plus à droite du mode est le bit d'indirection : si ce bit est à un, l'adressage sera indirect :

• 001 adressage indirect @Rn ou (Rn) : le registre contient l'adresse de l'opérande.
• 011 indirect autoincrémenté @(Rn)+ : le registre est utilisé comme un pointeur vers un mot contenant l'adresse de l'opérande. Le registre est incrémenté de 2.
• 101 indirect autodécrémenté @-(Rn) : comme ci-dessus, sauf que le registre est préalablement décrémenté de 2.
• 111 adressage indirect indexé @X(Rn) : la valeur de X (stockée juste après l'instruction) est ajouté au contenu du registre Rn pour former l'adresse du mot contenant l'adresse de l'opérande. Ni X ni Rn ne sont modifiés.

On notera qu'il n'y a pas de mode « immédiat » : celui-ci est accompli en utilisant le mode 2 (autoincrémentation). En effet, le PC pointe vers le mot qui suit l'instruction, et la postincrémentation le fait passer à l'instruction suivante après que la valeur immédiate suivant l'instruction en cours d'exécution est chargée par le processeur.
L'utilisation du PC comme registre crée donc 4 nouveaux modes :

• 010 adressage immédiat #n : l'opérande littéral n est contenu dans le mot suivant l'instruction.
• 011 adressage absolu @#A : l'adresse A est contenu dans le mot suivant l'instruction.
• 110 adressage relatif A : on ajoute à PC + 4 la valeur du mot qui suit l'instruction.
• 111 adressage relatif indirect @A : on ajoute à PC + 4 la valeur du mot qui suit l'instruction, valeur qui sera considérée comme un pointeur vers l'opérande.

Les modes d'adressage postincrémenté et prédécrementé seront particulièrement utilisé associé au pointeur de pile SP : -(SP) permettant l'empilement et (SP)+ le dépilement.

Les instructions à un opérande

 15                                   6   5       3   2       0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|             code opération            |    mode   |     Rn    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
                                         \_____________________/
                                               destination

Exemple : CLR (R0) 005010

Les instructions à deux opérandes

 15               11      9   8       6   5       3   2       0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| code opération|    mode   |     Rn    |    mode   |     Rn    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 
                 \_____________________/ \_____________________/
                          source               destination

Exemple : ADD R0, (R1)

N.B. : certaines instructions (ASH, ASHC, MUL, DIV) ne peuvent avoir qu'un registre comme source, dans ce cas le code opération s'étend du bit 9 au bit 15 :

 15               11      9   8       6   5       3   2       0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|     code opération        |     Rn    |    mode   |     Rn    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 
                             \_________/ \_____________________/
                                source         destination

Les branchements

 15                           8   7                            0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| code opération|               |         déplacement           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 

Le champ déplacement est signé, autorisant donc un décalage de -128 à +127 octets.

Les sauts et appels/retours de sous-programmes

Pour l'instruction JSR (Jump to Subroutine) :

 15                       9   8       6   5       3   2       0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|      code opération       |     Rn    |    mode   |     Rn    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 
                             \_________/ \_____________________/
                                lien           destination

Pour l'instruction RTS (Return from Subroutine) :

 15                                               3   2       0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|      code opération                               |     Rn    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
                                                     \_________/ 
                                                        lien 

Trappes et Interruptions

EMT, TRAP, BPT, IOT, CSM, RTI, RTT : pas de format particulier.

Codes conditions

CLC, CLV, CLZ, CLN, CCC, SEC, SEV, SEZ, SEN, SEC : pas de format particulier.

 15                                       5       3   2   1   0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                 code opération            | O | N | Z | V | C |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 

• Le bit 4, O, est à un pour les instructions SET (qui positionnent les drapeaux à 1) et 0 pour les instructions CLEAR qui les mettent à zéro.
• Les quatre bits de 0 à 3 sont un masque : un 1 à une position donnée indique que l'opération (SET ou CLEAR) doit être effectuée sur ce bit.

Instructions diverses

HALT, WAIT, RESET, MTPD, MTPI, MFPD, MFPI, MTPS, MFPS, MFPT : pas de format particulier.

Jeu d'instructions nombres flottants

Cette option est appelée FPP ou FP-11, FP pour Floating Point. Elle ajoute 6 nouveaux registres 64 bits (deux fois 32) pour les calculs, ainsi que quelques autres spécialisés (comme un registre d'état). Le fonctionnement du processeur flottant est distinct du processeur standard du PDP-11 : hormis un léger retard au moment où le processeur flottant va chercher l'instruction en mémoire, les deux processeurs calculent indépendamment.

Ce nouveau jeu d'instructions est disponible par modification du microcode.

Jeu d'instructions de gestion

Appelé CIS, pour Commercial Instruction Set, ce jeu d'instructions principalement axé sur la gestion de chaînes de caractères est étudié pour accélérer les opérations habituellement demandées par les programmes de gestion (écrit en COBOL par exemple).

Il permet la conversion de la représentation de nombres sous forme de caractères vers des valeurs binaires (et inversement) ou les calculs directement sur les représentations « chaîne de caractères ».

Simulateurs

• SIMH est un très bon émulateur de PDP11 (modèle 11/73 sans l'option CIS).
• Ersatz-11 un autre émulateur, produit commercial sauf pour une utilisation personnelle (pédagogique).

Systèmes d'exploitation

• Les systèmes DEC :
  • RT-11 (Real Time 11) qui se décline en deux versions RT11SJ pour Single Job (système monotâche) et RT11FB pour Foreground/Background (système bi-tâche).
  • RSX-11 (Resource Sharing eXtension-PDP 11)
  • RSTS/E (Resource System Time Sharing / Enhanced)
• Autres :
  • Unix (versions V5, V6 et V7 ou BSD 2.x)

Notes et références

Annexes

Articles connexes

• PDP la gamme de PDP de DEC
• le VAX, successeur du PDP-11

Liens externes

• (en) Galerie de photo de PDP-11
• (en) site consacré au PDP-11
• (en) The PDP-11 Processor Handbook
• Simulateurs de PDP