Langage de programmation des systèmes - Systems Programming Language

Le langage de programmation de systèmes , souvent abrégé en SPL mais parfois connu sous le nom de SPL / 3000 , était un langage de programmation orienté vers les procédures écrit par Hewlett-Packard pour la gamme de mini-ordinateurs HP 3000 et introduit pour la première fois en 1972. SPL a été utilisé pour écrire le fonctionnement principal du HP 3000. système , Multi-Programming Executive (MPE). Des langages similaires sur d'autres plates-formes étaient génériquement appelés langages de programmation système , ce qui prête à confusion.

Initialement connu sous le nom de langage de programmation Alpha Systems , du nom du projet de développement qui a produit la série 3000, SPL a été conçu pour tirer parti de la conception du processeur basé sur la pile de l'Alpha . Il est calqué sur ESPOL , un langage similaire dérivé d' ALGOL utilisé par les systèmes mainframe Burroughs B5000 , qui a également influencé un certain nombre de langages des années 1960 comme PL360 et JOVIAL .

Au milieu des années 1970, le succès des systèmes HP a produit un certain nombre de ramifications SPL. Les exemples incluent ZSPL pour le processeur Zilog Z80 et Micro-SPL pour Xerox Alto . L' action inspirée plus tard ! pour la famille Atari 8 bits , qui a été assez réussie. Ce dernier a suivi de plus près la syntaxe Pascal , perdant certaines des particularités de SPL.

SPL a été largement utilisé pendant la durée de vie de la plate-forme HP 3000 à base de circuits intégrés d' origine . Dans les années 1980, le HP 3000 et le MPE ont été réimplémentés dans un émulateur fonctionnant sur les plates-formes HP 9000 basées sur PA-RISC . HP a promu Pascal comme langage système préféré sur PA-RISC et n'a pas fourni de compilateur SPL. Cela a provoqué des problèmes de maintenance du code et des compilateurs SPL tiers ont été introduits pour répondre à ce besoin.

Histoire

Hewlett-Packard a présenté ses premiers mini - ordinateurs , la série HP 2100 , en 1967. Les machines avaient été initialement conçues par une équipe externe travaillant pour Union Carbide et destinées principalement à des applications de contrôle embarqué industriel, et non au marché plus large du traitement des données. HP a vu cela comme un ajustement naturel avec son activité d'instrumentation existante et l'a initialement présenté à ces utilisateurs. Malgré cela, HP a constaté que le rapport prix / performances de la machine les rendait de plus en plus performants sur le marché professionnel.

Au cours de cette période, le concept de partage du temps devenait populaire, d'autant plus que les coûts de la mémoire centrale diminuaient et que les systèmes commençaient à être livrés avec plus de mémoire. En 1968, HP a introduit un système groupé utilisant deux machines de la série 2100 exécutant HP Time-Shared BASIC , qui fournissait un système d'exploitation complet ainsi que le langage de programmation BASIC . Ces systèmes à deux machines, connus collectivement sous le nom de HP 2000, ont été un succès immédiat. HP BASIC a été très influent pendant de nombreuses années, et sa syntaxe peut être vue dans un certain nombre de BASIC de micro-ordinateurs , notamment Palo Alto TinyBASIC , Integer BASIC , North Star BASIC , Atari BASIC et d'autres.

Les concepteurs de HP ont commencé à se demander: "Si nous pouvons produire un système de partage de temps aussi efficace en utilisant un ordinateur junky comme le 2116, pensez à ce que nous pourrions accomplir si nous concevions notre propre ordinateur." À cette fin, en 1968, la société a commencé à constituer une équipe plus importante pour concevoir une nouvelle architecture de taille moyenne. Les nouveaux membres de l'équipe comprenaient ceux qui avaient travaillé sur les systèmes mainframe Burroughs et IBM , et les concepts qui en résultaient ressemblaient fortement au système très réussi Burroughs B5000 . Le B5000 utilisait un processeur de machine d'empilage qui simplifiait la mise en œuvre de la multiprogrammation , et cette même architecture a également été choisie pour le nouveau concept HP.

Deux implémentations ont été envisagées, une machine à l'échelle de mainframe 32 bits connue sous le nom d'Omega et une conception 16 bits connue sous le nom d'Alpha. Presque tous les efforts portaient sur l'Omega, mais en juin 1970, Omega a été annulée. Cela a conduit à une refonte complète d'Alpha pour le différencier des années 2100, et il a finalement émergé avec des plans pour une conception de système d'exploitation encore plus agressive. Omega avait l'intention de fonctionner en mode batch et d'utiliser un ordinateur plus petit, le «frontal», pour traiter les interactions avec l'utilisateur. C'était le même concept de fonctionnement que la série 2000. Cependant, 2000 autres ne seraient pas suffisants pour Alpha, et la décision a été prise de n'avoir qu'un seul fonctionnement pour un fonctionnement par lots, interactif et même en temps réel .

