Discussion :

[Mathieu.J]

Bounjour,

Je souhaiterai pouvoir avoir en mémoire une "fenêtre" de taille T sur un énorme fichier.

Pour cela j'utilise

Code :

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

1
2
buff = (char*) MapViewOfFile(fichierMappe,FILE_MAP_READ | FILE_MAP_WRITE,0,0,100000);

ici T = 100000;

Le problème c'est que je ne sait pas comment me servir de l'offset de début
(0, 0) ici.
offset sur 64 bit = 1offset de poids forts 32 bit+ 1 offset de poids faible 32bits.


Je souhaiterais que ma fenêtre commence sur le Neme octet de mon fichier, comment je m'y prend ??

les offset doivent être multiple de l'"Allocation Ganulometry", pourquoi ?

j'ai essayé (0,granulometry*x) et ma fenêtre commence toujours au début du fichier.


Quelqu'un a-t-il une idée pour positionner ma fenêtre à un endroit X?

[Médinoc]

ben, normalement, si tu veux positionner à N octets, (et si N est inférieur à 4Go), tu passes simplement 0 pour le mot de poids fort et N sur le mot de poids faible...

Le problème, c'est qu'ici, N doit être un multiple de la taille d'une Page mémoire (soit souvent 512 octets).


Bref, tu ne peux pas faire débuter ta fenêtre directement sur n'importe quel octet.

[Mathieu.J]

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
	//*************************************************
	// Mapper le fichier en mémoire 
	//*************************************************

	
	HANDLE fichierMappe;

	fichierMappe = CreateFileMapping((HANDLE)grosFichierHandler/*0xFFFFFFFF*/,NULL,PAGE_READWRITE,0,0,NULL);
	if(fichierMappe==NULL)
	{
		switch(GetLastError())
		{
			case ERROR_SUCCESS&#58;cout<<"&#91; OK &#93; Le gros fichier est ouvert."<<endl;break;
			case ERROR_INVALID_PARAMETER&#58;cout<<"&#91;EROR&#93; Le gros fichier n'a pas pu etre ouvert &#58; Un parametre est invalide."<<endl;break;
			case ERROR_FILE_NOT_FOUND&#58;cout<<"&#91;EROR&#93; Le gros fichier n'a pas pu etre ouvert &#58; Le fichier est introuvable."<<endl;break;
			case ERROR_INVALID_NAME&#58;cout<<"&#91;EROR&#93; Le gros fichier n'a pas pu etre ouvert &#58; Le nom de fichier est incorrect."<<endl;break;
			default&#58;cout<<"&#91;EROR&#93; Le gros fichier n'a pas pu etre ouvert &#58; Erreur inconue."<<GetLastError&#40;&#41;<<endl;break;
		&#125;
	&#125;
	else
	&#123;
		cout<<"&#91; OK &#93; Le gros fichier est ouvert."<<endl;
	&#125;


	//*************************************************
	// Accéder à un morceau du fichier mappé
	//*************************************************

	char* buff = new char&#91;200000&#93;;
	SYSTEM_INFO info;
	GetSystemInfo&#40;&info&#41;;
	int allocationGanularity = info.dwAllocationGranularity;
	buff = &#40;char*&#41; MapViewOfFile&#40;fichierMappe,FILE_MAP_READ | FILE_MAP_WRITE,0,&#40;&#40;int&#41;&#40;100000/allocationGanularity&#41;&#41;*allocationGanularity,100000&#41;;
	afficherContenuBuffer&#40;buff,100000&#41;;
	return 0;
&#125;

Mon fichier contient 100 000 "a", puis 100 000 "b", ainsi de suite

avec 0,0 j'obtient mes 100 000 "a"

mais avec 0 , ((int)100000/granulometry)*granulometry j'obtient toujours les "a" et pas de "b"

comment ca se fait ??

[Médinoc]

J'ai pas encore vraiment regardé ton code, mais vu ton calcul, tu devrais obtenir un truc du genre "aaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbb" lors de la seconde lecture...

[Mathieu.J]

Désolé c'est de ma faute

Je décalais de 100 000, alors qu'en fait il y a 100 000 000 "a", donc ca décalait bien, mais pas suffisament, et pour tomber pil poil sur un bloc, je v les créer avec une taille multiple de granulometry...

merci beaucoup

[Mathieu.J]

Autre petite question.

Voici mon algorithme

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
void testParccourirModifier()
{
	//*************************************************
	// Ouvrir et Mapper le fichier en mémoire 
	//*************************************************

	HFILE grosFichierHandler;
	grosFichierHandler = OpenFile((LPCSTR) CHEMIN_GROS_FICHIER.c_str(),&structure,OF_READWRITE); 
	

	HANDLE fichierMappe;

	fichierMappe = CreateFileMapping((HANDLE)grosFichierHandler,NULL,PAGE_READWRITE | SEC_COMMIT,0,0,NULL);
	
	
	// Pour chaque bloc

	for&#40;unsigned int i=0; i<NB_BLOCS; i++&#41;
	&#123;

		// Récupérer le bloc dans un buffer
		char * buff =  &#40;char * &#41;MapViewOfFile&#40;fichierMappe,FILE_MAP_WRITE,0,i*TAILLE_BLOCS,TAILLE_BLOCS&#41;;


		//afficherBloc&#40;buff,TAILLE_BLOCS&#41;;
		for&#40;unsigned int j=0; j<TAILLE_BLOCS; j++&#41;
		&#123;
			buff&#91;j&#93; = buff&#91;j&#93;+1;
		&#125;

		// Mettre a jour le disque dur
		UnmapViewOfFile&#40;buff&#41;;
	&#125;

	CloseHandle&#40;fichierMappe&#41;;
	CloseHandle&#40;&#40;HANDLE&#41;grosFichierHandler&#41;;
	double  tempsEcoule = difftime &#40; tempsArrivee ,tempsDepart &#41;; 
&#125;

Ce qui donne :
Ouverture du fichier
Maping du fichier
pour chaque bloc
--- Récupérer le bloc (MapViewOfFile)
--- Le modifier
--- Le sauvegarder (UnMapViewOfFile)
finpour


J'ai quelques petites questions :

- Est-ce que je libère bien toutes les ressources ?
- Mon algorithme est-il "optimal" ? j'entend pad la : ma techinque est-elle correcte ? Mon fichier peut faire plusieurs dizaines de gigagoctets, vaut-il mieu le mapper en entier et ensuite le parcourir avec les vues ? ou alors le mappé partie par partie et mettre tout ce qui est mappé dans une view ? ou un mix des deux ? ...

Je n'ai pas encore bien compris le principe de mapping, que fais exactement CreateFileMaping ?

[Médinoc]

Le fait que ce soit optimal ou non, je ne sais pas. Mais je pense que oui, toutes les ressources sont libérées.

En fait, le CreateFileMapping(), je pense qu'il alloue les ressources systèmes et qu'il "marque" le fichier comme pouvant être mappé en mémoire d'un instant à l'autre.

Le MapViewOfFile(), lui, mappe le fichier en mémoire, c'est-à-dire qu'il l'associe à la mémoire: Si tu modifies la mémoire, ça modifie le fichier.