WEBVTT

00:07.490 --> 00:13.700
Dans le deuxième exemple, je vais vous montrer comment un processus peut importer une mémoire externe, disons

00:13.940 --> 00:18.440
un fichier texte sur le disque, dans son espace d'adressage virtuel.

00:18.690 --> 00:19.250
D'accord.

00:19.250 --> 00:22.640
Puis effectuer certaines opérations sur cette mémoire virtuelle.

00:22.850 --> 00:28.460
Toutes les modifications apportées par le processus à cette mémoire virtuelle seront finalement répercutées dans

00:28.460 --> 00:31.250
la mémoire externe, c'est-à-dire dans le fichier texte.

00:31.700 --> 00:32.300
D'accord.

00:32.300 --> 00:35.420
Voici donc l'exemple que nous allions aborder.

00:35.600 --> 00:41.780
Dans l'exemple suivant, je vous montrerai comment plusieurs processus peuvent importer le même fichier

00:41.780 --> 00:48.170
externe dans leurs espaces d'adressage virtuels respectifs et finalement mettre en œuvre le concept de mémoire

00:48.170 --> 00:49.190
partagée.

00:49.220 --> 00:51.830
Pour l'instant, laissons de côté la mémoire partagée.

00:53.510 --> 00:56.570
Me voici donc dans le fichier et le fichier de cartes, d'accord.

00:56.570 --> 00:57.820
Démocratie.

00:58.790 --> 01:07.370
Dans cet exemple, j'ai simplement choisi un étudiant structurel dans lequel j'ai ces champs.

01:07.940 --> 01:08.540
D'accord.

01:08.720 --> 01:15.170
Je vais donc commencer par ouvrir notre fichier, le fichier texte, qui se trouve

01:15.170 --> 01:17.030
sur le disque dur.

01:17.300 --> 01:23.300
Pour exécuter ce programme, l'utilisateur doit donc spécifier le chemin d'accès au fichier sur le disque dur,

01:23.300 --> 01:28.070
qui est situé sur le disque dur, puis ouvrir le fichier à l'aide de l'appel système open.

01:28.610 --> 01:29.150
D'accord.

01:29.360 --> 01:34.760
Et comme nous allons effectuer des opérations de lecture et d'écriture sur le fichier, il faut donc

01:34.760 --> 01:35.840
passer ce drapeau.

01:37.790 --> 01:41.660
Le fichier a donc été ouvert à l'aide de l'appel système open.

01:41.900 --> 01:48.860
Maintenant, ce que nous allons faire, c'est que la prochaine chose à faire est d'extraire la taille

01:48.860 --> 01:50.180
du fichier.

01:51.410 --> 01:58.310
Dans ce cas, le fichier que j'allais utiliser est file ou txt, et il ne doit pas s'agir d'un fichier vide.

01:59.300 --> 02:06.470
Créez un fichier texte sur votre disque et insérez-y n'importe quelle donnée indésirable afin que ce fichier occupe

02:06.470 --> 02:08.660
un espace fini sur le disque.

02:08.780 --> 02:14.120
Dans mon cas, j'ai simplement inséré certains espaces dans ce fichier et rien de plus.

02:17.300 --> 02:25.430
Supposons que j'ouvre le fichier et que je supprime tout ce qui s'y trouve, et que j'insère simplement des espaces ou des blancs, tout

02:25.430 --> 02:28.370
ce que vous pouvez insérer dans ce fichier.

02:28.700 --> 02:33.110
Notre objectif est que ce fichier occupe un espace fini sur le disque.

02:33.110 --> 02:36.560
Dans ce cas, il faut donc 539 octets.

02:37.370 --> 02:43.640
L'étape suivante consiste à extraire la taille du fichier.

02:43.820 --> 02:45.390
Comment faire ?

02:45.410 --> 02:49.100
Nous prenons simplement une variable de type struct stat.

02:49.820 --> 02:50.400
D'accord.

02:50.410 --> 02:53.350
Il suffit ensuite d'appeler la fonction F start.

02:53.930 --> 03:00.130
Tout ce que nous essayons de faire, c'est d'extraire la taille du fichier et donc, après

03:00.140 --> 03:07.990
cet appel à stat, la taille du fichier peut être utilisée en utilisant la variable SD size de la barre stat.

