Gros fichier mémoire (block par block)

Bonjour,

Je développe un logiciel de cryptage.

Mon logiciel doit pouvoir crypter de très gros fichier (plusieurs centaines de Mo).

Je monte le fichier en mémoire block par block (1 bloc = 64 Ko par exemple) et crypte donc block par block en mémoire pour ensuite redescendre le block crypté dans le fichier de destination.

C'est très rapide jusqu'à des fichiers de 120 Mo (environ 3 secondes), mais au dessus de 120 Mo, ça devient très long (20 secondes environ).

J'ai 256 Mo de RAM...

J'utilise un buffer (unsigned char *) pour stocker mes blocs.

J'ai essayé avec les API ReadFile et WriteFile et aussi avec les fonctions C++ fread et fwrite et j'obtiens toujours le même résultat.

Le problème vient donc de Windows.
Il doit s'embrouiller dans le Swap ou je ne sais pas quoi...

C'est assez déroutant...
120 Mo --> très rapide
130 Mo --> très lent

????

Merci pour votre aide...

Pour infos, j'utilise Windows XP.

A chaque fois, il est plus lent au 1er traitement du fichier.
Quand je retraite le même dichier, il va beaucoup plus vite à partir de la 2ème fois.

Pour les fichiers très gros (200Mo), il arrive qu'il aille très vite (2, 3 secondes, comme pour le fichier de 120Mo) et puis d'un seul coup, il va mettre 20 secondes...

Comment booster Windows pour le rendre performant sur chaque traitement d'ouverture et de sauvegarde du block, car le problème de performance semble venir uniquement de la gestoin mémoire faite par Windows.

Tu devrais utiliser des blocs d'un mo, ce serait mieux.
Je te conseille d'utiliser ReadFile pour la lecture et HeapAlloc pour l'allocation de mémoire.
Pour ton problème, j'èspère que tu ne fais l'allocation qu'un fois, sinon ton pb à partir de 130mo est très bizarre.
Tu pourrais peut être mettre ton code pour voir?

J'utilise un bloc de 64Ko, car c'est ce qui est le plus rapide...
(j'ai fais plusieurs tests et comparer les résultats du Benchmark).

Mon programme traite aussi des tout petit fichier...

Je te met mon code...

Voilà mon code...

Pour simplifier, il ne traite pas le cas ou le dernier bloc à charger en mémoire a une taille inferieur à la taille d'un bloc.

Par exemple, pour un fichier de 200 Ko, sachant qu'un bloc fais 64Ko, je vais faire :
Bloc 1 : 64 Ko
Bloc 2 : 64 Ko
Bloc 3 : 64 Ko
Bloc 4 : 64 Ko (au lieu de 8 Ko)


////////////////////////////////////////////////////////////////////
#define BLOC_SIZE 64 //taille d'un bloc en Ko

bool OpenFileByBloc (char * filename)
{
HANDLE hFile, hHeap;
LPVOID pBloc; //pointeur sur le buffer contenant les blocs
DWORD lengthFile; //taille totale du fichier (en octets)
DWORD lengthBloc; //taille d'un bloc (en octets)

/* création du handle sur le fichier à ouvrir */
hFile = CreateFile (filename,
GENERIC_READ, 0, 0,
OPEN_EXISTING,
FILE_FLAG_SEQUENTIAL_SCAN, 0);

if (hFile == INVALID_HANDLE_VALUE) return FALSE;

/* taille en octets du fichier à ouvrir */
lengthFile = GetFileSize (hFile, 0);

/* taille en octets du buffer */
lengthBloc = BLOC_SIZE * 1024;

/* allocation mémoire du buffer recevant les blocs du fichier */
hHeap = GetProcessHeap();
pBloc = HeapAlloc (hHeap, HEAP_ZERO_MEMORY, lengthBloc);
if (pBloc == NULL) return FALSE;

/* position du curseur dans le fichier (position du bloc à traiter) */
DWORD i = 0;

/* nombre d'octets lu par ReadFile */
DWORD lengthRead = 0;

/********************************************/
while (i < lengthFile)
{
/* place le curseur sur le bloc à monter en mémoire */
SetFilePointer (hFile, i, 0, FILE_BEGIN);

/* charge le morceau du fichier en mémoire dans le bloc "pBloc" */
ReadFile (hFile, pBloc, lengthBloc, &lengthRead, 0);

/* passe au bloc suivant */
i = i + lengthBloc;

}
/********************************************/

/* libère le buffer */
HeapFree (hHeap, 0, pBloc);

/* ferme le fichier */
CloseHandle (hFile);

return TRUE;
}

tu le mets ou??

Pour le moment, pendant que je teste, je le met dans un Exécutable (console Win32).

Je l'appelle ainsi :

void main()
{
char filename[] = "c:\\test.txt";

StartBenchmark ();
OpenFileByBloc (filename);
printf ("%u\n", StopBenchmark());

return 0;

}

Merci pour ton aide...

oh pardon tu as posté ton code entre temps
pour ton problème je dirais que c'est normal qu'il mettent longtemps pour les gros fichier, même si c'est bizarre qu'il saute brusquement vers 120mo, en tous cas je ne vois pas pq ce serait un pb de ram, puisque tu n'utilises en tout et pour tout que 64ko.
J'ai essayé chez moi et il met environ 35s pour 700mo (mais avec des blocs de 1mo)

J'aimerais comprendre pourquoi le temps mis pour effectuer cet algo n'est pas proportionnel à la taille du fichier à charger.

C'est certainement à cause du gestionnaire de mémoire du noyau de Windows... Mais pourquoi ?

Je pense que lorsque tu lit un fichier, windows le garde dans un coin de la mémoire (pour pouvoir y accéder plus rapidement par la suite). C'est pour cela qu'au 2ème traitement c'est plus rapide. La rupture doit provenir du fait que la limite de stockage rapide est atteinte.