Système d'exploitation virtuel
Pourquoi un système d'exploitation virtuel ?
Celui qui a quelque peu travaillé sur des plates-formes différentes, même d'une famille identique, sait au combien il est pénible de devoir gérer les spécificités des systèmes d'exploitation. Bon nombre de logiciels ne sont pas disponibles sur des plates-formes non par manque d'intérêt mais plutôt du fait de la nécessité d'un portage sur une nouvelle plate-forme.
L'intérêt d'un système d'exploitation virtuel est de mettre à la disposition des informaticiens une interface système identique quelle que soit la plate-forme qui se fond sur un système d'exploitation réel. Les API étant identiques, le portage de l'applicatif est immédiat, même si des fonctions particulièrement avancées ont été employées.
Pour connaître les options d'exécution d'Up ! System, veuillez vous référer à la fiche Paramètres d'Up ! System.
Concepts du système d'exploitation virtuel
Calendrier
Les files d'attente permettent de gérer deux sortes de travaux : ceux s'exécutant qu'une seule fois et ceux s'exécutant périodiquement. Pour ce second cas, le plus simple est de se définir un calendrier spécifiant les dates et les périodes de déclenchement des travaux. Un calendrier est défini à partir de plusieurs période de calendrier. Une période de calendrier est définie par :
- Un jour de planification : tous les jours, toutes les semaines, toutes les deux semaines, tous les mois, tous les deux mois, tous les trois mois, tous les six mois ou tous les ans à partir d'un certain jour.
- Une date limite éventuelle du déclenchement périodique.
- Une heure d'exécution.
Nous pouvons éventuellement adjoindre une sous-période de déclenchement dans la journée de planification définie par :
- Une période de l'heure de planification.
- Une heure limite éventuelle du déclenchement périodique dans la journée de planification.
Après chaque exécution d'un travail périodique, celui-ci est remis dans la file d'attente pour la date de la prochaine planification.
Le type Calendrier d'Up ! Parallelism & Scheduling modélise les calendriers. Le type PeriodeCalendrier d'Up ! Parallelism & Scheduling modélise les périodes de calendrier.
Entrées-sorties
Les entrées-sorties sont modélisées par des variables du type Fichier d'Up ! System. Elles correspondent à des fichiers spéciaux. Il y a :
- L'entrée standard est modélisée par l'objet Clavier.
Cet objet permet de récupérer tout ce que l'utilisateur saisit au clavier, que le programme fonctionne en mode fenêtré ou non.
- La sortie standard est modélisée par l'objet Ecran.
Cet objet permet d'afficher des messages à l'utilisateur que le programme fonctionne en mode fenêtré ou non.
- Le journal traçant l'activité du programme est modélisé par l'objet Journal.
Cet objet permet de marquer dans le journal les grandes étapes de fonctionnement du programme, et, en particulier, de signaler les erreurs rencontrées.
Lorsque le programme fonctionne en mode batch, la sortie standard est automatiquement détournée dans le journal.
Le journal est donné par le paramètre Journal. Par défaut, il s'agit du fichier ${UPS_HOME}/log/ups.log en mode mono-poste ou ${UPS_HOME}/log/${UPS_USER}/ups.log en mode multi-postes.
- Le fichier de trace alimenté par le code de mise au point est modélisé par l'objet MiseAuPoint.
Il s'agit du fichier ${UPS_HOME}/log/nom du programme.map en mode mono-poste ou ${UPS_HOME}/log/${UPS_USER}/nom du programme.map en mode multi-postes.
- Le fichier de trace est uniquement alimenté si le programme est exécuté en mode mise au point activé par le paramètre MiseAuPoint=TraceApplication.
- L'imprimante standard est modélisée par l'objet Imprimante.
Cet objet permet de constituer un fichier de texte qui est spoulé vers l'imprimante par défaut.
Fichier
Un fichier est un élément d'un répertoire. Il est constitué d'une liste d'octets ordonnée. La taille de cette liste est sans limite, hormis la place disponible de l'unité dont fait partie le fichier. Un fichier sert à conserver des informations persistantes à l'exécution des programmes.
Un fichier porte un nom composé de caractères éditables et sans limite de taille. Il peut comporter des caractères non alpha-numérique tel le caractère espace. Seuls les caractères division / et division inversé \ ne sont pas acceptés.
Un fichier appartient à un utilisateur (son propriétaire) et possède des droits d'accès vis-à-vis de son propriétaire et de groupes d'utilisateur.
Un fichier est caractérisé par un chemin d'accès correspondant à la succession des répertoires y menant. Ce chemin d'accès est exprimé sous forme d'une chaîne de caractères et cite dans l'ordre :
- Le nom de l'unité.
- La cascade de répertoires menant au fichier. Les noms des répertoires doivent être séparés par le caractère division
/ ou le caractère division inversé \.
Le type Fichier d'Up ! System permet de lire et d'écrire dans des fichiers.
Pour connaître le contenu d'un répertoire, il faut utiliser la fonction ListerFichiers d'Up ! System. Celle-ci retourne la description de chaque fichier ou de chaque sous-répertoire d'un répertoire donné sous forme d'un objet du type FichierListe.
File d'attente
Avec une architecture logicielle classique, quand il y a une augmentation de l'usage du système d'informations, de nouveaux processus et de nouvelles tâches sont crées. La machine monte en charge linéairement avec le nombre de demandes, les temps de réponse s'accroissent en conséquence.
Dans le cas d'une politique autorisant une croissance souple (scalable growth), le mieux est d'employer des files d'attente gérant les demandes pour lisser la monter en charge de la machine. Les temps de réponse sont alors améliorés et la machine supportera une plus grande amplitude d'utilisateurs.
Une file d'attente permet à une tâche cliente d'y placer un travail de type Travail en spécifiant une contrainte temporelle d'exécution et une priorité. A chaque file sont associées des tâches la desservant. Les tâches sont créées dynamiquement en fonction de la demande, dans la limite d'un nombre maximal spécifique à chaque file.
Les tâches prélèvent les travaux un à un selon le planning établi et par ordre de priorité puis les exécutent. Les tâches clientes peuvent suivre l'état leur état d'avancement. Une fois terminés, le résultat des travaux est disponible.
Le type FileDAttente d'Up ! System modélise les files d'attente. Le type Travail d'Up ! System modélise les travaux dans les files d'attente.
Journal
Up ! Application System comporte un journal applicatif correspondant à l'API Journal dans lequel peuvent être écrits tous les événements remarcables.
Up ! Application System comporte également des journaux spécialisés pour tracer l'activité des modules suivants :
- Up ! Archive.
- Up ! Com.
- Up ! Content Service.
- Up ! Corba.
- Up ! Debugger.
- Up ! File Transfer Service.
- Up ! Java.
- Up ! Kernel.
- Up ! Mail Service.
- Up ! Network.
- Up ! Object Management System.
- Up ! Security Manager.
- Up ! System.
Pour plus de précisions, merci de se référer à la fichier Journaux d'exploitation.
Instance
Utilité des instances
Supposons qu'un applicatif soit conçu sur une architecture client-serveur. Par principe, un serveur traite plusieurs clients. Le temps qu'un client travaille, le serveur peut traiter le demande de plusieurs autres clients.
Dans le cadre d'un applicatif complexe, les demandes successives d'un même client ne sont pas indépendantes. En effet, il existe une relation de causalité ce qui demande de gérer un contexte par client regroupant des informations persistantes entre deux demandes. Ce contexte regroupe un ensemble de variables traduisant l'état du client. Nous pouvons y trouver :
- Une session à une base de données.
- Une transaction en cours.
- La liste des dernières actions effectuées.
Up ! System possède le mécanisme d'instances pour gérer automatiquement le contexte d'un client lors de l'écriture du programme du serveur. Une instance correspond au contexte d'exécution d'un client particulier du serveur. Up ! System possède des API pour créer une nouvelle instance lorsque le client se connecte au serveur (CreerInstance), pour changer d'instance lorsqu'il est nécessaire de traiter la demande d'un client (CommuterInstance) ou terminer une instance lorsque le client se déconnecte du serveur (ArreterInstance).
Le principe des instances est bien différent de celui d'une tâche : une instance permet de faire de la sérialisation alors qu'une tâche permet de faire du parallélisme.
Quand l'applicatif est multi-instance, il reste à signifier à Up ! Application System quelles sont les informations propres à une instance et quelles sont celles qui sont partagées. Cela se résout aisément au moyen du mode de partage des segments de données.
Mode de partage des mémoires
Un module comporte des mémoires dans lequel sont regroupées les variables et les références vers les objets particuliers de chacun de ces composants : exceptions, files d'attente, entrepôts, types, etc. Ces mémoires sont de trois sortes :
- Le segment de données publiques commun à tous les composants du module.
Il regroupe toutes les variables publiques et les objets particuliers publics du module. Ces données ont été déclarées par le qualificatif Public dans le source Up ! 5GL. Ce segment est identifié par l'instruction SegmentPublic.
- Le segment de données protégées propre à composants du module.
Il regroupe toutes les variables protégées et les objets particuliers protégés du module. Ces données ont été déclarées par le qualificatif Protege dans le source Up ! 5GL. Ce segment est identifié par l'instruction SegmentProtege.
- Le segment de données privées propre à composants du module.
Il regroupe toutes les variables privées et les objets particuliers privés du module. Ces données ont été déclarées par le qualificatif Prive dans le source Up ! 5GL. Ce segment est identifié par l'instruction SegmentPrive.
Chaque segment de mémoire peut être qualifié selon le mode de partage voulu en fonction de ce qui doit être ou non mis en commun par deux instances gérées par un même processus ou par deux instances gérées par deux processus d'un même programme :
- Le mode de partage MemoirePrivee signifie que chaque instance possède sa propre copie du segment de données. Ainsi les données ne sont pas partagées d'une instance à l'autre.
- Le mode de partage MemoireProtegee signifie que chaque processus possède sa propre copie du segment de données. Ainsi les données ne sont pas partagées entre deux instances de deux processus différents mais sont partagées par deux instances du même processus.
- Le mode de partage MemoirePublique signifie qu'il existe qu'une seule copie du segment de données pour tous les processus. Ainsi les données sont partagées entre deux instances d'un même processus ou de deux processus différents.
Par défaut, le mode de partage d'un segment de mémoire est MemoireProtegee.
Journaux
Au cours de l'exécution du programme, Up ! Virtual Technical Machine peut alimenter des journaux reportant l'activité du processus.
Il ne faut pas confondre ces journaux avec les journaux mémorisant les modifications apportées aux objets des entrepôts persistants. Ceux-ci servent pour le mécanisme de reprise en cas d'arrêt brutal d'un programme persistant.
Processus
Pour Up ! System, un programme a deux états :
- L'état inerte : il n'est pas en cours d'exécution.
- L'état actif : il est cours d'exécution.
Un même programme peut être exécuté simultanément par plusieurs utilisateurs sur un même ordinateur ou sur différents ordinateurs. Chaque exécution forme alors un processus caractérisé par :
- Le fichier mémorisant le programme dont il est issu.
- Des zones mémoire utilisées par le code et les données du programme (segments de code, segments de données et segment de pile).
- Une priorité d'exécution.
Un processus est identifié de manière unique par le couple (numéro de la machine, numéro du processus).
La variable NumeroProcessus contient le numéro du processus du programme courant.
Pour connaître les programmes en cours d'exécution, il faut utiliser la fonction ListerProcessus d'Up ! System. Celle-ci retourne la description de chaque processus de la machine courante sous forme d'un objet du type ProcessusListe.
Répertoire
Pour Up ! System, les unités de stockages sont organisées en hiérarchies. Chaque niveau d'une hiérarchie est un répertoire. Il n'y a pas de limite quant à la profondeur de la hiérarchie. La base de cette hiérarchie pour une unité donnée est le répertoire racine symbolisé par le caractère division / ou le caractère division inversé \.
Un répertoire porte un nom composé de caractères éditables et sans limite de taille. Il peut comporter des caractères non alpha-numérique tel le caractère espace. Seuls les caractères division / et division inversé \ ne sont pas acceptés.
Un répertoire appartient à un utilisateur (son propriétaire) et possède des droits d'accès vis-à-vis de son propriétaire et de groupes d'utilisateur.
La variable RepertoireTmp contient le répertoire où doivent être créés les fichiers temporaires. Sa valeur provient du paramètre tmp.
Synchronisation
Utilité des synchronisations
Si plusieurs tâches cohabitent, d'un même ou de plusieurs processus, alors celles-ci partagent des données et des ressources communes. Les synchronisations d'Up ! System sont nécessaires pour garantir un bon fonctionnement de l'applicatif. Il y en a de deux types :
- Les synchronisations automatiques.
Elles sont employées par Up ! Object Management System pour gérer par exemple :
- L'accès à la table des entrepôts de mémoire.
- L'accès à chaque objet.
- Les synchronisations fonctionnelles.
Elles permettent par exemple de gérer les cas suivants :
- Des données ne doivent pas être utilisées par une tâche alors qu'une autre est en train des mettre à jour. Il s'agit de gérer une concurrence d'accès.
- Une ressource ne doit pas être utilisée simultanément par plusieurs tâches. Il s'agit de gérer un accès exclusif.
Le type Synchronisation d'Up ! System permet gérer les synchronisations fonctionnelles des tâches. Il permet en particulier d'en créer de spécifiques. Pour prendre une synchronisation, il suffit d'appeler la méthode Prendre. Si la synchronisation a déjà été prise par une autre tâche, alors la tâche est suspendue temps que la synchronisation n'est pas lâchée et que ce n'est pas son tour de la prendre : la file des tâches en attente sur une synchronisation est gérée Premier Arrivé Premier Servi i.e. First In First Out (FIFO).
Pour lever une synchronisation préalablement posée, il suffit d'appeler la méthode Lacher.
Levées automatiques des synchronisations
En règle générale, les synchronisations sont levées lors de l'appel à la méthode Lacher. Cependant, il se peut qu'il existe un imprévu aie lieu dans le programme suite à une exception ou suite à un dysfonctionnement. En ce cas, des synchronisations prises par la tâche essuyant cet imprévu sont automatiquement levées. Voici de tels cas de figure :
- Les objets locaux à un appel sont automatiquement détruits à la fin de cet appel s'il n'y plus aucune référence envers eux.
La destruction d'un objet de type Synchronisation cause la levée automatique de la synchronisation.
- Une exception est envoyée.
Les objets locaux sont automatiquement détruits s'il n'y plus aucune référence envers eux pour chaque appel dépilé ne rattrapant par cette exception. La destruction d'un objet de type Synchronisation cause la levée automatique de la synchronisation.
- La tâche est arrêtée par l'appel à la méthode ArreterTache.
Toutes les synchronisations posées par la tâche sont automatiquement levées.
- Le programme est arrêté par l'appel à la procédure ArreterProgramme.
Toutes les synchronisations posées par toutes les tâches du programme sont automatiquement levées.
- Le programme est arrêté suite à un dysfonctionnement.
Toutes les synchronisations posées par toutes les tâches du programme sont automatiquement levées.
Tâche
Définition d'une tâche
Un processus est constitué de plusieurs tâches s'exécutant en parallèle. Une tâche est un traitement unitaire autonome. Il existe deux sortes de tâches :
- Les tâches créées par l'utilisateur. Il y a en particulier la tâche principale correspondant à l'exécution de la fonction Principal.
- Les tâches propres à Up ! Virtual Technical Machine.
Chaque tâche est caractérisée par :
- La fonction dont elle est issue.
- Un état instantané constitué de la valeur des registres du processeur et l'index de l'instruction en cours d'exécution.
- Une priorité d'exécution relative à la priorité d'exécution du processus.
La variable TachePrincipale d'Up ! System identifie la tâche principale du processus.
Le type Tache d'Up ! System permet gérer les tâches des processus. Il permet en particulier d'en créer de spécifiques.
Tâches propres à Up ! Object Management System, Up ! Object Request Broker et Up ! System
Up ! Object Management System comporte des tâches spécifiques. Ces dernières sont listées dans le document Architecture d'un processus d'un programme en technologie Up ! Virtual Technical Machine.
Up ! System comporte des tâches servant à gérer :
- Les alarmes.
- Les files d'attente et les calendriers.
Unité de stockage
Up ! System reconnaît les unités de stockage formatées qui sont en ligne au moment de l'exécution d'un programme Up ! Application System. Ces unités de stockage peuvent être :
- Des disques durs locaux à l'ordinateur ou partagé depuis un autre ordinateur.
- Des unités de disquettes ou de Cd-Rom.
Pour connaître les unités de stockage disponibles, il faut utiliser la fonction ListerUnites d'Up ! System. Celle-ci retourne la description de chaque unité sous forme d'un objet du type UniteListee.
Ces informations vous seront particulièrement utiles pour écrire un module d'installation ou de configuration de votre applicatif.
Variable environnement
Une variable environnement est une entité définie pour la session courante. Cette entité possède un nom et une valeur. Généralement, leur nom est en majuscule. Pour obtenir, la valeur d'une variable environnement, il suffit de précéder son nom du caractère dollar $.
On peut définir autant de variables environnement que nécessaire.
UPS_HOME, UPS_PATH et UPS_USER sont des variables environnement. Elles alimentent respectivement les variables UpsHome, UpsPath et UpsUser.
Up ! System met à la disposition des programmes les pseudo variables environnement suivantes :
| Variable | Signification |
| SYSTEM_HOME | Répertoire d'installation du système d'exploitation. |
| UPS_APPLICATION | Identifiant de l'application au sein de Up ! Virtual Technical Machine. |
| UPS_HOME | Répertoire d'installation d'Up ! Application System. |
| UPS_LANGUAGE | Identifiant de la langue au sein de Up ! Virtual Technical Machine. |
| UPS_NLS | Liste des chemins d'accès aux ressources linguistiques d'Up ! Application System. |
| UPS_PATH | Liste des chemins d'accès aux exécutables d'Up ! Application System. |
| UPS_PS1 | Préfixe de première saisie au clavier d'Up ! System. |
| UPS_PS2 | Préfixe de n-ième saisie au clavier d'Up ! System. |
| UPS_PROJECT | Identifiant du projet au sein de Up ! Virtual Technical Machine. |
| UPS_SESSION | Identifiant unique d'un tâche au sein de Up ! Virtual Technical Machine. |
| UPS_USER | Identifiant de l'utilisateur au sein de Up ! Virtual Technical Machine. |
Ces variables sont uniquement utilisables en lecture.
Elles peuvent être également employées dans la valeur de tous les paramètres de tous les modules de Virtual Technical Machine dont la sémantique correspond à un nom de répertoire ou de fichier.
En ce cas, le nom de la variable doit être écrit entre caractères accolade ouvrante { et accolade fermante } et précédée du caractère dollar $. Voici un exemple :
Tmp=${UPS_HOME}/demo/tmp/${UPS_USER}