Discussion :

[julieng31]

Bonjour,

j'ai développé une classe qui contient plusieurs fonctions qui vont lire des fichiers à un index particulier et en déduisent une valeur. Un exemple très simplifié :

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
 
#define SIZE_OF_DOUBLE (sizeof(double))
 
class module {
 
   private:
       std::ifstream file;
 
   public:
       module() {
           file.open("path.bin, ios::in | ios::binary");
       }
 
       getValue(const double x, const double y) {
           double value[4][4];
           unsigned int index = calcul(x, y); // Transformation des paramètres d'entrée en index
           file.seekg(index*SIZE_OF_DOUBLE, ios::beg);
           file.read(reinterpret_cast<char *> (&value[0]), 4*SIZE_DOUBLE);
           file.seekg(ligne_suivante*SIZE_OF_DOUBLE, ios::cur);
           file.read(reinterpret_cast<char *> (&value[1]), 4*SIZE_DOUBLE);
           file.seekg(ligne_suivante*SIZE_OF_DOUBLE, ios::cur);
           file.read(reinterpret_cast<char *> (&value[2]), 4*SIZE_DOUBLE);
           file.seekg(ligne_suivante*SIZE_OF_DOUBLE, ios::cur);
           file.read(reinterpret_cast<char *> (&value[3]), 4*SIZE_DOUBLE);
           return bicubicInterpo(x, y, values);
     }
}

Ceci n'est qu'un exemple. J'ai une 20aine de fonctions similaires à getValue() et à peu près le même nombre d'ifstream qui pointent sur des fichiers qui font entre 5 et 10Mo (soit un total d'environ 150Mo).

Auriez-vous un conseil pour d'une part l'optimiser car j'appelle plusieurs centaines de millions de fois chaque fonction et d'autre part, si je devais passer au multi-thread, que puis-je faire pour le rendre thread-safe car quand j'essaye de paralléliser avec openmp, j'ai un segfault (j'imagine que ce cela vient de l'accès au ifstream).

Merci d'avance !

[ternel]

Si tu veux être vraiment efficace, utilise un cache.
C'est à dire mets en mémoire soit la totalité du fichier, soit des parties de ceux-ci (un système de pages, donc)
mmap peut te donner une idée

Dans l'idée, ton fichier ayant une forme particulière, tu dois pouvoir le représenter comme un vector<Forme>, Forme étant l'aspect d'un élément.

150Mo, c'est assez petit pour la RAM (en Go pour un PC, et "beaucoup" pour un serveur)

[julieng31]

Merci Leternel pour cette réponse. En cherchant quelques infos sur google, je tombe sur mmap sous linux. Mon environnement est windows.

Est-ce que mmap existe ou a un équivalent pour windows ?

[ternel]

"google mmap windows" m'a donné file mapping

Mais tu n'en as pas forcément.
Commence déjà par définir une struct/class, et fais en un vector.

[julieng31]

Mon fichier, au départ, est une matrice indicée par une longitude terrestre [-180 à 180] et une latitude terrestre [-90 à 90] avec un pas fixe pour un fichier donné. Chaque valeur est un double. Ensuite, le tout est stocké en fichier binaire.

L'intérêt de la fonction est d'aller lire les valeurs pour 4 longitudes consécutives et ceci sur 4 lignes consécutives (soit 16 points en carré de 4 par 4). Autrement dit, les 16 points autour de x et y dans ma fonction.

Du coup, que veut dire vector<Forme> :
* est-ce que "forme" serait une ligne donc plusieurs centaines de doubles ?
* est-ce que "forme" serait un double ? Dans ce cas, quel est l'intérêt par rapport à ce que j'avais initialement ? Le vecteur serait stocké en mémoire ?

J'ai aussi regardé un mmap ou équivalent. Je suis tombé sur la fonction map() de QFile. Maintenant, je ne me retrouve avec un 'uchar *' et je n'arrive pas à trouver d'exemple pour convertir cela en double et aller chercher la bonne valeur...

[Iradrille]

Hello,

Forme ici peut être une matrice (16 doubles).

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
#define SIZE_OF_DOUBLE (sizeof(double))
 
class module {
private:
	struct Data {
		double values[4][4];
	};
 
	std::unordered_map<unsigned int, Data> cache;
 
public:
	module() {
		std::ifstream file("path.bin, ios::in | ios::binary");
		pour tous les indices {
			// lire tes 16 doubles
			unsigned index = calcul(x, y);
			Data d;
			file.seekg(index*SIZE_OF_DOUBLE, ios::beg);
			file.read(reinterpret_cast<char *> (&d.value[0]), 4*SIZE_DOUBLE);
			file.seekg(ligne_suivante*SIZE_OF_DOUBLE, ios::cur);
			file.read(reinterpret_cast<char *> (&d.value[1]), 4*SIZE_DOUBLE);
			file.seekg(ligne_suivante*SIZE_OF_DOUBLE, ios::cur);
			file.read(reinterpret_cast<char *> (&d.value[2]), 4*SIZE_DOUBLE);
			file.seekg(ligne_suivante*SIZE_OF_DOUBLE, ios::cur);
			file.read(reinterpret_cast<char *> (&d.value[3]), 4*SIZE_DOUBLE);
			cache.insert(index, d);
		}
	}
 
	double getValue(const double x, const double y) const {
		unsigned int index = calcul(x, y);
		auto const& d = cache[index];
 
		// si ce calcul est long et fait plusieurs
		// fois, il peut aussi est mis en cache
		return bicubicInterpo(x, y, d.values);
	}
};