03:08.000 --> 03:11.330
Vous obtiendrez ainsi la taille du fichier présent sur le disque.

03:13.130 --> 03:20.450
Ainsi, en connaissant la taille du fichier présent sur le bureau et le fichier a déjà été

03:20.450 --> 03:21.160
ouvert.

03:21.170 --> 03:26.120
Ce descripteur de fichier représente donc la mémoire externe présente sur le disque.

03:26.120 --> 03:29.890
Dans ce cas, il s'agit d'un fichier texte, mais il peut s'agir de n'importe quoi.

03:29.900 --> 03:35.420
Il peut s'agir de votre carte SD, de la mémoire de votre appareil photo, de n'importe quoi.

03:36.110 --> 03:38.360
L'appel au système ouvert est un appel très générique.

03:38.360 --> 03:44.450
Il peut être utilisé non seulement pour ouvrir un fichier texte, mais aussi pour ouvrir n'importe quelle ressource matérielle

03:44.450 --> 03:47.570
qui est de toute façon attachée à votre système.

03:48.590 --> 03:55.490
Maintenant que je connais la taille du fichier et que j'ai déjà le descripteur du fichier ouvert, je suis

03:55.490 --> 04:03.320
en mesure d'exporter le fichier texte externe présent sur le disque en tant que mémoire virtuelle dans l'espace d'adressage

04:03.320 --> 04:05.840
virtuel de mon processus.

04:06.170 --> 04:08.750
Une fois de plus, je passerai le pointeur null ici.

04:09.170 --> 04:15.440
Je transmettrai la taille du fichier parce que je veux importer le fichier entier dans mon monde, dans mon processus, dans l'espace

04:15.440 --> 04:16.730
d'adressage virtuel.

04:16.940 --> 04:19.940
Et je veux effectuer des opérations de lecture et d'écriture sur le fichier.

04:19.940 --> 04:26.150
Passez donc les deux drapeaux à chaque fois que vous devez effectuer une opération d'écriture.

04:27.490 --> 04:34.360
Maintenant, si mon programme fait des modifications dans la mémoire culturelle qui serait retournée par l'appel système

04:34.360 --> 04:40.810
map et si vous voulez que ces modifications se reflètent dans le fichier texte qui est présent sur ce disque, alors

04:40.810 --> 04:43.900
vous devez passer ici la valeur map shared.

04:43.990 --> 04:46.570
Vous ne pouvez pas passer la carte en privé.

04:46.720 --> 04:53.170
Que vous souhaitiez ou non partager cette mémoire virtuelle particulière avec d'autres processus, toutes les modifications

04:53.170 --> 05:00.580
effectuées par votre programme dans la mémoire virtuelle de la carte seront reflétées dans le fichier texte sur le disque.

05:00.730 --> 05:04.330
Très bien, dans ce cas également, le partage de la carte doit être adopté.

05:04.780 --> 05:10.180
Il faut ensuite passer le pointeur, puis la valeur du descripteur de fichier de la ressource externe, qui est

05:10.180 --> 05:10.930
un fichier.

05:11.110 --> 05:13.900
Le dernier argument peut être égal à zéro.

05:14.020 --> 05:19.180
Le dernier argument est l'offset dans le fichier texte à partir duquel le mapping doit être commencé.

05:19.390 --> 05:27.370
Il se peut que vous ne souhaitiez importer que la dernière ligne du fichier texte sur le disque.

05:27.970 --> 05:28.540
D'accord.

05:28.570 --> 05:33.730
Ou bien vous voulez importer dans votre processus la moitié seulement du fichier présent sur le disque, ce qui permet de

05:33.730 --> 05:34.690
gagner de l'espace.

05:35.050 --> 05:37.800
Il faut donc passer cette valeur ici.

05:37.810 --> 05:44.350
Cette valeur représente le décalage en termes d'octets dans le fichier texte.

05:45.010 --> 05:46.900
Il s'agit donc à nouveau d'une condition d'erreur.

05:46.900 --> 05:53.800
Et une fois que l'appel au système de cartographie a réussi, vous pouvez toujours fermer le descripteur de fichier d'une

05:53.800 --> 05:54.980
ressource externe.

05:55.000 --> 05:57.370
Ce descripteur de fichier n'est plus nécessaire.

