Decodage de données binaires

Bonjour, à tous !

Mes connaissances en programmation se limitant à ce que j'ai pu apprendre lors de ma scolarité, j'espère ne choquer personne avec mes questions ^^ !. J'éspère aussi poster au bon endroit :mrgreen: !

Voila je vous explique mon problème, j'ai écrit un petit bout de code maladroit qui mélange C et C++ (cela doit être affreux pour un programmeur confirmé mais le résultat est fonctionnel) qui a mon gout prend beaucoup de temps pour s'exécuter.

Le but de ce programme est de lire un fichier binaire qui contient un enregistrement de la communication numérique (ARINC) d'un équipement aéronautique.

Pour lire le fichier binaire pas de soucis cela se fait assez rapidement, le problème se situe au niveau du décodage des trames ARINC enregistrées, opération qui prend le plus de temps dans mon code.

Le fichier binaire contient en fait des succession de paquets de 9 octets : 5 octets contenant une info temporelle et 4 octets contenant le mot ARINC reçu.

Pour ce faire je lis l'ensemble des paquets de 9 octets et je les stockent un à un dans une liste chainée que je parcours ensuite pour les décoder, le résultats du décodage est stocké a son tour dans une structure qui est elle même stockée dans une autre liste chainée de structure (:bug:).

Le decodage consiste pour les 4 octets du mot ARINC a decomposer les 32 bits en différente parties pour obtenir les informations qu'il contient.Pour ce qui est de l'info temporelle les 5 octects contiennent sous forme binaire Heures;Minutes;Secondes et Microsecondes (8 bits pour les H, 6 pour les minutes, 6 pour les secondes et 20 pour les µsecondes)

Pour l'instant je me débrouille avec des divisions et des soustractions pour extraire les parties désirées du mot ou de l'info temporelle. De plus j'ai besoins d'afficher l'info temporelle sous la forme seconde.µsecondes ( H*3600+60*M+S+(µS/1000000)), ce calcul doit etre gourmand en temps je pense.

Ce projet étant lié a mon travail, je ne peut pas tout le temps rentrer dans le détail. Ma question se limite au problème de temps de calcul pour décoder les mots, si quelqu'un à une idée je lui en serait très reconnaissant.

Je peut donner plus d'infos dans un message privé (surtout que tout cela doit vous paraitre brouillon mais j'ai du mal à tout expliquer de manière succincte) et même vous fournir mon code si cela peut aider.

D'avance merci ;).

Tu stockes tes enregistrements bruts de 9 octets dans une liste chainée ==> OK

Par contre, je ne vois pas l'intérêt de stocker le résultat du décodage dans une autre liste chainée.

Cela t'oblige à décoder tous tes enregistrements bruts (effectivement, si tu en as beaucoup, cela peut prendre du temps) et surtout à stocker en mémoire une intreprétation de ce que tu as déjà. De plus, même si tu n'est pas intéressé par les 100 premiers (ou derniers, peut importe) enregistrements, tu calcule quand même leur représentation et tu stockes cette représentation en mémoire, quel gachis (je trouve).

