Discussion :

[gemai]

Bonjour à tous je cherche des informations sur le memory mapping, c'est a dire comment utiliser mmap,munmap, g bien le man de linux mais j'aurai voulu en savoir plus sur le memory mapping, si quelqu'un a des adresses a me donner je serais ravi.
Des exemples d'utilisation par exemple.

Merci à tous

[boborde]

ta question semble plus porter sur de la prog système linux .... si je fais pas d'erreur

pource qui est des appels système mmap, unmap , ioremap je ne saurais trop te conseiller de regarder sur le site ftp de oreilly, leur livre sur le noyau est génial ... des examples de codes ( ie: pour les drivers dans le cas de ioremap ) sont fournis

"Linux Device Driver" est disponible en ebook ( en VO desolé ) ... celui ci est très complet et un chapitre entier traite de mmap et dma ... la bonne chance moi je n'y suis pas encore... mais c'a pas l'air facile

par curiosité, quel type de driver necessite cette gestion mem ????
tiens moi au courant merci , je suis interessé par un exp de codage dans ce domaine ...

[gemai]

merci pour l'info
tu as raison c vrai que ca porte surement plus sur linux que sur la prog en C
mais en fait si j'ai besoin de mmap c parceque j'ai un gros fichiers a lire pour l'instant 200 Mo mais il va surement evoluer vers le Go, et je dois le lire une centaine de fois dans mon programme sequentiellement.
Donc a la place de le charger en memoire je voudrai le lire directement sur le dur.

voila, jj'espere avoir repondu a ta question, meme si je n'en duis pas sur !!!

[Anomaly]

Donc si j'ai bien compris tu veux utiliser mmap dans le but de faire une sorte de mémoire virtuelle ? Pourquoi tu ne programmes pas plutôt à la main ce genre de mécanisme, vu que tu sais comment tu vas y accéder, tu pourras trouver et implémenter l'algorithme le mieux adapté afin de minimiser les accès disque.

[gemai]

c exactement ca
et programmer ca a la main je ne vois pas ce que tu veux dire par a la main.
L'on m'avait indiquer cette piste de mmap pour le faire, je ne sais pas si je l'avais précisé mais je programme ca en C.
Et en programmation je suis loin d'etre une bete, pour l'instant je cherche des infos qui seraient suceptibles de pouvoir m'aider a faire ca.
Si tu as des idées n'hesite pas a me les faire partager.
Merci d'avance

[boborde]

peux tu noux donner un peu plus de detail quant au fonctionnement que tu veux obtenir au niveau memoire ,

sorte de découpage.. etc

comment compterai tu utilser tes routines au final ??

[gemai]

C trés simple je veux lpouvoir lire mon fichier de la premiere valeur a la 500, puis de la 1500 a la 6000.
Dans ce style la.

je voudrai pouvoir indiquer une zone de parcours de mon fichier.

Sachant que ce fichier ne contient que des floattants

[boborde]

Les infos ci dessous sont a tester je débute en dev unix

bon ben en fait tu ouvre ton fichier par open, ainsi tu recupère son descripteur....

tu calcule la taille dont tu dois disposer puis tu peux allouer de la mémoire
( point a verifier sur la façon dont on doit le faire )

puis après tu peux te lancer dans mmap

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
char* map_fichier = mmap( addr, // une adresse...
                                         len, // size_t , longueur de portion de fichier
                                               // a calculer ( fseek , etc )
                                         PROT_READ, // partagé en lecture ...
                                         MAP_SHARED, // les autres process
                                         fd, // recuperer par ouverture du fichier
                                         off  //off_t position à partir de laquelle tu 
                                                // commence a mapper le fichier
);
 
// apres on accede au fichier comme par un tableau ... par exemple en 
//pensant qu'on char par char
if ( map_fichier[3] == 'A' )
 printf( " 4° car à A ");

donc pour la lecture du début à la 500° valeur
le resultat de fseek( ... begin ... ) pour l'offset de ton preemier mmap,
la longueur et a calculer par tes soins en comptant les val ou je ne sais quoi...