Pour que cela fonctionne, il avait besoin d'une conception de bus informatique avancée avec un accès direct à la mémoire (DMA) étendu et d'un système d' exploitation avancé (OS) pour fournir des réponses rapides aux actions des utilisateurs. Le B5000 était également unique, pour l'époque, en ce que son système d'exploitation et ses utilitaires de base étaient tous programmés dans un langage de haut niveau , ESPOL . ESPOL était un dérivé du langage ALGOL conçu pour fonctionner sur les B5000, un concept qui était très influent dans les années 1960 et qui a conduit à de nouveaux langages comme JOVIAL , PL / 360 et BCPL . L'équipe HP a décidé qu'elle utiliserait également un langage dérivé d'ALGOL pour le fonctionnement de ses systèmes d'exploitation. Le langage similaire de HP était initialement connu sous le nom de langage de programmation Alpha Systems.

Alpha a mis plusieurs années à se développer avant d'émerger en 1972 sous le nom de HP 3000. La machine n'était sur le marché que quelques mois avant qu'il ne soit clair qu'elle ne fonctionnait tout simplement pas correctement, et HP a été obligé de rappeler toutes les 3000 déjà vendues. Il a été réintroduit à la fin de 1973 et la plupart de ses problèmes ont été résolus. Une mise à niveau majeure de l'ensemble du système, de la machine CX et du MPE-C pour fonctionner dessus, a réformé son image et le 3000 a continué à être un autre succès majeur au cours de la seconde moitié des années 1970.

Ce succès a rendu SPL presque aussi répandu que le BASIC de la série 2000, et comme ce langage, SPL a abouti à un certain nombre de versions pour d'autres plates-formes. Parmi eux, notons Micro-SPL, une version écrite pour la station de travail Xerox Alto . Cette machine avait à l'origine utilisé BCPL comme langage principal, mais le mécontentement face à ses performances a conduit Henry Baker à concevoir un langage non récursif qu'il a implémenté avec Clinton Parker en 1979. Clinton modifierait ensuite encore Micro-SPL pour produire Action! pour la famille Atari 8 bits en 1983.

HP a réimplémenté le système HP 3000 sur le chipset PA-RISC, exécutant une nouvelle version du système d'exploitation connue sous le nom de MPE / iX. MPE / iX avait deux modes, en "mode natif", il exécutait des applications qui avaient été recompilées pour le PA-RISC en utilisant de nouveaux compilateurs Pascal, tandis qu'en "mode compatible", il pouvait exécuter tous les logiciels existants via l'émulation. HP n'a pas fourni de compilateur en mode natif pour MPE / iX, ce n'était donc pas un processus facile de déplacer les logiciels existants vers la nouvelle plate-forme. Pour répondre à ce besoin, Allegro Consultants a écrit un langage compatible SPL nommé "SPLash!" qui pourrait compiler vers le code HP 3000 d'origine pour s'exécuter dans l'émulateur, ou en mode natif. Cela offrait une voie de portage pour les logiciels SPL existants.

Langue

Syntaxe de base

SPL suit généralement les conventions de syntaxe ALGOL 60, et sera familier à toute personne ayant de l'expérience dans ALGOL ou ses descendants, comme Pascal et Modula-2 . Comme ces langages, les instructions de programme peuvent s'étendre sur plusieurs lignes physiques et se terminer par un point-virgule. Les commentaires sont indiqués par le COMMENT mot - clé ou en entourant le texte du commentaire entre << et >>.

Les instructions sont regroupées en blocs en utilisant BEGIN et END, bien que, comme en Pascal, la FIN d'un programme doive être suivie d'un point. Le programme dans son ensemble est entouré de BEGIN et END., Similaire à Pascal, mais sans mot clé PROGRAM ou instruction similaire en haut. La raison en est que SPL permet à n'importe quel bloc de code d'être utilisé en tant que programme seul, ou compilé dans un autre programme pour agir comme une bibliothèque. La création de code en tant que programme ou sous-programme ne faisait pas partie du langage lui-même, gérée à la place en plaçant la $CONTROL SUBPROGRAM directive du compilateur en haut du fichier.

Le langage utilise le mot-clé INTRINSIC pour permettre au code externe d'être appelé directement en lui donnant un nom local. Par exemple, une bibliothèque de langage machine exposant une fonction pour exécuter la cloche de la console pourrait être importée dans un programme SPL au fur INTRINSIC BELL et à mesure , puis la cloche pourrait être exploitée en utilisant le mot-clé BELL comme s'il s'agissait d'une commande native.

