Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
fait la question dépasse le cadre de docker : comment une bibliothèque
dynamique est-elle "chargée" en mémoire ? Elle apparaît quelque part dans
la mémoire virtuelle d'un processus ? Est-ce que ça implique qu'elle soit
chargée quelque part ou bien c'est une simple correspondance entre ces
adresses virtuelles et le fichier représentant la bibliothèque, en se
contentant d'utiliser le cache système au fur et à mesure que des pages
sont nécessaire ?
Et si ce fichier exécutable ou d'une bibliothèque est supprimé lors de
l'exécution, est-ce que ça pose un problème ou bien ce fichier est
considéré comme ouvert et à ce titre son contenu n'est pas supprimé tant
qu'un processus détient une référence à son descripteur ?
Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
fait la question dépasse le cadre de docker : comment une bibliothèque
dynamique est-elle "chargée" en mémoire ? Elle apparaît quelque part dans
la mémoire virtuelle d'un processus ? Est-ce que ça implique qu'elle soit
chargée quelque part ou bien c'est une simple correspondance entre ces
adresses virtuelles et le fichier représentant la bibliothèque, en se
contentant d'utiliser le cache système au fur et à mesure que des pages
sont nécessaire ?
Et si ce fichier exécutable ou d'une bibliothèque est supprimé lors de
l'exécution, est-ce que ça pose un problème ou bien ce fichier est
considéré comme ouvert et à ce titre son contenu n'est pas supprimé tant
qu'un processus détient une référence à son descripteur ?
Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
fait la question dépasse le cadre de docker : comment une bibliothèque
dynamique est-elle "chargée" en mémoire ? Elle apparaît quelque part dans
la mémoire virtuelle d'un processus ? Est-ce que ça implique qu'elle soit
chargée quelque part ou bien c'est une simple correspondance entre ces
adresses virtuelles et le fichier représentant la bibliothèque, en se
contentant d'utiliser le cache système au fur et à mesure que des pages
sont nécessaire ?
Et si ce fichier exécutable ou d'une bibliothèque est supprimé lors de
l'exécution, est-ce que ça pose un problème ou bien ce fichier est
considéré comme ouvert et à ce titre son contenu n'est pas supprimé tant
qu'un processus détient une référence à son descripteur ?
Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
Yliur , dans le message <q53jgd$nck$, a écrit :Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
Ah, les micro-optimisations pour rendre les catastrophes présentables.
fait la question dépasse le cadre de docker : comment une bibliothèque
dynamique est-elle "chargée" en mémoire ? Elle apparaît quelque part
dans la mémoire virtuelle d'un processus ? Est-ce que ça implique
qu'elle soit chargée quelque part ou bien c'est une simple
correspondance entre ces adresses virtuelles et le fichier représentant
la bibliothèque, en se contentant d'utiliser le cache système au fur et
à mesure que des pages sont nécessaire ?
Unix possède la notion d'appel système « mmap() », qui permet de faire
apparaître un fichier (ou équivalent) comme une zone dans l'espace
d'adresses virtuelles d'un processus. Si c'est en lecture seule, c'est
réalisé en faisant apparaître directement les pages du cache dans
l'espace d'adressage du processus. Il y a pas mal d'optimisation faite
là-dessus :
- Pour la lecture, les pages sont initialement marquées comme invalides,
ce qui fait que le processus, quand il y accède, déclenche une faute
de page, le truc qui d'habitude se termine par « segmentation fault ».
Mais cette fois-ci, c'est réglé pour que la faute de page conduise au
chargement de la page (et au chargement anticipé des pages suivantes)
avant de laisser le processus reprendre.
- Pour l'écriture, quand elle est autorisée, le mécanisme utilise
également des fautes de page. Il y a alors deux possibilités : si le
fichier est mappé en privé, le noyau alloue une page au processus,
comme n'importe quelle allocation mémoire, et y fait une copie de la
page en question (copy-on-write). S'il est mappé en partagé, la page
du cache est marquée comme modifiée et sera écrite sur disque.
Les exécutables et les bibliothèques partagées sont chargés en utilisant
ce mécanisme. C'est fait par le noyau pour l'exécutable et par le
chargeur dynamique pour les bibliothèques. On peut l'observer dans
/proc/$PID/maps.
Et si ce fichier exécutable ou d'une bibliothèque est supprimé lors de
l'exécution, est-ce que ça pose un problème ou bien ce fichier est
considéré comme ouvert et à ce titre son contenu n'est pas supprimé
tant qu'un processus détient une référence à son descripteur ?
Du point de vue du filesystem, un fichier mmapé est un fichier ouvert,
donc s'il est dé-lié, sa suppression effective attendra qu'il soit
dé-mmappé, souvent à la fin des processus correspondants.
Ce qui est plus inquiétant, c'est ce qui se passe si le fichier est
modifié directement. Pour l'exécutable principal, le noyau l'interdit :
ssecem ~ $ cp =sleep /tmp ssecem ~ $ /tmp/sleep 60 &
[1] 8696 ssecem ~ $ ls >> /tmp/sleep zsh: text file busy: /tmp/sleep
zsh: exit 1 ls --color=tty -FT0 >> /tmp/sleep
Pour les bibliothèques, cette protection n'arrive pas, ce qui fait qu'on
peut observer des comportements étranges, par exemple si on a lancé un
daemon directement depuis un arbre de compilation et qu'on recompile.
Yliur , dans le message <q53jgd$nck$1@news.trigofacile.com>, a écrit :
Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
Ah, les micro-optimisations pour rendre les catastrophes présentables.
fait la question dépasse le cadre de docker : comment une bibliothèque
dynamique est-elle "chargée" en mémoire ? Elle apparaît quelque part
dans la mémoire virtuelle d'un processus ? Est-ce que ça implique
qu'elle soit chargée quelque part ou bien c'est une simple
correspondance entre ces adresses virtuelles et le fichier représentant
la bibliothèque, en se contentant d'utiliser le cache système au fur et
à mesure que des pages sont nécessaire ?
Unix possède la notion d'appel système « mmap() », qui permet de faire
apparaître un fichier (ou équivalent) comme une zone dans l'espace
d'adresses virtuelles d'un processus. Si c'est en lecture seule, c'est
réalisé en faisant apparaître directement les pages du cache dans
l'espace d'adressage du processus. Il y a pas mal d'optimisation faite
là-dessus :
- Pour la lecture, les pages sont initialement marquées comme invalides,
ce qui fait que le processus, quand il y accède, déclenche une faute
de page, le truc qui d'habitude se termine par « segmentation fault ».
Mais cette fois-ci, c'est réglé pour que la faute de page conduise au
chargement de la page (et au chargement anticipé des pages suivantes)
avant de laisser le processus reprendre.
- Pour l'écriture, quand elle est autorisée, le mécanisme utilise
également des fautes de page. Il y a alors deux possibilités : si le
fichier est mappé en privé, le noyau alloue une page au processus,
comme n'importe quelle allocation mémoire, et y fait une copie de la
page en question (copy-on-write). S'il est mappé en partagé, la page
du cache est marquée comme modifiée et sera écrite sur disque.
Les exécutables et les bibliothèques partagées sont chargés en utilisant
ce mécanisme. C'est fait par le noyau pour l'exécutable et par le
chargeur dynamique pour les bibliothèques. On peut l'observer dans
/proc/$PID/maps.
Et si ce fichier exécutable ou d'une bibliothèque est supprimé lors de
l'exécution, est-ce que ça pose un problème ou bien ce fichier est
considéré comme ouvert et à ce titre son contenu n'est pas supprimé
tant qu'un processus détient une référence à son descripteur ?
Du point de vue du filesystem, un fichier mmapé est un fichier ouvert,
donc s'il est dé-lié, sa suppression effective attendra qu'il soit
dé-mmappé, souvent à la fin des processus correspondants.
Ce qui est plus inquiétant, c'est ce qui se passe si le fichier est
modifié directement. Pour l'exécutable principal, le noyau l'interdit :
ssecem ~ $ cp =sleep /tmp ssecem ~ $ /tmp/sleep 60 &
[1] 8696 ssecem ~ $ ls >> /tmp/sleep zsh: text file busy: /tmp/sleep
zsh: exit 1 ls --color=tty -FT0 >> /tmp/sleep
Pour les bibliothèques, cette protection n'arrive pas, ce qui fait qu'on
peut observer des comportements étranges, par exemple si on a lancé un
daemon directement depuis un arbre de compilation et qu'on recompile.
Yliur , dans le message <q53jgd$nck$, a écrit :Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
Ah, les micro-optimisations pour rendre les catastrophes présentables.
fait la question dépasse le cadre de docker : comment une bibliothèque
dynamique est-elle "chargée" en mémoire ? Elle apparaît quelque part
dans la mémoire virtuelle d'un processus ? Est-ce que ça implique
qu'elle soit chargée quelque part ou bien c'est une simple
correspondance entre ces adresses virtuelles et le fichier représentant
la bibliothèque, en se contentant d'utiliser le cache système au fur et
à mesure que des pages sont nécessaire ?
Unix possède la notion d'appel système « mmap() », qui permet de faire
apparaître un fichier (ou équivalent) comme une zone dans l'espace
d'adresses virtuelles d'un processus. Si c'est en lecture seule, c'est
réalisé en faisant apparaître directement les pages du cache dans
l'espace d'adressage du processus. Il y a pas mal d'optimisation faite
là-dessus :
- Pour la lecture, les pages sont initialement marquées comme invalides,
ce qui fait que le processus, quand il y accède, déclenche une faute
de page, le truc qui d'habitude se termine par « segmentation fault ».
Mais cette fois-ci, c'est réglé pour que la faute de page conduise au
chargement de la page (et au chargement anticipé des pages suivantes)
avant de laisser le processus reprendre.
- Pour l'écriture, quand elle est autorisée, le mécanisme utilise
également des fautes de page. Il y a alors deux possibilités : si le
fichier est mappé en privé, le noyau alloue une page au processus,
comme n'importe quelle allocation mémoire, et y fait une copie de la
page en question (copy-on-write). S'il est mappé en partagé, la page
du cache est marquée comme modifiée et sera écrite sur disque.
Les exécutables et les bibliothèques partagées sont chargés en utilisant
ce mécanisme. C'est fait par le noyau pour l'exécutable et par le
chargeur dynamique pour les bibliothèques. On peut l'observer dans
/proc/$PID/maps.
Et si ce fichier exécutable ou d'une bibliothèque est supprimé lors de
l'exécution, est-ce que ça pose un problème ou bien ce fichier est
considéré comme ouvert et à ce titre son contenu n'est pas supprimé
tant qu'un processus détient une référence à son descripteur ?
Du point de vue du filesystem, un fichier mmapé est un fichier ouvert,
donc s'il est dé-lié, sa suppression effective attendra qu'il soit
dé-mmappé, souvent à la fin des processus correspondants.
Ce qui est plus inquiétant, c'est ce qui se passe si le fichier est
modifié directement. Pour l'exécutable principal, le noyau l'interdit :
ssecem ~ $ cp =sleep /tmp ssecem ~ $ /tmp/sleep 60 &
[1] 8696 ssecem ~ $ ls >> /tmp/sleep zsh: text file busy: /tmp/sleep
zsh: exit 1 ls --color=tty -FT0 >> /tmp/sleep
Pour les bibliothèques, cette protection n'arrive pas, ce qui fait qu'on
peut observer des comportements étranges, par exemple si on a lancé un
daemon directement depuis un arbre de compilation et qu'on recompile.
Yliur wrote:Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
J'aurais l'impression que les images vraisemblablement en
`copy-on-write' sont montées comme des fs indépendants,
donc il n'y aura pas de partage de zone de code (programme ou so), car
les fichiers sont différents.
En plus, sur les plateformes modernes, souvent, le véritable code
exécuté est en fait une donnée, non partagée sauf fork() préalable, d'un
interprète ou d'un exécuteur de bytecode en JVM.
Pour partager le plus possibles de choses entre VM génériques, et pas
seulement du `text' (code en lecture seulement),
container ou non, je dirais qu'il faut investiguer ça:
https://en.wikipedia.org/wiki/Kernel_same-page_merging
Yliur <yliur@free.fr> wrote:
Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
J'aurais l'impression que les images vraisemblablement en
`copy-on-write' sont montées comme des fs indépendants,
donc il n'y aura pas de partage de zone de code (programme ou so), car
les fichiers sont différents.
En plus, sur les plateformes modernes, souvent, le véritable code
exécuté est en fait une donnée, non partagée sauf fork() préalable, d'un
interprète ou d'un exécuteur de bytecode en JVM.
Pour partager le plus possibles de choses entre VM génériques, et pas
seulement du `text' (code en lecture seulement),
container ou non, je dirais qu'il faut investiguer ça:
https://en.wikipedia.org/wiki/Kernel_same-page_merging
Yliur wrote:Docker permet de mettre en commun des fichiers entre plusieurs
conteneurs, grâce aux images "ancêtres" des images finales.
J'aurais l'impression que les images vraisemblablement en
`copy-on-write' sont montées comme des fs indépendants,
donc il n'y aura pas de partage de zone de code (programme ou so), car
les fichiers sont différents.
En plus, sur les plateformes modernes, souvent, le véritable code
exécuté est en fait une donnée, non partagée sauf fork() préalable, d'un
interprète ou d'un exécuteur de bytecode en JVM.
Pour partager le plus possibles de choses entre VM génériques, et pas
seulement du `text' (code en lecture seulement),
container ou non, je dirais qu'il faut investiguer ça:
https://en.wikipedia.org/wiki/Kernel_same-page_merging
Et donc si le contenu du fichier n'est représenté qu'une seule fois, ça
ne repose pas sur du cache de bas niveau (pages du disque lui-même, en
dessous de la notion de fichier) ? Ce cache se trouve au-dessus de la
notion de fichier ?
Et donc si le contenu du fichier n'est représenté qu'une seule fois, ça
ne repose pas sur du cache de bas niveau (pages du disque lui-même, en
dessous de la notion de fichier) ? Ce cache se trouve au-dessus de la
notion de fichier ?
Et donc si le contenu du fichier n'est représenté qu'une seule fois, ça
ne repose pas sur du cache de bas niveau (pages du disque lui-même, en
dessous de la notion de fichier) ? Ce cache se trouve au-dessus de la
notion de fichier ?
J'ai des choses à exécuter sur un système d'exploitation donné, je trouve
docker pratique dans ce contexte, plutôt qu'une machine virtuelle
complète par exemple.
Et dans le cadre du déploiement de différentes versions/instances d'une
appli, le cas du partage de fichiers communs (le fonctionnement normal de
docker) est assez courant : les conteneurs déployés ont bien une base
commune.
Je ne comprends pas où tu situes la catastrophe...
Ces pages dans la mémoire virtuelle de processus, elles correspondent à
des blocs du disque directement ? Ou bien un mécanisme de correspondance
plus complexe (par exemple les octets n à m d'un fichier, peu importe où
il est stocké) ?
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
Le contenu de /proc/$PID/maps laisse entendre que c'est plutôt géré au
niveau du système de fichiers, non ? Il y a des chemins vers les fichiers
dans ce qui s'affiche. À moins que ce ne soit qu'une indication pour s'y
retrouver ?
Du coup une mise à jour de paquets alors que du code s'exécute est assez
dangereuse.
J'ai des choses à exécuter sur un système d'exploitation donné, je trouve
docker pratique dans ce contexte, plutôt qu'une machine virtuelle
complète par exemple.
Et dans le cadre du déploiement de différentes versions/instances d'une
appli, le cas du partage de fichiers communs (le fonctionnement normal de
docker) est assez courant : les conteneurs déployés ont bien une base
commune.
Je ne comprends pas où tu situes la catastrophe...
Ces pages dans la mémoire virtuelle de processus, elles correspondent à
des blocs du disque directement ? Ou bien un mécanisme de correspondance
plus complexe (par exemple les octets n à m d'un fichier, peu importe où
il est stocké) ?
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
Le contenu de /proc/$PID/maps laisse entendre que c'est plutôt géré au
niveau du système de fichiers, non ? Il y a des chemins vers les fichiers
dans ce qui s'affiche. À moins que ce ne soit qu'une indication pour s'y
retrouver ?
Du coup une mise à jour de paquets alors que du code s'exécute est assez
dangereuse.
J'ai des choses à exécuter sur un système d'exploitation donné, je trouve
docker pratique dans ce contexte, plutôt qu'une machine virtuelle
complète par exemple.
Et dans le cadre du déploiement de différentes versions/instances d'une
appli, le cas du partage de fichiers communs (le fonctionnement normal de
docker) est assez courant : les conteneurs déployés ont bien une base
commune.
Je ne comprends pas où tu situes la catastrophe...
Ces pages dans la mémoire virtuelle de processus, elles correspondent à
des blocs du disque directement ? Ou bien un mécanisme de correspondance
plus complexe (par exemple les octets n à m d'un fichier, peu importe où
il est stocké) ?
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
Le contenu de /proc/$PID/maps laisse entendre que c'est plutôt géré au
niveau du système de fichiers, non ? Il y a des chemins vers les fichiers
dans ce qui s'affiche. À moins que ce ne soit qu'une indication pour s'y
retrouver ?
Du coup une mise à jour de paquets alors que du code s'exécute est assez
dangereuse.
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter.
Je crossposte sur fr.comp.lang.c
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter.
Je crossposte sur fr.comp.lang.c
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter.
Je crossposte sur fr.comp.lang.c
Le 27 février 2019, à 10:04, Yliur a écrit :Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter. À mon avis (je ne suis pas informaticien) il y a
tellement de niveaux d'optimisation entre le code source et l'exécution
qu'il est difficile de prévoir, sur la base du source, comment un code va
s'exécuter.
Le 27 février 2019, à 10:04, Yliur a écrit :
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter. À mon avis (je ne suis pas informaticien) il y a
tellement de niveaux d'optimisation entre le code source et l'exécution
qu'il est difficile de prévoir, sur la base du source, comment un code va
s'exécuter.
Le 27 février 2019, à 10:04, Yliur a écrit :Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter. À mon avis (je ne suis pas informaticien) il y a
tellement de niveaux d'optimisation entre le code source et l'exécution
qu'il est difficile de prévoir, sur la base du source, comment un code va
s'exécuter.
Le 27 février 2019, à 10:04, Yliur a écrit :Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter. À mon avis (je ne suis pas informaticien) il y
a tellement de niveaux d'optimisation entre le code source et
l'exécution qu'il est difficile de prévoir, sur la base du source,
comment un code va s'exécuter.
Je crossposte sur fr.comp.lang.c
Le 27 février 2019, à 10:04, Yliur a écrit :
Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter. À mon avis (je ne suis pas informaticien) il y
a tellement de niveaux d'optimisation entre le code source et
l'exécution qu'il est difficile de prévoir, sur la base du source,
comment un code va s'exécuter.
Je crossposte sur fr.comp.lang.c
Le 27 février 2019, à 10:04, Yliur a écrit :Au passage, cette histoire de mmap sur des fichiers, il me semble avoir
vu que c'était parfois utilisé comme optimisation de lecture de fichiers
classiques (dont on veut juste lire le contenu) : c'est parce qu'au lieu
d'allouer un tableau d'octets en mémoire et de copier le contenu d'un
fichier dedans on se contente de faire une association entre les adresses
et le contenu du fichier, donc on évite une allocation et la recopie de
tous les octets en mémoire ? Et peut-être des appels systèmes pour les
lectures successives de blocs dans le fichier.
La seule fois où j'ai utilisé un mmap dans un code, ça a chargé
l'intégralité du fichier en mémoire dès l'appel (peut-être même que
l'appel a été bloquant, je ne sais plus), alors que mon but était
évidemment de l'éviter. À mon avis (je ne suis pas informaticien) il y
a tellement de niveaux d'optimisation entre le code source et
l'exécution qu'il est difficile de prévoir, sur la base du source,
comment un code va s'exécuter.
Je crossposte sur fr.comp.lang.c