Discussion :

[victor_gasgas]

Bonjour à tous!

Voilà j'ai un std::vector sur une structure ne contenant que des floats et des ints. Je copie alors l'intégralité de ce vector dans un std::vector<char> avant de l'envoyer à des APIs comme OpenGL avec &vec[0].

Cela fonctionne très bien!

Maintenant j'aimerais serializer le vector de char dans un fichier binaire afin d'accélérer le chargement par la suite! Mais je me pose de la question de portabilité : en effet prennont un Pc little et un Pc big endian, n'aurait-je pas un problème au étant donné que tout sera enregistré comme de simple char? Ou même à un autre endroit?

P.S. Il me semble que boost::serialization permet d'enregistrer de la mémoire brute mais dans ce cas la lecture des ints sera erronés non?

Voilà j'aimerais avoir votre avis! Merci beaucoup!

[koala01]

Salut,

En effet, tu risques d'avoir quelques soucis si tu sérialise tes données brutes sur une machine gros boutiste et que tu essayes de les relire sur une machine petit boutiste

Il faut donc que tu décides (au niveau des spécifictations) du boutisme de ta sérialisation et que tu prennes, par la suite, les actions qui s'imposent en fonction du boutisme utilisé lors de la lecture.

Cependant, je ne vois pas très bien en quoi tu espères accélérer le chargement en sauvegardant (dans un format binaire, donc, a priori, peu portable) tes données sous la forme d'une collection de char

Qu'il s'agisse de lire 10000 entiers et 2000 float ou l'équivalent en tant que unsigned char, tu devra de toutes manières lire la même quantité de données, avec, en prime, une série de problèmes dus à la conversion que cela peut impliquer.

Avant de t'inquiéter de ce genre de problème, je ne saurais trop te rappeler que "premature optimization is root of all evils"

Autrement dit: pour décider de prendre un tel risque, il faut que tu fasse une analyse poussée des performances des différentes possibilités, afin d'éviter de te faire du mal pour rien.

Commence donc peut etre "simplement", en sauvegardant tes données sous forme de fichier texte, puis compare les performances de lecture en sauvegardant cette fois sous la forme d'un fichier binaire, mais toujours en sauvegardant les données comme "ce qu'elles sont".

Par la suite, tu peux éventuellement envisager de chipoter à sauvegarder le tout sous la forme d'une collection de char, mais je doute sincèrement que cela ne t'apporte quoi que ce soit

[victor_gasgas]

Pour commencer merci pour la réponse,

Je vois que sur certains points j'ai pas été assez clair. En effet je ne cherche pas à faire des optimisations prématuré : voilà l'interface dont je dispose :

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
struct abstract_vertex_array {};
 
// les deux classes ci-dessous sont épurées et c'est pour ça qu'elle se ressemble tellement
 
struct raw_vertex_array : public vertex_array {
    raw_vertex_array(char* memory, size_t size);
 
private:
    std::vector<char> m_data;
};
 
 
template<class T>
struct formatted_vertex_array : public vertex_array {
    formatted_vertex_array(const std::vector<T> &data);
 
private:
    std::vector<T> m_data;
};

La classe formatted_vertex_array est idéale car facile à serializer du moment que le paramètre template T l'est aussi!

Par contre il peut arriver que l'utilisateur fasse passer un bloc de mémoire directement dans raw_vertex_array. Prenons le cas où la création de ce bloc nécessite un traitement lourd, comme c'est parfois le cas actuellement, je me suis dis que la serialialization était tout indiqué là aussi car c'est là que l'optimisation aurait lieu : on évite tout le traitement en chargeant depuis une fichier par exemple!

Donc ma solution de serializer la classe raw_vertex_array est-elle viable?

J'espère avoir pû éclairer un peu la situation! Merci

[koala01]

Attention: tu n'as aucun lien entre un formatted_vertex_array et un raw_vertex_array, hormis leur base commune.

Tu ne peux donc décédément pas envisager de sérialiser l'un et de le récupéré comme étant l'autre lors de la désérialisation!

Ou alors, tu dois prévoir un opérateur de conversion dans les différents sens, et cela n'ira pas sans poser certains problèmes, surtout que formatted_vertex_array est une classe template (imagines la catastrophe que tu te prépares si tu essayes de convertir un formatted_vertex_array<short> (les short sont classiquement codé sur 16 bits) converti en raw_vertex_array en... formatted_vertex_array<double> (les doubles sont classiquement codés sur... beaucoup plus)

[victor_gasgas]

D'après le lien du tuto de boost serialize http://www.boost.org/doc/libs/1_53_0...doc/index.html il semble que boost s'occupe bien des classes dérivés et de recharger comme il faut pour peu que les fonctions serialize des classes soient bien définies (voir sous section Derived class du tuto).

P.S. Je ne manipule que des pointeurs sur la classe de base car j'ai oublié mais il y a une notions de classe abstraites : la classe vertex_array possède la méthode virtuelle abstraite void* data();

La seule question que je me pose donc ce situe au niveau de la mémoire brute avec le problème little et big endian surtout!

[koala01]

Oui, boost est en mesure de sérialiser des classes dérivées, mais, si tu as les classes Camion, Voiture, Velo, Avion, PatinsARoulettes qui dérivent de Vehicule, tu vas sérialiser chacune des instances de ces différents types pour ce que c'est (un camion, une voiture, un avion etc) et, lorsque tu vas relire ta sérialisation, tu vas obtenir une instance du type particulier (camion, voiture ou avion), même si elle est connue sous la forme d' "un pointeur sur Véhicule".

Ce que tu voudrais faire en l'occurrence revient peu ou prou à sauvegarder un camion et à vouloir relire des patins à roulettes... cherchez l'erreur

De plus, le choix de renvoyer un void * est pour le moins "casse gueule" car cela implique que, d'une manière ou du autre, tu dois savoir le type réel des données réellement manipulées si tu veux arriver à les manipuler correctement (comprends: en n'essayant pas de manipuler un short * comme s'il s'agissait d'un double * )

Je ne connais rien de ton projet, et je ne peux donc pas, dans l'état actuel des choses, te conseiller de manière correcte de travailler, mais, une chose est sure, je te déconseille fortement de suivre la voie que tu traces pour l'instant parce qu'elle va t'emmener très rapidement à quelque chose de tout à fait impossible à maintenir et à faire évoluer, et le problème de boutisme sera sans doute le moins important de tous