Contrairement à Pascal, où PROCEDURE et FUNCTION étaient des concepts séparés, SPL utilise une approche plus C-like où tout PROCEDURE peut être préfixé avec un type pour le transformer en une fonction. Conformément à la syntaxe des autres langages de type ALGOL, les types de paramètres étaient listés après le nom, pas en partie. Par exemple:

INTEGER PROCEDURE FACT(N); VALUE N; INTEGER N;

Déclare une fonction FACT qui prend une valeur N qui est un entier. Le VALUE indique que cette variable est également la valeur de retour de la procédure.

Bien que désapprouvés, ALGOL et Pascal ont autorisé le code à être étiqueté en utilisant un nom de début se terminant par deux points, qui pourrait ensuite être utilisé pour la cible des boucles et des GO TO instructions. Une différence mineure est que SPL exigeait que les noms d'étiquettes soient déclarés dans la section variable à l'aide du LABEL mot - clé.

SPL a ajouté à ce concept avec l' ENTRY instruction qui a permis à ces étiquettes d'être davantage définies comme des «points d'entrée» accessibles à partir de la ligne de commande. Les libellés nommés dans les instructions d'entrée étaient exposés au système d'exploitation et pouvaient être appelés à partir de la commande RUN. Par exemple, on pourrait écrire un programme contenant des fonctions de chaîne à convertir en majuscules ou minuscules, puis fournir des points ENTRY pour ces deux. Cela pourrait être appelé à partir de la ligne de commande sous la forme RUN $STRINGS,TOUPPER .

Types de données

Là où SPL diffère le plus sensiblement d'ALGOL, c'est que ses types de données sont très spécifiques à la machine, basés sur le format de mot big endian 16 bits de 3000 .

Le INTEGER type est un type signé 16 bits, avec 15 bits de valeur et le bit le moins significatif comme signe. DOUBLE est un entier 32 bits, pas un type à virgule flottante. REAL est une valeur à virgule flottante de 32 bits avec 22 bits pour la mantisse et 9 pour l'exposant, tandis que LONG est une valeur à virgule flottante de 64 bits avec 54 bits de mantisse et 9 bits d'exposant.

BYTE est utilisé pour le traitement des caractères, consistant en un mot machine de 16 bits contenant deux caractères de 8 bits. LOGICAL est un type booléen qui stocke un seul bit dans le bit le plus significatif . Il n'y a pas d'équivalent d'un PACKED modificateur que l'on trouve en Pascal, c'est donc LOGICAL un peu un gaspillage de mémoire.

Comme C, les données sont faiblement typées , les emplacements mémoire et le stockage variable sont des concepts mélangés, et on peut accéder aux valeurs directement via leurs emplacements. Par exemple, le code:

INTEGER A,B,C
LOGICAL D=A+2

définit trois variables entières de 16 bits, A, B et C, puis une valeur LOGIQUE, également une valeur de 16 bits. Le = , comme Pascal, signifie "est équivalent à", et non "obtient la valeur de", qui est utilisé := dans les langages de type Algol. Ainsi, la deuxième ligne indique "déclarer une variable D qui est dans le même emplacement mémoire que A + 2", qui dans ce cas est également l'emplacement de la variable C. Cela permet de lire la même valeur comme un entier via C ou une logique à travers D.

Cette syntaxe peut sembler étrange aux lecteurs modernes où la mémoire est généralement une boîte noire , mais elle a un certain nombre d'utilisations importantes dans la programmation de systèmes où des emplacements de mémoire particuliers contiennent des valeurs du matériel sous-jacent. En particulier, il permet de définir une variable qui pointe vers l'avant d'un tableau de valeurs, puis de déclarer des variables supplémentaires qui pointent vers des valeurs individuelles dans le tableau. Si l'emplacement de la table change, une seule valeur doit changer, l'adresse initiale et toutes les variables individuelles suivront automatiquement dans leurs décalages relatifs appropriés.

Les pointeurs ont été déclarés en ajoutant le POINTER modificateur à n'importe quelle déclaration de variable, et l'emplacement mémoire d'une variable déréférencé avec le @ . Ainsi INTEGER POINTER P:=@A déclare un pointeur dont la valeur contient l'adresse de la variable A, et non la valeur de A. @ peut être utilisé de part et d'autre de l'affectation; @P:=A met la valeur de A dans P, ce qui entraîne probablement un pointeur suspendu , @P:=@A fait pointer P vers A, tandis que P:=A met la valeur de A dans l'emplacement actuellement pointé par P.