05:57.760 --> 05:58.330
D'accord.

05:58.420 --> 06:04.060
Nous avons déjà réussi à importer la mémoire externe en tant que mémoire virtuelle dans le processus.

06:04.060 --> 06:05.440
Espace d'adressage virtuel.

06:06.220 --> 06:09.660
J'ai maintenant une mémoire qui a été allouée à mon programme.

06:09.670 --> 06:12.250
Je peux faire ce que je veux de cette mémoire.

06:12.310 --> 06:18.440
Je me contente donc d'initialiser la structure et d'utiliser mon opération CP VI.

06:18.460 --> 06:25.420
J'écris les informations dans ce fichier ou cette mémoire mappée.

06:25.960 --> 06:32.860
C'est donc ici que se produit la modification des pages de mémoire virtuelle importées.

06:33.670 --> 06:38.860
Ainsi, selon ce diagramme, vous avez modifié ces pages de mémoire virtuelle de couleur verte.

06:39.250 --> 06:39.880
D'accord.

06:40.000 --> 06:45.430
Ces changements se répercutent immédiatement sur les pages physiques chargées dans la mémoire

06:45.430 --> 06:49.780
vive, mais le fichier texte externe n'a pas encore été modifié.

06:50.350 --> 06:54.340
Pour cela, vous devez appeler le système MX Sync.

06:54.970 --> 07:01.270
Dès que vous appelez le système AMP Sync, les pages physiques chargées dans la RAM synchronisent

07:01.270 --> 07:06.580
leur contenu avec la mémoire externe qui a été mappée.

07:07.540 --> 07:15.580
Une fois les modifications envoyées, vous pouvez détruire les pages de mémoire virtuelle importées à l'aide

07:15.580 --> 07:17.590
de l'appel système map.

07:18.130 --> 07:18.580
D'accord.

07:18.580 --> 07:19.710
Et le tour est joué.

07:19.720 --> 07:23.230
Permettez-moi maintenant d'exécuter ce programme et de vous montrer la démonstration.

07:24.520 --> 07:34.960
Donc, comme je l'ai dit, je vais utiliser le fichier demo text comme mémoire externe et ce fichier est vide.

07:35.140 --> 07:41.590
Remarquez donc que la taille de ce fichier sur le disque doit être une valeur finie, qui est de 539 octets.

07:42.010 --> 07:44.320
J'ai compilé mon programme.

07:47.190 --> 07:51.510
Qui est map file write demo two dot C.

07:53.770 --> 07:58.150
Je vais exécuter l'exécutable et passer.

07:59.250 --> 08:02.130
Le fichier demo two dot txt comme argument.

08:03.000 --> 08:06.030
Voyons maintenant quel est le contenu de ce fichier.

08:08.490 --> 08:15.420
Nous pouvons donc voir que vous avez imprimé Abhishek et Bangalore conformément aux informations, au numéro de matricule

08:15.420 --> 08:18.150
et au masque, car il s'agit de données binaires.

08:18.420 --> 08:22.950
Ils ont donc été imprimés dans le fichier au format binaire, que vous ne pouvez pas lire.

08:23.160 --> 08:28.680
Ainsi, dans un fichier texte, si vous écrivez des données binaires, vous ne pourrez pas les lire.

08:30.030 --> 08:32.820
Mais vous avez compris que notre programme fonctionne bien.

08:33.090 --> 08:33.750
D'accord.

08:34.530 --> 08:39.270
Nous avons donc importé avec succès la mémoire externe, qui est un fichier texte dans le processus, l'espace d'adressage

08:39.270 --> 08:41.080
virtuel à l'aide d'une carte.

08:41.100 --> 08:43.620
Nous avons écrit les données dans cette mémoire virtuelle.

08:43.830 --> 08:47.460
Nous avons ensuite détruit cette cartographie à l'aide d'un appel de carte.

08:47.490 --> 08:52.410
Nous synchronisons l'ensemble des données de la mémoire physique avec le fichier externe à l'aide de HM sync.

08:52.410 --> 08:58.710
Enfin, nous vérifions manuellement ce qui se trouve dans notre fichier texte et nous constatons que les données s'y trouvent.

08:58.860 --> 09:01.050
Notre programme fonctionne donc parfaitement.