dans ton cas on ne fais que lire ...

un appel a unmap retirer le mappage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

unmap( addr, len );

j'espère que ca t'aidera, mais c juste ce k'il y a écrit dans le man ....

[gemai]

Ce que je ne sais pas c a quoi correspond le type size_t ( a un entier?).
L'adresse du fichier comment je peux la récupérer?
off_t je ne comprends pas qu'elle position je dois indiquer ici?

merci pour ces renseignements je vais commencer a faire quelques tests.

[boborde]

pour les types que tu me demande essai de chercher du co^é des opérations de fichier :

lseek pour récupérer loff_t
seef pourr off_t

pour size_t penche toi vers les primitives de lecture sur fichier mais oui c problablement un unisgned long ,

ces déclarations de type ( size_t et autres ) permettent de faire evoluer ton app en fonction des versions du noyau...

l'adresse addr est le point obscur , d'après mes souvenirs c une adresse que tu fournit, je vais regarder de ce coté dans mes archives

cependant c' est bien l'adresse que retourne mmap() que tu devra utiliser pour accéder à tes infos

[gemai]

ok merci
je v chercher aussi de mon coté

[boborde]

j'ai fait un test

il apparait que le param addr est en fait facultatif ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
char* map_fichier = (char*)mmap( NULL, taille_a_mapper,
                                                  PROT_READ,
                                                  MAP_SHARED,
                                                  fd,
                                                  0 ); // 0 on commence au début
 
if ( map_fichier == (char*)MAP_FAILED )
{
 perror(" Erreur mmap");
 exit(1);
}
 
for ( int i = 0 ; i < taille_a_mapper ; i++ )
 printf( "%c",map_fichier[i] );
 
munmap( (void*) map_fichier, taille_a_mapper );
 
return 0;

[gemai]

ok merci beaucoup je pense avoir maintenant totalement compris

[gemai]

Bonjour à tous, j'ai un probleme avec mon mapping.
Voila le code implémenté :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <sys/mman.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
 
char* map_fichier,c;
 
 
int main()
{
 
 
 
	long int i,fd,a;
	FILE *fin1;
 
	fd =open("obj10.bin",O_RDWR);
 
	map_fichier = (char*) mmap( NULL, 16384 , PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0 );
 
 
	if ( map_fichier == (char*)MAP_FAILED )
	{
		perror(" Erreur mmap");
		return 0;
	}
 
 
	for ( i = 0 ; i < 16384  ; i++ )
	{
		a=map_fichier[i];
		printf("%ld %ld\n",i,a);
	}
 
 
	munmap( (void*) map_fichier, 16384 );
 
 
	return 1;
}

En faisant ca ca marche toute les valeurs sont bien affichées correctement.
obj16.bin fait 16384 octets
Par contre avec ce code en lisant toujours le meme fichier, ca ne marche pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include <sys/mman.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
 
 
float* map_fichier,c;
 
 
int main()
{
 
 
 
	long int i,fd,a;
	FILE *fin1;
 
	fd =open("obj16.bin",O_RDWR);
 
	map_fichier = (float*) mmap( NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0 );
 
 
	if ( map_fichier == (float*)MAP_FAILED )
	{
		perror(" Erreur mmap");
		return 0;
	}
 
 
	for ( i = 0 ; i < 1100 ; i++ )
	{
 
		printf("%ld %f\n",i,map_fichier[i]);
	}
 
 
	munmap( (void*) map_fichier, 4096 );
 
 
	return 1;
}

Donc voila ce qui se passe a l'exécution, il m'affiche correctement les 1024 premieres valeurs, ensuite il me met des 0. Et apres la 2048 eme ca m'affiche erreur de segmentation.
J'ai tout d'abord penser que les float n'étaient pas codés sur 4 octets mais c bien le cas. Donc la je n'ai plus d'idée, je trouve ca trop bizarre...

Si quelqu'un pense savoir n'hésitez pas a me repondre.