Pourquoi ne pas calculer l'interprétation de ces résultats bruts que lorsque tu en as réellement besoin et ce n'est même pas la peine de la sauvegarder car d'après ce que tu montres, le temps de recalcul semble très rapide. Dans le calcul que tu as décrit, il n'y a rien de long (sauf si c'est répété quelques milliers de fois pour rien :?)

En fait je n'ai pas tout dit :D ! je stocke les informations décodées dans une liste car d'autres opérations sont réalisées ensuite ! en effet je dois faire des tests sur les infos décodées, par exemple pour l'ARINC chaque donnée est identifiée par un numéro de label (en octal sur 8 bits) et une transmission est une succession de labels qui doivent arriver dans un certain ordre et je teste cet ordre pour voire si on a pas perdus des billes en cours de route :D !. Au final je crée aussi un fichier csv qui contient les infos décodées, ce fichier n'est ni plus ni moins que les élément de ma liste chainée mis bout a bout (et donc dans l'ordre de récéption).

Je me sert aussi de la STL pour avoir des outil de comparaison entre listes pour faire les tests.

Certes le calcul cité ne doit pas être long mais pour certain enregistrements le nombre de mots reçu est important, par exemple pour 5 minutes on peut atteindre 900000 mots !

J'ai aussi essayé la méthode lecture->décodage->stockage dans une même boucle mais le résultats est identique au niveau timing ;).

Bonsoir,
La lecture du fichier peut être longue si tu fait des lectures successive de 9 octets par 9 octets, sans buffer.
Si c'est ce que tu fait, essai avec un filebuf, sinon ben j'ai pas d'autre idée...

La lecture du fichier est deja "bufferisée" et est deja très rapide ! c'est l'enchainement des décodages qui est la plus longue (peut etre n'existe t il pas de solution :D)

Bonjour,
As-tu fais un bench pour voir exactement quelles étaient les étapes les plus gourmandes ? Sinon toute recherche d'optimisation peut te faire aller dans des directions peu rentables ou contre-productives...
Dans ce que je comprend de ton exposé :
1/ Lecture du fichier: OK
2/ Pour tout mes enregistrement :
2.1 Decoder Enregistrement
2.1.1 Decoder Temps
2.1.2 Decoder Mot
2.2 Ajouter à la liste des Enregistrements décodées.

Qu'est-ce qui est gourmand : 2.1.1, 2.1.2 ou 2.2 ou tous ?

Citation:

---

Envoyé par Darki03

Pour l'instant je me débrouille avec des divisions et des soustractions pour extraire les parties désirées du mot ou de l'info temporelle.

---

Des masques et des décalages ?

Citation:

---

Envoyé par Darki03

De plus j'ai besoins d'afficher l'info temporelle sous la forme seconde.µsecondes ( H*3600+60*M+S+(µS/1000000)), ce calcul doit etre gourmand en temps je pense.

---

Le calcul n'est pas forcément ce qui te prendra plus le temps. La question peut plutôt se poser en ces termes : A l'affichage, tu ne vas probablement afficher qu'un faible nombre d'enregistrement sur l'écran (le nombre de ligne d'un écran étant limité). Peut-être ne faut-il faire cette transformation qu'à ce moment (d'autant si tu as un composant d'affichage 'intelligent' type liste virtuelle).

Citation:

---

Envoyé par 3DArchi

Bonjour,
As-tu fais un bench pour voir exactement quelles étaient les étapes les plus gourmandes ? Sinon toute recherche d'optimisation peut te faire aller dans des directions peu rentables ou contre-productives...
Dans ce que je comprend de ton exposé :
1/ Lecture du fichier: OK
2/ Pour tout mes enregistrement :
2.1 Decoder Enregistrement
2.1.1 Decoder Temps
2.1.2 Decoder Mot
2.2 Ajouter à la liste des Enregistrements décodées.

Qu'est-ce qui est gourmand : 2.1.1, 2.1.2 ou 2.2 ou tous ?

---

En fait je ne suis pas rentré dans le détail de la boucle de décodage, j'ai juste constaté que c'était l'opération la plus longue de mon programme.

Citation:

---

Envoyé par 3DArchi

Des masques et des décalages ?

---

Des décalages, par exemple pour le calcul des minutes et des secondes qui sont codées sur 6 bits et donc deux octets:
Les 6 bits de poids fort de l'o1 représentent les minutes, les deux bits de poids faible de l'o1 et les 4 bits de poids fort de l'o2 représentent les secondes.

Les calcul est le suivant:
minutes=o1>>2;
secondes=o2>>4;
secondes=secondes+(o1-4*minutes)*16;

Citation:

---

Envoyé par 3DArchi

Le calcul n'est pas forcément ce qui te prendra plus le temps. La question peut plutôt se poser en ces termes : A l'affichage, tu ne vas probablement afficher qu'un faible nombre d'enregistrement sur l'écran (le nombre de ligne d'un écran étant limité). Peut-être ne faut-il faire cette transformation qu'à ce moment (d'autant si tu as un composant d'affichage 'intelligent' type liste virtuelle).

---

En fait je n'affiche rien à l'écran, tout les résultats sont inscrits dans un fichier texte en sortie de programme (1 ligne par mot et données séparées par un ; ). De plus je construit aussi un petit fichier rapport qui contient des infos sur le décodage (nottament la liste des labels érronées).

Citation:

---

Envoyé par Darki03

En fait je ne suis pas rentré dans le détail de la boucle de décodage, j'ai juste constaté que c'était l'opération la plus longue de mon programme.

---

Peux-tu poster juste ce bout de code ?

A priori pas de soucis pour présenter cette partie de mon code (voir en piece jointe, attention les yeux ^^ !)

Pardonnez aussi mon impolitesse mais j'ai oubliè de vous remercier pour vos réponses et votre réactivité<:yaisse2: !

La première remarque qui me saute aux yeux - l'impact en perf n'est peut-être pas significatif mais.. - : pourquoi allouer sur le tas x et word et non pas les définir sur la pile ? A moins qu'il n'y a récursion ou que info soit très très grosse (et à ce moment que pour x), je ne vois pas l'intérêt.
Peux-tu fournir la définition de info ?

Voici la structure info:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

typedef struct { int label; int parite; int sec; int misec; int sdi; int ssm; bool test_par; string binaire; int error; int emit; int emit1; } info;

---

puiss(256,2) == 256*256 ?

Citation:

---

Envoyé par 3DArchi

puiss(256,2) == 256*256 ?

---

Oui, de meme que puiss(256,1)= 256 >< (je l'avait pas vu celle la Oo !)

Tes variables ont des noms affreux :nono:
En revanche, tu utilises la STL :king:; ca fera - de question à se poser.

Passons au cœur des choses :
En préambule, je ne te garantie pas que tout va améliorer la chose, mais à tester pour voir les impacts.
1/ Enlever les allocations dynamiques :

Code:

---

1 2 3 4 5 6

for(list<mot>::iterator k(read.begin()); k!= read.end();++k) { info x; unsigned char word[9]; }

---

2/ Decoded : faire un resize puisque tu as l'ensemble des éléments, puis avoir un iterateur d'insertion :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

size_t nbr_elts(0); while(posu<last_octet) // Tant que l'on a pas atteint le dernier octect { //lecture ... read.push_back(w); //On ajoute w a la liste read nbr_elts++; } Decoded.resize(nbr_elts); type<Decoded>::iterator it_courant(Decoded.begin()); for(list<mot>::iterator k(read.begin()); k!= read.end();++k) { info x; // ... decodage *it_courant = x; ++it_courant; }

---

3/ Que fait wordcopy_2 ?

4/ Je crois que les stringstream ne sont pas très performant. On va remplacer ça :

Code:

---

1 2 3 4 5

std::ostringstream label;//,c1,c2,c3,c4,c5; // label<<std::oct<<static_cast<int>(word[0]); //Conversion du label en octal std::istringstream l1(label.str()); // l1>>(*x).label; //On affecte la valeur du label a la variable label de la structure x

---

Qui si j'ai bien compris transforme un entier en octal et relit cet octal comme un entier. J'en comprend pas bien l'intérêt mais bon...
On va se servir du compilateur pour nous générer une transformation bien plus efficace en utilisant les principes de la méta-programmation (on aurait peut être pu utiliser boost, mais je ne sais pas si tu l'utilises):
On commence par définir une méta-fonction qui nous fait tout le calcul (j'ai pas réfléchie au pb LSB/MSB, je te laisse le soin de vérifier) :
(tu as besoin d'inclure #include <climits> pour CHAR_BIT)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

template<int Loop, long long dix = 1> struct dec2oct2dc { inline static long long DoIt(int word_) { return ((word_&0x07))*dix + dec2oct2dc<(Loop-3>0?Loop-3:0), dix*10>::DoIt(word_>>3); } };   template<long long dix> struct dec2oct2dc<0,dix> { inline static long long DoIt(int) { return 0; } };

---

Ensuite on remplace les lignes de codes avec les stream par :

Code:

---

1 2	x.label = dec2oct2dc<sizeof(int)*CHAR_BIT>::DoIt(static_cast<int>(word[0]));

---

Toujours dans le même ordre d'idée, on va changer ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

std::bitset<8> b1(word[0]); // std::bitset<8> b2(word[1]); // std::bitset<8> b3(word[2]); // std::bitset<8> b4(word[3]); // std::ostringstream a1,a2,a3,a4; //Conversion en binaire des 4 octet du mot ARINC a1<<b1; // a2<<b2; // a3<<b3; // a4<<b4; // (*x).binaire=a4.str()+a3.str()+a2.str()+a1.str(); //x.bianaire = les 32 bit du mot arinc a la suite (MSB --- LSB)

---

Par ... horreur ... des macros ::aie:

Code:

---

1 2 3 4 5 6 7 8 9 10

#define TOBIT_0(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0'); #define TOBIT_1(c_,pc) (*(pc) = ((c_))&0x01)?'1':'0');TOBIT_0((c_)>>1,(pc)-1) #define TOBIT_2(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_1((c_)>>1,(pc)-1) #define TOBIT_3(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_2((c_)>>1,(pc)-1) #define TOBIT_4(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_3((c_)>>1,(pc)-1) #define TOBIT_5(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_4((c_)>>1,(pc)-1) #define TOBIT_6(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_5((c_)>>1,(pc)-1) #define TOBIT_7(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_6((c_)>>1,(pc)-1) #define TOBIT(c_,pc) TOBIT_7(c_,pc)

---

Et le code devient :

Code:

---

1 2 3 4 5 6 7 8

char str_bit[33]; str_bit[32]=0; TOBIT(word[0],&str_bit[31]); TOBIT(word[1],&str_bit[23]); TOBIT(word[2],&str_bit[15]); TOBIT(word[3],&str_bit[7]); x.binaire = str_bit;

---

5/ (ligne à peu de valeur ajoutée ?)
On remplace

Code:

---

usec=(word[6]-16*sec)*puiss(256,2)+word[5]*puiss(256,1)+word[4]; // Calcul des µsec

---

par

Code:

---

usec=(word[6]&0x0F)*256*256+word[5]*256)+word[4]; // Calcul des µsec

---

Hypothèse = puiss(256,2)==256*256 et puiss(256,1)=256...

6/ De la même façon, on peut remplacer

Code:

---

sec=sec+(word[7]-4*m)*16; //Calcul des secondes

---

par

Code:

---

sec=sec+(word[7]&0x03)*16; //Calcul des secondes

---

7/ Dernier point : que fait test_parite ? En fait, prend-il beaucoup de temps ?

[EDIT] ci-joint ton fichier remanié. Il te reste encore un peu de boulot pour vérifier le tout ;)

:king: merci pour toutes ces réponses, je vais étudier ça ce soir à la maison (au boulot je suis pas mal pris par d'autres choses et je me débrouille avec mon programme tel quel).

Pour les deux fonctions wordcopy_2 et test_par en voici le détail:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

//Fonction pour copier le mot a2 dans le mot a1 void wordcopy(unsigned char a1[9], unsigned char a2[9]) { int i=0; for(i=0;i<=9;i++) { a1[i]=a2[i]; } }   //Fonction pour copier le mot a2 dans le mot a1 void wordcopy_2(unsigned char * const a1, unsigned char a2[9]) { int i=0; unsigned char *pi; pi=a1; for(i=0;i<=9;i++) { *pi=a2[i]; pi++; } }

---

en fait j'ai fait wordcopy_2 a cause de l'allocation dynamique mais comme tu me conseille plutot de l'enlever, wordcopy suffit !8O

Code:

---

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

//Calcul du nombre de bit a 1 dans un char int nb_bit_1(char n) { int count=0; while(n){ count++; n &= n-1; } return count; }   //Test de la parité d'un mot ARINC (si n1 est pair alors par=1, si n1 est impair par=0) bool test_parite( unsigned char a[9],int par) { bool k=0; int nb1=0; int last=0; last=a[3]>>7; // last=a[3]-128*last; //On retire le bit de parité dans le mot d'entrée nb1 = nb_bit_1(last)+nb_bit_1(a[2])+nb_bit_1(a[1])+nb_bit_1(a[0]); //Nb de bit a 1 dans les 31 bits restants if ( ( ( nb1 & 1 ) && ( par==0 ) ) || ( !( nb1 & 1 ) && ( par==1 ) ) ) //Si nb1 est impair et par=0 ou Si nb1 est pair et par=1 alors le test est True { k=1; } else { k=0; //Sinon le test est False } return k; }

---

Cette fonction réalise un test de parité sur le mot ARINC. Elle compare le bit de parité à la valeur qui devrait etre envoyée en fonction du nombre de bits à 1 dans les 31 bits restants.

Derniere question, si j'ai bien compris [word[3]-128*par] est équivalent à [word[3]&0x7F] ?

Citation:

---

Envoyé par Darki03

Pour les deux fonctions wordcopy_2 et test_par en voici le détail:

---

Sauf erreur de recopie, tu as un bug dans tes fonctions wordcopy : i va jusqu'à 9 inclus alors que le tableau est de taille 9 (donc dernier adressable est [8]). :aie: Jamais eu de plantage inexpliqué ?

Citation:

---

Envoyé par Darki03

en fait j'ai fait wordcopy_2 a cause de l'allocation dynamique mais comme tu me conseille plutot de l'enlever, wordcopy suffit !8O

---

Sinon, si tu l'as, utilises memcpy. En général, il est optimisé pour être plus efficace que ta fonction.

Citation:

---

Envoyé par Darki03

Code:

---

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

//Calcul du nombre de bit a 1 dans un char int nb_bit_1(char n) { int count=0; while(n){ count++; n &= n-1; } return count; }   //Test de la parité d'un mot ARINC (si n1 est pair alors par=1, si n1 est impair par=0) bool test_parite( unsigned char a[9],int par) { bool k=0; int nb1=0; int last=0; last=a[3]>>7; // last=a[3]-128*last; //On retire le bit de parité dans le mot d'entrée nb1 = nb_bit_1(last)+nb_bit_1(a[2])+nb_bit_1(a[1])+nb_bit_1(a[0]); //Nb de bit a 1 dans les 31 bits restants if ( ( ( nb1 & 1 ) && ( par==0 ) ) || ( !( nb1 & 1 ) && ( par==1 ) ) ) //Si nb1 est impair et par=0 ou Si nb1 est pair et par=1 alors le test est True { k=1; } else { k=0; //Sinon le test est False } return k; }

---

Cette fonction réalise un test de parité sur le mot ARINC. Elle compare le bit de parité à la valeur qui devrait etre envoyée en fonction du nombre de bits à 1 dans les 31 bits restants.

---

Je jette un coup d'oeil.

Citation:

---

Envoyé par Darki03

Derniere question, si j'ai bien compris [word[3]-128*par] est équivalent à [word[3]&0x7F] ?

---

:ccool: (il m'avait échappé).

Code:

---

1 2 3

last=a[3]>>7; // last=a[3]-128*last; //On retire le bit de parité dans le mot d'entrée

---

Peut juste être simplifié :

Code:

---

1 2	last=a[3]&0x7f; //Tu connais maintenant !

---

Ton code ressemble furieusement à du code C qui aurait été porté en C++, non ?

Citation:

---

Envoyé par 3DArchi

Sauf erreur de recopie, tu as un bug dans tes fonctions wordcopy : i va jusqu'à 9 inclus alors que le tableau est de taille 9 (donc dernier adressable est [8]). :aie: Jamais eu de plantage inexpliqué ?

---

Oo je sais pas pourquoi j'ai fait ça mais y'a bel et bien un soucis. A priori cela n'engendre pas de plantage 8O ! je vais quand meme corriger cela tout de suite !

Citation:

---

Envoyé par Darki03

A priori cela n'engendre pas de plantage 8O !

---

Tu as eu de la chance ;) (probablement que l'octet est un octet de padding pour de l'alignement et non significatif).

Citation:

---

Envoyé par 3DArchi

Code:

---

1 2 3

last=a[3]>>7; // last=a[3]-128*last; //On retire le bit de parité dans le mot d'entrée

---

Peut juste être simplifié :

Code:

---

1 2	last=a[3]&0x7f; //Tu connais maintenant !

---

Ton code ressemble furieusement à du code C qui aurait été porté en C++, non ?

---

En fait j'ai écrit des partie de code avec mes souvenirs de cours de C (parce qu'on retient les choses plus facilement après le C++ avec les classes, héritage et encapsulation et autres bizzareries je ne me rappelle plus grand chose !)

Les parties en C++ ont été faite a partir de toutes mes recherches sur internet :D !

Code:

---

1 2 3 4 5

TOBIT(word[0],&str_bit[31]); TOBIT(word[1],&str_bit[23]); TOBIT(word[2],&str_bit[15]); TOBIT(word[3],&str_bit[7]);

---

je me retrouve avec un erreur : expected ';' before ')' token.

J'essaie de comprendre de mon coté mais si tu as une idée ^^ !:mouarf:

Merci d'avance.

EDIT:
je pense que cela vient des define 8O

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

/* ************************************************** */ #define TOBIT_0(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0') #define TOBIT_1(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_0((c_)>>1,(pc)-1) #define TOBIT_2(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_1((c_)>>1,(pc)-1) #define TOBIT_3(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_2((c_)>>1,(pc)-1) #define TOBIT_4(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_3((c_)>>1,(pc)-1) #define TOBIT_5(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_4((c_)>>1,(pc)-1) #define TOBIT_6(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_5((c_)>>1,(pc)-1) #define TOBIT_7(c_,pc) (*(pc) = ((c_)&0x01)?'1':'0');TOBIT_6((c_)>>1,(pc)-1) #define TOBIT(c_,pc) TOBIT_7(c_,pc) /* ************************************************** */

---

y'avait une parenthèse en trop :D :king:

Bon voila j'ai implanté tes modifications et la je doit dire chapeau :king:! le résultat est sans équivoque : avant pour 1500000 mots enregistrés il fallait 4 minutes environs et la je suis proche des 10 secondes 8O8O8O8O :yaisse2:!

Je te remercie 3DArchi pour cette aide précieuse et pour le temps que tu as consacré à mon problème :king:!

Si de mon coté j'avait plus de temps je pousserai le projet encore plus loin en créant une interface graphique pour ce programme (pour l'instant je me débrouille en ligne de commande sous cygwin).

J'imaginai aussi des fonctionnalités comme l'ouverture des fichiers binaire et affichage dans la fenêtre du soft, recherche de labels, tri, etc... mais bon cela reste au dessus de mes compétences :aie:!

Merci encore, je passe le sujet en résolu :mouarf: !

Citation:

---

Envoyé par Darki03

Bon voila j'ai implanté tes modifications et la je doit dire chapeau :king:! le résultat est sans équivoque : avant pour 1500000 mots enregistrés il fallait 4 minutes environs et la je suis proche des 10 secondes 8O8O8O8O :yaisse2:!

---

Je pense que le nœud principal était dans les sstream. En théorie, c'est mieux de les utiliser mais côté perf, ça se révèle être une catastrophe à chaque fois qu'on les créé et qu'on les supprime dans une boucle. Les autres (les masques par expl), je ne suis pas persuadé que cela a fait gagner grand chose, mais personnellement je trouve cela plus clair quand on relit le code. Question de point de vue, j'imagine.

Citation:

---

Envoyé par Darki03

Si de mon coté j'avait plus de temps je pousserai le projet encore plus loin en créant une interface graphique pour ce programme (pour l'instant je me débrouille en ligne de commande sous cygwin).


J'imaginai aussi des fonctionnalités comme l'ouverture des fichiers binaire et affichage dans la fenêtre du soft, recherche de labels, tri, etc... mais bon cela reste au dessus de mes compétences :aie:!

---

Mais ça te permettra aussi d'améliorer tes connaissances ;)

Par curiosité, à quoi ça te sert de transformer les nombres de la représentation décimale vers une représentation octal, puis interpréter cette représentation octale comme décimale (le code qu'on a remplacé par une méta-fonction à base de template). J'avoue avoir du mal à voir à quoi cela peut servir.

Citation:

---

Envoyé par 3DArchi

Par curiosité, à quoi ça te sert de transformer les nombres de la représentation décimale vers une représentation octal, puis interpréter cette représentation octale comme décimale (le code qu'on a remplacé par une méta-fonction à base de template). J'avoue avoir du mal à voir à quoi cela peut servir.

---

En fait je suis en train d'essayer de comprendre ce que tu as fait (j'ai du mal mais ça va venir). Ce que j'avais fait la première fois avec des recherches internet (sur le site de developpez.com d'ailleurs http://cpp.developpez.com/faq/cpp/?page=SL
) c'est une conversion en octal puis une conversion du string résultant en int, mais bon c'est ce que j'ai compris :aie:

Sinon ta fonction retourne bien le premier octet du mot ARINC sous sa forme octale (c'est dans cette base qu'il est codé 8O)

Ce que tu avais fait avec les sstream est, je dirais, la solution à prendre dans la plus part des cas. Sauf qu'il faut savoir que ça a un impact sur les perfs. Donc, dans ton cas particulier où tu dois le faire pour plus d'1,5 millions de fois, il vaut mieux chercher une autre solution. On aurait pu utiliser une bête fonction inline qui aurait fait la même chose, mais je trouve cela plus 'élégant' de passer par un peu de méta-programmation. Lis cet article ça en décrit les idées et les principes.

Merci pour les infos ! j'ai regardé rapidement et j'ai presque compris :aie: !

Donc tu utilise la recursion et la spécialisation pour créer une boucle avec le template, en gros on fait:

(Word_&0x07)*dix (=1) + ((Word_>>3)&0x07)*(dix*10=dizaines) (=10*1=10 1ieme itération) + (((Word_>>3)>>3)&0x07)*(dix*10) (=10*10=100=centaines 2ieme itération)+ etc..

on s'arrete quand Loop-3<0 (la specialisation avec le return 0)

Par contre voici mes questions:

pourquoi définir la variable dix en long long?

pourquoi appeler le template avec

Code:

---

dec2oct2dec<sizeof(int)*CHAR_BIT>(static_cast<int>(Word[0]))

---

?

avec ceci on a Loop=32 et on boucle 11 fois (en gros on fait les 4 octets de l'int en entrée). Or dans le cadre de mon problème le label en octal est codé sur 1 octet seulement (0 à 377 en octal) donc un dec2oct2dec<7> suffirait.

Citation:

---

Envoyé par Darki03

pourquoi définir la variable dix en long long?

---

Car avec un int (32 bits), on peut déborder dans ta conversion : 4 294 967 295 -> 37 777 777 777

Citation:

---

Envoyé par Darki03

pourquoi appeler le template avec

Code:

---

dec2oct2dec<sizeof(int)*CHAR_BIT>(static_cast<int>(Word[0]))

---

?

avec ceci on a Loop=32 et on boucle 11 fois (en gros on fait les 4 octets de l'int en entrée). Or dans le cadre de mon problème le label en octal est codé sur 1 octet seulement (0 à 377 en octal) donc un dec2oct2dec<7> suffirait.

---

Parceque ton code passait par un int :

Code:

---

1 2 3

std::ostringstream label; label<<std::oct<<static_cast<int>(word[0]);

---

J'ai pas cherché à réfléchir... Je suis parti sur un int...
C'est la fête, on généralise avec une classe trait en prime :

Code:

---

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 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

#include <iostream> #include <climits>   // une classe trait de base : template<class T> struct dec2oct2dc_trait_base {};   // Définition de notre classe trait : template<class T> struct dec2oct2dc_trait:public dec2oct2dc_trait_base<T> { typedef typename dec2oct2dc_trait_base<T>::dix_type ret_type; // le type retour nous est donnee par le type pour dix static const size_t nbr_bits = sizeof(char)*CHAR_BIT; // la taille en bit du type };   // notre méta-fonction // l'avantage avec les classes traits // c'est qu'ici, on n'a plus de type spécifique (hormis pour loop) : template< class T, // le type size_t Loop=dec2oct2dc_trait<T>::nbr_bits, // l'indice de loop qu'on débute par défaut au nbr de bit typename dec2oct2dc_trait<T>::dix_type dix = 1 // notre multiple de 10 > struct dec2oct2dc { inline static typename dec2oct2dc_trait<T>::ret_type DoIt(T val_) { return ((val_&0x07))*dix + dec2oct2dc<T,(Loop>3?Loop-3:0), dix*10>::DoIt(val_>>3); } }; // notre méta-fonction spécialisée partiellement pour la dernière boucle : template<class T, typename dec2oct2dc_trait<T>::dix_type dix> struct dec2oct2dc<T, 0,dix> { inline static typename dec2oct2dc_trait<T>::ret_type DoIt(T) { return static_cast<typename dec2oct2dc_trait<T>::ret_type>(0); } };   // une petite fonction pour rendre le tout plus lisible à l'utilisation : template<class T> inline typename dec2oct2dc_trait<T>::ret_type dec2oct2dc_fn(T param_) { return dec2oct2dc<T>::DoIt(param_); }   // Les spécialisations partielles de dec2oct2dc_trait_base // Elles doivent être définies avant l'utilisation effective de dec2oct2dc_fn   // une spécialisation de notre classe trait de base pour le type char template<> struct dec2oct2dc_trait_base<char> {typedef int dix_type;};   // une spécialisation de notre classe trait de base pour le type unsigned char template<> struct dec2oct2dc_trait_base<unsigned char> {typedef int dix_type;};   template<> struct dec2oct2dc_trait_base<int> {typedef long long dix_type;};     // L'utilisation : int main() { char c=42; std::cout<<" 1 = "<<dec2oct2dc_fn(c)<<std::endl; std::cout<<" 2 = "<<dec2oct2dc_fn(static_cast<unsigned char>(c))<<std::endl; std::cout<<" 3 = "<<dec2oct2dc_fn(static_cast<int>(c))<<std::endl;   return 5; }

---

Avec ça, te v'là repartis pour quelques nouvelles lectures et réflexions :mouarf:

Citation:

---

Envoyé par 3DArchi

Avec ça, te v'là repartis pour quelques nouvelles lectures et réflexions :mouarf:

---

Oui en effet ! en tout cas merci pour toutes ces infos ! Il faut que je lise tout ceci a tête reposée comme on dit :king: !

Grace a cette technique on peut spécialiser la meta fonction pour les différents types possibles ! En attendant il faut que je devellope un autre bout de code pour lire d'autres fichiers binaires avec une structure différente et la il me faut juste controler l'ecart de temps entre deux paquets de données enregistrées (cela devrait etre plus simple !)

Par contre aurait tu des infos sur une techinque permettant de créer des dictionnaires de décodage, je m'explique : par exemple chaque numéro de label est associé à un numéro de variable et on s'attend a avoir certaine valeur pour les différentes partie du mot (chaque mot transporte une donnée qui est codée sur un ceratin nb de bit et avec une résolution spécifique a chaque label). Pour l'instant je me débrouille en chargeant le contenu d'un fichier texte dans des conteneurs et en faisant des comparaison.

Je te remercie par avance ! :yaisse2:

Citation:

---

Envoyé par Darki03

Par contre aurait tu des infos sur une techinque permettant de créer des dictionnaires de décodage, je m'explique : par exemple chaque numéro de label est associé à un numéro de variable et on s'attend a avoir certaine valeur pour les différentes partie du mot (chaque mot transporte une donnée qui est codée sur un ceratin nb de bit et avec une résolution spécifique a chaque label). Pour l'instant je me débrouille en chargeant le contenu d'un fichier texte dans des conteneurs et en faisant des comparaison.

---

:koi:
Rien compris.
Tu as les conteneurs associatifs (type std::map), mais je ne suis pas sur que ce soit ce que tu demandes.

Oui je m'explique mal ^^' !
En fait un mot ARINC de 32 bits contient 5 parties:
1 bit de parité
2 bits de SSM
19 bits de Data
2 bits de SDI
8 bits de Label

En gros à chaque numéro de label on associe un nom de variable, le SDI identifie la source du mot (0, 1, 2 ou 3), le SSM represente soit le signe de la donnée si celle ci est codée en BCD ou son statut fonctionnel en BNR, la parité est testée via ma fonction de test.

Pour la data elle peut etre codée sur un nombre de bit spécifique (pas forcement sur les 19 bits).

Donc en fait pour avoir des infos complétement décodées vis à vis de l'équipement sur lequel je bosse il faudrait lorsque l'on décode un numéro de label pouvoir récupérer:
-> Le Nom de variable associé
-> Le SDI attendu
-> Le SSM attendu
-> Le Masquage/decalage pour avoir la donnée ainsi que la résolution de décodage pour le BNR (complément à deux)

Je sait pas si j'ai été assez clair :aie:!

Une version générique de ton problème d'association (certainement perfectible) (commentaire inside) :

Code:

---

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 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145

#include <string> #include <map>   // classes de base qui nous servira dans le tableau associatif struct ARINC_decoder_base { virtual void masquer_donnee(/*TODO*/)const=0; virtual void decoder_donnee(/*TODO*/)const=0; virtual std::string const& variable_name()const=0; virtual unsigned char ssm()const=0; virtual unsigned char sdi()const=0; }; namespace ARINC_details_ { enum ARINC_labels // Les différents labels de ton équipement : { L_1, L_2, L_3 //TODO pour tous tes labels ... };   // les 'politiques' de label : une 'politique' partage les même fonctions de masquage et décodage de données pour plusieurs labels: enum ARINC_politique_labels_ { POL_A, POL_B, POL_C, POL_D //TODO pour toutes tes politiques de labels ... }; template<ARINC_politique_labels_> struct ARINC_decoder_politique {}; // spécialisation partielle pour chaque politique : template<> struct ARINC_decoder_politique<POL_A> { static void masquer_donnee(/*TODO*/){/*TODO*/} static void decoder_donnee(/*TODO*/){/*TODO*/} };   template<> struct ARINC_decoder_politique<POL_B> { static void masquer_donnee(/*TODO*/){/*TODO*/} static void decoder_donnee(/*TODO*/){/*TODO*/} }; //TODO pour toutes tes politiques de labels ... // association label&politique : template<ARINC_labels> struct politique_label{}; template<> struct politique_label<L_1> { typedef ARINC_decoder_politique<POL_A> politique; }; template<> struct politique_label<L_2> { typedef ARINC_decoder_politique<POL_A> politique; }; template<> struct politique_label<L_3> { typedef ARINC_decoder_politique<POL_B> politique; }; //TODO pour toutes tes associations labels/politiques de labels ...   template<ARINC_labels> struct ARINC_decoder_trait{ static const std::string str_variable_name; static const unsigned char m_ssm_expected; static const unsigned char m_sdi_expected; }; // tu les définis pour chaque label : // pour ça, je n'hésite pas à me faire des macros : #define DEFINE_DECODER_TRAIT(label_, var_name_, ssm_,sdi_)\   template<> const std::string ARINC_decoder_trait<label_>::str_variable_name = var_name_;\   template<> const unsigned char ARINC_decoder_trait<label_>::m_ssm_expected=ssm_;\   template<> const unsigned char ARINC_decoder_trait<label_>::m_sdi_expected=sdi_;     DEFINE_DECODER_TRAIT(L_1,"var_1",0x01,0x01) DEFINE_DECODER_TRAIT(L_2,"var_2",0x01,0x02) DEFINE_DECODER_TRAIT(L_3,"var_3",0x01,0x02) //TODO pour tous tes labels   // ne pas laisser de define qui ne servent plus #undef DEFINE_DECODER_TRAIT   // association des labels et des infos : template<ARINC_labels label_> struct ARINC_labels_desc : public ARINC_decoder_base { virtual void masquer_donnee(/*TODO*/)const { politique_label<label_>::politique::masquer_donnee(); } virtual void decoder_donnee(/*TODO*/)const { politique_label<label_>::politique::decoder_donnee(); }   virtual std::string const& variable_name()const { return ARINC_decoder_trait<label_>::str_variable_name; } virtual unsigned char ssm()const { return ARINC_decoder_trait<label_>::m_ssm_expected; } virtual unsigned char sdi()const { return ARINC_decoder_trait<label_>::m_sdi_expected; } }; }   struct ARINC_decoder { private: ARINC_decoder(); ARINC_decoder(ARINC_decoder const&); ARINC_decoder&operator=(ARINC_decoder const&); ~ARINC_decoder();   typedef std::map<unsigned char,ARINC_decoder_base const *> containter; typedef containter::const_iterator citerator; static void build_it(containter&cont_) { cont_[0x01]=new ARINC_details_::ARINC_labels_desc<ARINC_details_::L_1>(); cont_[0x02]=new ARINC_details_::ARINC_labels_desc<ARINC_details_::L_2>(); cont_[0x03]=new ARINC_details_::ARINC_labels_desc<ARINC_details_::L_3>(); //TODO pour toutes tes associations octet reçu/label ... }   public: static ARINC_decoder_base const* get_it(unsigned char uc_) { static containter s_decoders; if(s_decoders.size()==0){ build_it(s_decoders); } citerator it(s_decoders.find(uc_)); if(it==s_decoders.end()){ // throw une erreur : throw std::exception(); // ou return NULL; } return it->second; } };

---

Utilisation :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

// unsigned char uc_ le label de la trame reçue ARINC_decoder_base const*le_decodeur(ARINC_decoder::get_it(uc_)); if(le_decodeur){ le_decodeur->masquer_donnee(); le_decodeur->decoder_donnee(); le_decodeur->variable_name(); le_decodeur->ssm(); le_decodeur->sdi(); } else { std::cout<<static_cast<int>(uc_)<<" label invalide"<<std::endl; }

---