De la même manière, SPL inclut la prise en charge de tableaux de type C dans lequel la variable d'index est un décalage de nombre de mots par rapport à l'emplacement de mémoire défini pour la variable initiale. Contrairement à C, SPL ne fournissait que des tableaux à une dimension et utilisait des parenthèses plutôt que des crochets. Les variables pouvaient également être déclarées GLOBAL , auquel cas aucune mémoire locale ne leur était réservée et le stockage était supposé être déclaré dans une autre bibliothèque. Cela reflète le extern mot - clé en C.

Les littéraux peuvent être spécifiés avec différents suffixes, et ceux sans suffixe sont supposés l'être INTEGER . Par exemple, 1234 serait interprété comme un INTEGER , tandis que 1234D était un DOUBLE . E noté a REAL et L a LONG . Les constantes de chaîne étaient délimitées par des guillemets doubles et les guillemets doubles dans une ligne étaient échappés par un deuxième guillemet double.

Les déclarations de variables peuvent utiliser des constantes pour définir une valeur initiale, comme dans INTEGER A:=10 . Notez l'utilisation de assign-to plutôt que is-a. En outre, SPL avait un EQUATE mot clé qui permettait de définir une chaîne de texte en tant que variable, puis remplaçait toutes les instances de cette variable dans le code par la chaîne littérale lors de la compilation. Ceci est similaire au const mot - clé en C.

Segmentation de la mémoire

Comme cela était courant à l'époque, le HP 3000 utilisait un modèle de mémoire segmentée orientée octets dans lequel une adresse était un seul mot de 16 bits, permettant au code d'accéder à jusqu'à 65 536 octets (ou comme ils l'appelaient, des «demi-mots» ). Pour permettre l'accès à de plus grandes quantités de mémoire, un système de mémoire virtuelle a été utilisé. Lors de l'accès à la mémoire, l'adresse 16 bits était précédée de l'une des deux valeurs de segment de 8 bits, une pour le code de programme (PB) et une autre pour les données variables. Le résultat était une adresse 24 bits. Ainsi, alors que chaque programme avait accès à un total de 128 Ko à tout moment, il pouvait échanger les segments pour accéder à un espace mémoire complet de 16 Mo.

SPL comprenait une variété de systèmes de support pour permettre aux programmes d'être facilement segmentés et ensuite rendre cette segmentation relativement invisible dans le code. Le mécanisme principal était d'utiliser la $CONTROL SEGMENT=asegmentname directive du compilateur qui définissait dans quel segment le code suivant devait être placé. La valeur par défaut était MAINLINESEG , mais le programmeur pouvait ajouter n'importe quel nombre de segments nommés supplémentaires pour organiser le code en blocs.

Autres caractéristiques

SPL incluait une fonction "d'extraction de bits" qui permettait un bidouillage simplifié . N'importe quel bit, ou chaîne de bits, dans un mot pouvait être accédé en utilisant la .(x:y) syntaxe, où x et y étaient les positions de bit de début et de fin de 0 à 15. Ainsi A.(8:15) renvoyé l'octet inférieur du mot stockant A. Ce format pourrait être utilisé pour diviser et fusionner les bits selon les besoins. De plus, des opérations supplémentaires ont été fournies pour les équipes et les rotations, et pourraient être appliquées à n'importe quelle variable avec & , par exemple A:=A & LSR(3) .

Exemple

Ce programme simple, issu de la version 1984 du manuel de référence, présente la plupart des fonctionnalités du langage SPL.

Le programme dans son ensemble est délimité entre BEGIN et END. . Il commence par la définition d'une série de variables globales, A, B et C, définit une procédure unique puis l'appelle vingt fois. Notez que la procédure n'a pas BEGIN et la fin de son propre parce qu'il ne contient qu'une seule ligne de code réel, X:=X*(Y+Z); le INTEGER X,Y,Z ne fait pas partie du code lui - même, il est indiquant le type des trois paramètres étant transmis dans la ligne ci - dessus et est considéré comme faisant partie de cette ligne.

 BEGIN
     INTEGER A:=0, B, C:=1;
     PROCEDURE N(X,Y,Z);
         INTEGER X,Y,Z;
         X:=X*(Y+Z);
     FOR B:=1 UNTIL 20 DO
         N(A,B,C);
 END.

Les références

Citations

Bibliographie

• Edler, Christopher (novembre 1995). "Le château le plus fort: la montée, la chute et la montée du HP 3000" . Le moteur analytique . 3 (1). ISSN   1071-6351 . Archivé de l'original le 3 février 2002.
• Vert, Bob (2004). HP3000 Evolution . Robelle .
• Manuel de référence du langage de programmation des systèmes (PDF) . Hewlett-Packard. Février 1984.