Exercice Systeme exploitation

Bonjour à tous,
Je voudrais que vous m'aidiez à résoudre le challenge suivant (Un vrai challenge pour moi qui suis débutant en informatique):
"Soit une matrice de n lignes et t colonnes qui représente la mémoire.Les 2 premières lignes sont occupées par le système d'exploitation.Les lignes 5 et 6 sont censées être occupées.A partir de la 3émé ligne,à chaque fois qu'un job arrive et demande de la place mémoire,ce job est divisé en page de 2 lignes représentées par exemple comme suit: 7 lignes représentées par 4 pages.On crée une table par job avec nombre de lignes = nombre de pages.
On crée une autre table (image mémoire).Le nombre de lignes = n (nombre de lignes de la matrice) avec "l" pour les entrées libres et "o" pour les entrées occupées.
Il faut remplir et libérer la matrice,et faire la mise à jour des tables.Lorsqu'un job arrive,et s'il y'a suffisamment de blocs libres (adjacents ou pas),on met le job en mémoire avec la mise à jour,sinon on attend qu'un autre job se termine.On doit utiliser le langage turbo pascal.On peut choisir n'importe quel exemple pour les job.
Je vous remercie pour votre aide.

Tu demandes de l'aide, je vais donc essayer de te donner des pistes pour t'aider à trouver la solution par toi même.
Tout d'abord, je vais t'aider à analyser le sujet. Essaie de voir si ça peut te débloquer, d'en déduire la marche à suivre pour le programme lorsqu'un job se présente et lorsqu'il repart. Prends le temps de chercher en profondeur, sinon un exercice ne sert à rien. Si vraiment tu ne trouves pas, alors je t'aiderai pour cette marche à suivre ;)

---

Un croquis, même sommaire, peut aider à visualiser les choses dans les problèmes liés à des matrices (même en maths d'ailleurs), j'en ai donc fait un petit :
http://img29.imageshack.us/img29/1355/croq.th.jpg

Ceci est ta mémoire. Nous constatons en examinant le sujet que pour l'allocation des pages en mémoire, le nombre de colonnes n'intervient jamais. On se ramène donc pour l'image mémoire à un modèle simplifié à une seule dimension, comme dans le sujet :
http://img200.imageshack.us/img200/8494/dim1.th.jpg

Considérons maintenant les autres éléments qu'on peut extraire du sujet
=> Quand un nouveau job se pointe, il doit obtenir la mémoire dont il a besoin si elle est disponible. Sinon, il doit être mis en attente (et nous devons donc stocker quelque part une sorte de salle d'attente pour job insatisfaits).
=> Les tables de mémoire et d'image mémoire doivent rester synchronisées pour que les jobs entrants n'aillent pas piquer la mémoire des autres - et ne manquent pas de mémoire alors que celle-ci est disponible.
=> Lorsqu'un job se termine, on doit pouvoir libérer la mémoire qui lui est liée. Or, l'image mémoire ne précise pas à quel job appartiennent les blocs mémoire alloués. Il faut donc garder en mémoire, pour chaque job en cours, les blocs mémoires qui lui sont alloués, dans une structure séparée de l'image mémoire.
=> Par ailleurs, lorsqu'un job se termine, il faut aussi vérifier qu'il n'y a pas de job en attente qui pourrait se contenter de la mémoire disponible.

Merci d'abord pour votre réponse.
J'ai compris pour la représentation graphique et je voudrais si possible que vous m'expliquiez: 1)comment déclarer un job au niveau de la mémoire? 2) Doit-il être déclaré en tant qu'entier,ou chaine de caractères? 3)Comment le faire entrer,le mettre en attente et le sortir?Avec quelles instructions en Turbo pascal?
4) Pour mettre un job en attente,dois-je déclarer une file d'attente et l'y mettre?
5)Enfin comment lui allouer un quantum de temps éventuellement?
Je sais que ça fait beaucoup de questions,et je voudrais que vous m'aidiez pas à pas,car ja n'arrive pas à cerner concrètement le problème posé.Merci.:cry:

1, 2, et 4/Alors pour tes jobs, si j'ai bien suivi tu as le choix de la manière dont tu les représente, la quantité de mémoire qu'ils occupent ne varie pas au cours du temps, et tu travailles sur un système d'exploitation déjà existant (windows, mac, unix...) même si le but est d'étudier la conception d'un nouveau.

