Discussion :

[Darki03]

Code :

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

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 ^^ !

Merci d'avance.

EDIT:
je pense que cela vient des define

Code :

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

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

[Darki03]

Bon voila j'ai implanté tes modifications et la je doit dire chapeau ! 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 !

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

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 !

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

[3DArchi]

Bon voila j'ai implanté tes modifications et la je doit dire chapeau ! 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 !

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.

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 !

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.

[Darki03]

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

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

[3DArchi]

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.

[Darki03]

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

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 :

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

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.

[3DArchi]

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

pourquoi appeler le template avec

Code :

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

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 :

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

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 :

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
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

[Darki03]

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

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 !

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 !

[3DArchi]

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.

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

[Darki03]

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 !

[3DArchi]

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

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
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 :

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

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;
      }