Je te propose donc pour le job un modèle simpliste mais efficace : un fichier sur le disque.
Tu as en effet

• Un nom de fichier pour l'identifier.
• Une série d'octets le composant qui représente la mémoire initialement occupée.
• La taille qu'il occupe est normalement donnée par le système.

C'est tout ce que la mémoire a besoin de savoir sur les jobs entrants et sortant.

Pour les jobs en attente, il faudra créer un enregistrement (RECORD) contenant le nom d'un job et le nombre de pages mémoires qu'il requiert (histoire d'éviter de le recalculer à chaque fois, ce n'est pas utile), et créer un tableau de variables de ce type en variable globale.

Comme les jobs vont et viennent un peu aléatoirement, tu préféreras sans doute garder aussi sous la main une variable entière indiquant le premier emplacement libre dans le tableau, et remplacer le nom d'un job qui part de la file d'attente par la chaîne vide '' pour savoir que l'emplacement est libre.

Pour les jobs en cours d'exécution, un autre RECORD, contenant le nom du job et les lignes (ou les pages) de la mémoire qu'il occupe, sera efficace. Mêmes remarques sur le regroupement en tableau.

3/Ton programme a essentiellement besoin de deux procédures : une pour faire entrer les jobs, et une pour les en faire sortir. Ces deux procédures n'ont besoin en paramètre que du nom du job.

Pour l'entrée, il faudra

• Trouver le nombre de pages mémoires dont le job a besoin
• Le comparer au nombre de pages réelles, en notant les numéros de pages (ou lignes) libres dans une variable temporaire.
• En fonction du résultat, mettre le job en attente (via le tableau qui précède) ou le faire entrer dans la mémoire.
• Pour le faire entrer dans la mémoire, noter dans l'image mémoire que les lignes qu'il requiert ne sont plus libres, puis copier, page par page, le contenu du fichier dans la matrice représentant la mémoire

(Je suis sûr que pour les instructions pascal tu peux trouver ;))

Pour la sortie, deux choses à considérer :

• Il est possible (et même très probable) que la zone mémoire utilisée par le job ait été modifiée au cours de son exécution. Il faudra se demander si on doit réécrire le job sur le disque dans son état modifié après.
• Il faudra aussi se demander si il faut réinitialiser toutes les pages mémoires occupées par le job avec des zéros, dans la matrice mémoire. C'est une tâche potentiellement très longue, donc normalement on évite, mais sur un système où la sécurité des données est importante (ex : militaire), il est important de savoir que le job qui prendra la place de l'actuel pourra potentiellement lire une partie de ses données, encore en mémoire et non écrasées par ses propres données, si on ne le fait pas

Quelle que soient les réponses, tu en déduis des choses à faire ou ne pas faire, puis

• Tu marques dans l'image mémoire les pages du processus comme libérées (et actualise le nombre de pages libres si tu tiens un compte de celles-ci)
• Tu regardes s'il n'y a pas un processus en attente qui peut se lancer.

5/A ce niveau, ce n'est plus de la gestion mémoire mais de l'ordonnancement (scheduling), donc je pense que tu t'écartes de ton sujet ;)

En gros, ça marche en utilisant un timer, qui exécute à un intervalle fixé une procédure chargée de changer de job si l'actuel a épuisé son quantum (ce que l'on sait au moyen d'une horloge, basée par exemple sur le nombre de cycles CPU exécutés depuis le lancement de la machine, et d'une variable stockant l'état de cette horloge lors du lancement du job actuel).

Bonjour,

Voilà, j’ai essayé de construire un programme avec les connaissances que je possède, mais plusieurs choses m’échappent .Je vous soumets mon travail et je compte sur votre patience pour m’aiguiller encore plus. En tant qu’apprenant, je sais que certaines évidences pour vous, ne le sont pas pour moi.
Merci.

Program s_e
Const n=10,p=10 ;
Type mat =array[1..n,1..p]of integer;
Var mem:mat;
Type tab=array[1..n]of integer;
Var im_m:tab;
Type job=record
Nom_fich: string;
Nb_oct:integer;
End;
Var fichier :file of job;
Assign(fichier,’joob’);{associer à la variable fichier le nom du fichier}
Rewrite(fichier) ; {ouvrir un fichier qui n’existe pas ou qui été réécrit }
Comment remplir le fichier : nom_fich et nb_octet ?
Reset (fichier) ;
Close (fichier) ;
Type job_exe=record ;
Nom_job :string ;
Nb_ligne_occ:integer;
End;
Var f: file of job_exe;
Comment attribuer les noms des job?
Procedure remplir_tab (var im_m :tab) ;
Var k :integer ;
Begin
For k:=1 to n do
Begin
(im_m[1],im_m[2],im_m[5],im_m[6]):=’o’;
(im_m[3],im_m[4],im_m[7],im_m[8]):=’L’;
End ;
End ;
Comment attribuer à un job une page de 2 lignes ?
Procedure entree ( var mem :mat,var im_m:tab);
Va r I,j: integer;
Begin
For i:=3 to n do
Begin
If im_m[k]= ‘L’ then
Mem[i]:= Dois-je écrire le nom du job ? Est-ce que cette instruction copie le job en mémoire
Par ex : j1 :110011
100011(groupe de 2 lignes comment vais-je mettre ce j1 en mémoire ?)
Mem[i] :=j1 ?
Par exemple, ce job 1, dois-il être déclaré J1 ou 110011 ou doit-il être déclaré par type (entier, ou chaine de caractère etc.…), pour que lors de la compilation ,le programme me demande le type du job ?
Im_m[k] :=’o’ ;
End
Else
La file d’attente : (Comment la déclarer ?écrire les fonctions ou procédures qui lui correspondent ?
Procedure sortie (var mem :mat ; var im_m :tab) ;
• Comment créer la table par job pour ecrire p.ex :
•
• n°ligne • page
• 3,4 • 0
• 7,8 • 1
• ……………………
• Comment faire la mise à jour des tables et le test de blocs mémoire libres (adjacents ou pas) ;
• Comment libérer la mémoire c.à.d. comment faire sortir le job ?et quels sont les testes nécessaires ? (aussi pour les jobs qui sont en attente).
:(

Monsieur Neolander,
Je n'ai pas lu votre avis concernant ma dernière réponse.Si vous pensez que mon niveau (débutant ),est trop basique et ne nécessite pas une attention de haut niveau,faites le moi savoir,pour que je puisse poser ma préoccupation sur d'autres forums,car c'est vrai je ne sais pas mettre un job en attente, ni la bonne façon de le déclarer,le faire entrer ,sortir, etc..J'ai beau me creuser les méninges ,je n'y arrive pas .Si vous pouvez au moins me montrer une fois,comment faire avec un exemple sur un seul job (par exemple,comment le déclarer,le faire entrer,le mettre en attente,et le sortir),j'essaierai de l'appliquer pour trois jobs ou plus à la fois.
Merci.

Bonjour et désolé.

J'ai moi aussi du travail, et il n'est pas spécialement en avance, d'où mon absence de ces derniers jours. Mais ce n'est pas par mépris pour ton niveau que je suis absent, n'aie crainte ;)

Les jobs que tu veux charger en mémoire sont avant tout des paquets d'octets. Quand je dis d'utiliser le nom de fichier, je voulais dire que tu pouvais stocker tes jobs sous la forme de fichiers. Exemple simple pour aider à comprendre :

Code:

---

1 2 3 4 5 6 7 8

const job : array[1..10] of byte = (25, 0, 87, 15, 96, 77, 97, 36, 115, 68); const nom_job = 'test'; var fichier : file of byte; Assign(fichier, nom_job); Rewrite(fichier); Write(fichier, job, 10); Close(fichier);

---

Ta gestion des jobs entrants pourrait ressembler à ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

const N = 10; {Nombre de colonnes de la matrice mémoire} const TAILLE_PAGE = 2; {Taille en lignes d'une page} const P = 10; {Taille en octets d'une ligne} Type mat =array[1..N,1..P] of byte; Var mem:mat; Type tab=array[1..N] of char; Var im_m:tab; var pages_libres : longint; {Contiendra le nombre de pages libres dans la mémoire} type job = RECORD {Désigne un job entrant, qu'il soit en attente ou non} Nom_fic : string = ''; Nb_pages : LongInt = -1; end; type job_exec = RECORD Nom_fic : string = ''; lignes_occup : array[1..N] of longint; {On stocke les numéros de lignes occupés en terminant par un zéro. Il y a plus efficient en utilisant des tableaux dynamiques, mais je ne sais plus si ils existent en turbo pascal} end; Type file_attente = Array [1..N/TAILLE_PAGE+1] of job; var file_att : file_attente; Type table_job = Array[1..N/TAILLE_PAGE+1] of job_exec; var jobs_en_cours : table_job; procedure Entrant(var job_entrant : job); var fichier : file of byte; place, reste_a_fournir, i, j : longint; trouve : boolean; begin if job_entrant.Nb_pages < 0 then begin Assign(fichier, job_entrant.Nom_fic); Reset(fichier, P*TAILLE_PAGE); job_entrant.Nb_pages := FileSize(fichier); Close(fichier); end; {A partir d'ici, on connaît la taille en pages du fichier} If pages_libres >= job_entrant.Nb_pages then begin {On a assez de pages dans la mémoire, il faut charger le job.} Assign(fichier, job_entrant.Nom_fic); Reset(fichier, P*TAILLE_PAGE); {Tout d'abord, il faut lui trouver une place dans la table des jobs en cours} place := 1; trouve := false; while not trouve do begin if jobs_en_cours[place].Nom_fic = '' then trouve := true; else place := place+1; end; jobs_en_cours[place].Nom_fic := job_entrant.Nom_fic; {Ensuite, il faut trouver les pages qu'il va occuper dans la mémoire et les remplir Nous faisons l'exploration de la mémoire page par page, puisqu'elle est attribuée par paquets de TAILLE_PAGE lignes.} reste_a_fournir := job_entrant.Nb_pages; i := 1; j := 1; while reste_a_fournir do {Tant qu'on a besoin de pages...} begin if im_m[i]='l' then begin for k:=1 to TAILLE_PAGE do begin {On marque les lignes concernées comme occupées} im_m[i]:='o'; jobs_en_cours[place].lignes_occup[j] := i; j:=j+1; i:=i+1 end; {/!\ ATTENTION /!\ J'ai déjà vu cette instruction employée ainsi quelque part, mais je n'ai aucune preuve que ça fonctionne vraiment. A TESTER IMPERATIVEMENT ! Si ça ne marche pas, tu devras lire octet par octet avec des boucles for...} BlockRead(fichier, mem[i][1], TAILLE_PAGE); {On charge la page concernée en mémoire} reste_a_fournir := reste_a_fournir - 1; end; i:=i+TAILLE_PAGE; end; jobs_en_cours[place].lignes_occup[j+1]:=0; {On indique que la liste des lignes occupées se termine ici} end else begin {Pas assez de place ! On met le job en attente, en commençant par lui chercher une place} trouve := false; while not trouve do begin if file_att[place].Nom_fic = '' then trouve := true; else place := place+1; end; file_att[place].Nom_fic := job_entrant.Nom_fic; file_att[place].Nb_pages := job_entrant.Nb_pages; end; end; {Initialisation des variables. Je me base sur mes connaissances en Delphi donc à vérifier par toi qui connais mieux TP que moi} var i : integer; begin for i:=1 to N do im_m[i]:='l'; im_m[1]:='o'; im_m[2]:='o'; im_m[5]:='o'; im_m[6]:='o'; pages_libres:=N-4; end.

---

Je te conseille de vérifier ce code, je ne l'ai pas testé donc il est potentiellement plein de fautes. De plus, il manque de gestion des exceptions (et si le fichier n'existe pas ? Et si le fichier est vide, auquel cas il prend 0 pages ? (j'ai supposé que tous les jobs prenaient au moins une page)). J'espère que ça t'aidera néanmoins.

Si tu te bases sur ce modèle, n'oublie pas...
-De libérer les zones de tableaux qui ne sont plus utilisés (une zone libre d'un tableau de job a pour nom '' et un nombre de pages négatif, une zone libre d'un tableau de job_exec a pour nom '', une zone libre de l'image mémoire est constituée de TAILLE_PAGE 'l' consécutifs...)
-D'actualiser pages_libres
-De créer une boucle principale du programme qui vérifie l'arrivée de jobs entrants de façon régulière si tu veux faire pro (FindFirst et FindNext de l'unité Dos peuvent être utilisées pour lister le contenu d'un dossier, après il faut voir si tout ce contenu est déjà lancé ou en file d'attente).
L'intérêt, c'est qu'après tu lances le programme et tu te contentes de bazarder des fichiers dans le répertoire des jobs pour voir si le programme les gère correctement.
Par contre, dans ce cas, il vaut mieux créer un sous-dossier là où il y a ton programme pour stocker les jobs, et modifier le programme pour qu'il cherche dans ce sous-dossier. Sinon, ça risque de mal finir...
-D'explorer la file d'attente lors de la sortie d'un job pour voir si un autre job peut se lancer

Pour donner des noms au job, un algo simple est de faire une chaîne qui commence par 'job' et qui se termine par un entier (à convertir en chaîne avec la fonction Str) que tu incrémentes à chaque nouveau job ;)

Pour les fonctions de manipulation de fichier utilisées (notamment le rôle des paramètres de Reset), je te renvoie ici pour plus d'info : http://tdprog.free.fr/pascal/cours/fichier.htm

Monsieur Neolander ,
Merci pour votre reponse qui m'a apporté beaucoup d'eclaircissements.J'ai concocté un essai de programme sous tp7,mais malheureusement,comme j'ai installé Vista sp1 à la place de XP,Turbo Pascal ne veut pas tourner.Il affiche les caracteres en Qwerty,ne veut pas s'ouvrir plein ecran,affiche le message "the system does not support full screen mode",et ne garde pas le travail enregistré.Apparemment,il y'a un probleme avec Vista.J'ai télechargé plusieurs versions de TP7 ,mais toujours le même probléme.Dois-je abandonner definitivement Vista pour la programmation en Pascal ?,ou existe t'il une version de turbo pascal compatible avec Vista?.
Si vous pouviez m'eclairer? Je suis impatient de verifier "mon programme".Merci .

Ces problèmes semblent lié à Vista, qui a un support des applications DOS... disons... plus perfectible encore que Windows XP. Une machine virtuelle de Win98/Me ou un émulateur DOS (DOSBox par exemple) pourraient faire l'affaire, si personne ne trouve de solution meilleure... :roll:

Merci! Je vais reinstaller xp et voir.:(

Monsieur Neolander, salut!

Merci pour le tuyau de DOSBOX.TP7 fonctionne sous Vista (en utilisant l'émulateur virtuel) et sauvegarde les projets crées.
Je vous adresse ci après le programme que j'ai pu faire et qui se compile normalement.Je vous saurai gré de m'aider à passer à l'étape suivante,à savoir comment gérer les jobs en attente et les faire sortir,J'ai essayé plusieurs procédures,mais aucune ne se compile.
Merci!!:?
Salut!
voici l'algorithme que j'ai fait:


-program tp_SE;
uses crt;
const n=6; m=14;
type matrice=array[1..m,1..n] of integer; {la matrice qui represente
la memoire}
type tableau=array[1..m] of integer;
type ptr=^element;
element=record
page:integer;
ligne:3..m;
suiv:ptr;
end;
var mem:matrice; nb_job:integer; test:tableau; tab_job:ptr;
procedure initialiser(var mem:matrice;var tab_job:ptr;var test:tableau);
var j,i:integer;
begin
tab_job:=nil;
for i:=3 to m do test[i]:=0;
for i:=1 to 2 do test[i]:=1;
for i:=1 to 2 do
for j:=1 to n do begin
mem[i,j]:=1;
end;
for i:=3 to m do
for j:=1 to n do begin
mem[i,j]:=0;
end;

end;
function espacelibre(test:tableau):integer;
var i:integer;
k:integer;
begin
k:=0;
for i:=3 to m do
if test[i]=0 then
k:=k+1;
espacelibre:=k;
end;
function saisie(test:tableau):integer;
var x:integer;
begin
repeat
readln(x);
until (x < espacelibre(test)) and (x mod 2=0);
saisie:=x;
end;
procedure insert(x:integer;var mem:matrice;var tab_job:ptr;var test:tableau);
var i,j:integer;
p:ptr;
begin
i:=3;
while (i<= x+2) do begin
test[i]:=1;
for j:=1 to n do mem[i,j]:=1;
if (i mod 2 <> 0) then begin
new(p); p^.ligne:=i; p^.page:=(i div 2);
p^.suiv:=tab_job; tab_job:=p;
end;
i:=i+1;
end;
end;
procedure affichage(tab_job:ptr; mem:matrice; test:tableau);
var i,j:integer;
begin
writeln(' LA MATRICE QUI REPRESENTE LA MEMOIRE');
writeln;
for i:=1 to m do begin
for j:=1 to n do
write(mem[i,j]:4);
writeln;
end;

writeln('Page Ligne');
writeln;
while tab_job <> nil do begin
write(tab_job^.page);
write(' ');
write(tab_job^.ligne);
writeln;
tab_job:=tab_job^.suiv;
end;
write('l''espace libre est:');
textcolor(12);
writeln(espacelibre(test));
textcolor(white);
end;
BEGIN
clrscr;
inisialiser(mem,tab_job,test);
affichage(tab_job,mem,test);
writeln('Entrez le nombre de JOB : ');
readln(nb_job);
nb_job:=nb_job*2;
if (nb_job<=12) then begin
insert(nb_job,mem,tab_job,test);
affichage(tab_job,mem,test);
end
else
begin
writeln(' Il n''y a pas assez de place pour ce job ');
writeln (' Il faut entrer une valeur inferieure ou égale au espaces libres');
writeln('Entrez le nombre de JOB : ');
readln (nb_job);
nb_job:=nb_job*2;
if nb_job<=espacelibre(test) then
begin
insert(nb_job,mem,tab_job,test);
affichage(tab_job,mem,test);
writeln ('Entrez le nombre de JOB ');
end
else
begin
writeln(' Il n''y a pas assez de place pour ce job ');
writeln (' Il faut entrer une valeur inferieure ou égale au espaces libres');
writeln('Entrez le nombre de JOB : ');
end;
end;
readln;
readln;
END.-comment je fais entrer 3jobs en minimum? quelle est la boucle nécessaire pour ça?
-comment je les fait sortir ?(c.a.d supprimer les job pour libérer les cases de la matrice memoire et de la table des jobs)
(p.ex:le 1er job entre,le 2éme aussi,le 3éme ne trouve pas de place,il m'affiche qu'il n'y a pas de place ,quel est le job que vs voulez supprimer(le faire sortir)?
-comment j'affiche la table des jobs que j'ai faits?

Citation:

---

Envoyé par hajerboug

-comment je fais entrer 3jobs en minimum? quelle est la boucle nécessaire pour ça?

---

Je n'ai rien compris :cry: Qu'est-ce que tu veux dire par "faire entrer trois jobs en minimum" ?

Citation:

---

Envoyé par hajerboug

-comment je les fait sortir ?(c.a.d supprimer les job pour libérer les cases de la matrice memoire et de la table des jobs)
(p.ex:le 1er job entre,le 2éme aussi,le 3éme ne trouve pas de place,il m'affiche qu'il n'y a pas de place ,quel est le job que vs voulez supprimer(le faire sortir)?

---

Alors pour les supprimer, il faut explorer la liste des lignes occupées par le job, les marquer comme libre dans l'image mémoire (mettre la valeur 1), et faire disparaître le job dans toutes les structures de données de ton allocateur qui y font référence (table des jobs notamment).

Il manque un truc important dans ta table de jobs, j'ai l'impression : comment tu fais pour savoir à quel job appartient chaque ligne de la mémoire ? Sans ça, la désallocation risque effectivement de se révéler un peu difficile... ;)

Citation:

---

Envoyé par hajerboug

-comment j'affiche la table des jobs que j'ai faits?

---

Deux méthodes. Une qui bouffe des cycles processeur, une qui bouffe de la mémoire.
Le CPU : Tu explores la table des jobs, tu notes les identifiants des jobs et éventuellement le nombre de pages/lignes qu'ils occupent dans une variable temporaire, tu affiches le résultat, tu détruis la variable.
La mémoire : Tu crées une autre table (enfin... ou plutôt une liste chaînée) recensant les jobs actuellement en mémoire et le nombre de pages/lignes qu'ils occupent, actualisée lors des entrées/sorties

Monsieur Neolander,

Merci pour votre aide.J'ai reussi tant bien que mal à compiler mon programme grace à vos conseils.Encore une fois merci!!!!!!!!!!!!!!:ccool: