[Débutant] Question de principe sur mapping de données sur les attributs d'une classe

Question de principe sur mapping de données sur les attributs d'une classe

Bonjour,

En essayant de me bricoler quelques outils (en l'occurence ici, conversion de données videos proprietaire d'un enregistreur TNT vers un format plus standard) je suis de nouveau confronté à un problème que j'avais déjà rencontré lors de l'écriture d'une sorte de parseur RTP. Si le seul objectif était le résultat, je l'écrirais en C, mais désireux d'en profiter pour me familiariser avec C# j'ai choisi de m'y risquer.

Au final mes outils marchent, mais sont d'une lenteur calamiteuse. Mon problème est le suivant:

Imaginons, la structure de données suivante assez simple (entête paquet RTP): http://www.networksorcery.com/enp/protocol/rtp.htm

En C, langage qui m'est plus familier, j'aurais fait quelque chose du genre:
Code:

1 2 3 4 5 6 7 8 struct rtp_header{ short version:2 // 2 bits pour la version short padding:1 // 1 bit de padding short extension:1 // 1 bit pour l'extension short extension:4 // 4 bits pour le nombre de CRC etc... en continuant de mapper un nombre de bits de mes types de bases en fonction de mes besoins. }
ensuite à partir d'un buffer contenant les octets lus, je ferais un memcpy du buffer dans une instance de cette structure. Le mapping est immédiat et rapide.

En C#, j'ai une classe pour ce type de paquet, qui hérite d'une classe générique et qui définit des attribiuts propre correspondant aux différents champs.
Je remplis donc ces attributs à grand renfort de '&' logiques avec des masques et des décalages de bits.

Cette méthodologie est-elle correcte ? Comment implémenteriez un tel mapping tableau de bits/groupes de bits et dans quel type d'objet (classe, autre..) ?

Merci d'avance pour tout commentaire constructif.

La méthode pour remplir la structure me semble correcte.

Citation:

Envoyé par Naouin

Au final mes outils marchent, mais sont d'une lenteur calamiteuse. Mon problème est le suivant:

Es-tu sûr que le problème de lenteur vienne réellement de là ? Tu devrais utiliser un profiler pour en être sûr.
Si c'est le cas montre nous ton code que l'on puisse t'aider à l'optimiser

Yop,

merci pour ton retour. Donc à ta demande, voici qques extraits de code significatif.

D'abord 2 extraits de classes annexes (J'ai remplacé les accesseurs par un commentaire, pas de problème à ce niveau):

- La classe MpegPS_PackHeader:

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
 
    class MpegPS_PackHeader:MpegPS_Packet
    {
        private ulong _scr;
        private ushort _scr_ext;
        private uint _program_mux_rate;
        private int _pack_stuffing_length;
//        private int _stuffing_byte = 0xFF;
 
//..blabla, les accesseurs ici (même noms que les attributs, sans les "_").
 
// le constructeur
        public MpegPS_PackHeader(Byte[] buf)
        {
            type = "00-00-01-BA";
            Byte[] scrByte = {0x00, 0x00, 0x00, buf[8], buf[7], buf[6], buf[5], buf[4]};
            scr = get_scr((BitConverter.ToUInt64(scrByte, 0) >> 27) & (UInt64)0x000000077FFF7FFF);
            Byte[] scr_extByte = {buf[9], buf[8]};
            _scr_ext = (UInt16)((BitConverter.ToUInt16(scr_extByte, 0) >> 1) & (UInt16)0x01FF);
            Byte[] prg_mux_rate = {0x00, buf[12], buf[11], buf[10]};
            _program_mux_rate = (UInt32)((BitConverter.ToUInt32(prg_mux_rate, 0) >> 10) & (UInt32)0x003FFFFF);
            _pack_stuffing_length = buf[13] & 0x07;
            totalLength = (UInt32)(14 + _pack_stuffing_length);
            setPayloadData(null);
            setHeaderData(null);
        }
 
        private ulong get_scr(ulong scrValue)
        {
//            Console.WriteLine(String.Format("{0:X}", scrValue));
            ulong scr_30_32 = (scrValue & (UInt64)0x0000000700000000) >> 32;
            ulong scr_16_29 = (scrValue & (UInt64)0x000000007FFF0000) >> 16;
            ulong scr_0_15 = (scrValue & (UInt64)0x0000000000007FFF);
            return ((((scr_30_32 << 15) | scr_16_29) << 15) | scr_0_15);
        }
    }

- La classe pour les packets de type media:

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
 
    class MpegPS_PacketizedElementaryStreamHeader:MpegPS_Packet
    {
        private MpegPS_Extension _MpegPS_extension = null;
//        private Byte[] _PESPacketBuffer;
 
// accesseurs ici
 
// Le constructeur:
        public MpegPS_PacketizedElementaryStreamHeader(Byte[] buf)
        {
            type = BitConverter.ToString(buf, 0, 4);
            totalLength = (UInt32)buf[4] << 8 | buf[5];
            headerLength = 6;
            payloadLength = 0;
            _MpegPS_extension = null;
        }
 
        public void addMpegPS_Extension(Byte[] buf)
        {
            _MpegPS_extension = new MpegPS_Extension(buf);
        }
/*
        public void addPayloadData(Byte[] buf)
        {
            _payloadData = new Byte[totalLength];
            buf.CopyTo(_payloadData, 0);
        }
*/
    }

- les deux classes d'extension référencé dans la classe media:

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
 
    class MpegPS_PES_Extension
    {
        private UInt32 _pes_extensionLenght;
        private Boolean _PES_private_data_flag;
        private Byte[] _PES_private_data;
        private Boolean _pack_header_field_flag;
        private Byte _pack_header_field_length;
        private Boolean _program_packet_sequence_counter_flag;
        private Byte _packet_sequence_counter;
        private Boolean _mpeg1_mpeg2_identifier;
        private Byte _original_stuffing_length;
        private Boolean _PSTD_buffer_flag;
        private Boolean _PSTD_buffer_scale;
        private UInt16 _PSTD_buffer_size;
        private Boolean _PES_extension_flag_2;
        private Byte _PES_extension_field_length;
 
// Les accesseurs ici
 
// Le constructeur
        public MpegPS_PES_Extension(Byte buf)
        {
            pes_extensionLenght = 1;
            PES_private_data_flag = ((buf & 0x80) == 0x80);
            pack_header_field_flag = ((buf & 0x40) == 0x40);
            program_packet_sequence_counter_flag = ((buf & 0x20) == 0x20);
            PSTD_buffer_flag = (buf & 0x10) == 0x10;
            PES_extension_flag_2 = (buf & 0x01) == 0x01;
        }
    }
 
    class MpegPS_Extension
    {
        private UInt32 _extensionLength;
 
        private Byte _PES_scrambling_control;
        private Boolean _PES_priority;
        private Boolean _data_alignement_indicator;
        private Boolean _copyright;
        private Boolean _original;
        private Boolean _PTS_flag;
        private UInt32 _PTS;
        private Boolean _DTS_flag;
        private UInt32 _DTS;
        private Boolean _ESCR_flag;
        private UInt32 _ESCR_base;
        private UInt16 _ESCR_ext;
        private Boolean _ES_rate_flag;
        private UInt32 _ES_rate;
        private Boolean _DSM_trick_mode_flag;
        private Boolean _additional_copy_info_flag;
        private Byte _additional_copy_info;
        private Boolean _PES_CRC_flag;
        private UInt16 _PES_CRC;
        private Boolean _PES_extension_flag;
        private MpegPS_PES_Extension _PES_extension;
        private Byte _PES_header_data_length;
 
// Les accesseurs ici
 
// Le constructeur
        public MpegPS_Extension(Byte[] buf)
        {
            _extensionLength = 3;
            PES_scrambling_control = (Byte)((buf[0] & 0x30) >> 4);
            PES_priority = ((buf[0] & 0x08) == 0x08) ? true : false;
            data_alignement_indicator = ((buf[0] & 0x04) == 0x04) ? true : false;
            copyright = ((buf[0] & 0x02) == 0x02) ? true : false;
            original = ((buf[0] & 0x01) == 0x01) ? true : false;
            PTS_flag = ((buf[1] & 0x80) == 0x80) ? true : false;
            if (PTS_flag)
            {
                _extensionLength += 5;
            }
            DTS_flag = ((buf[1] & 0x40) == 0x40) ? true : false;
            if (DTS_flag)
            {
                _extensionLength += 5;
            }
            ESCR_flag = ((buf[1] & 0x20) == 0x20) ? true : false;
            if (ESCR_flag)
            {
                _extensionLength += 6;
            }
            ES_rate_flag = ((buf[1] & 0x10) == 0x10) ? true : false;
            if (ES_rate_flag)
            {
                _extensionLength += 3;
            }
            DSM_trick_mode_flag = ((buf[1] & 0x08) == 0x08) ? true : false;
            additional_copy_info_flag = ((buf[1] & 0x04) == 0x04) ? true : false;
            if (additional_copy_info_flag)
            {
                _extensionLength += 1;
            }
            PES_CRC_flag = ((buf[1] & 0x02) == 0x02) ? true : false;
            if (PES_CRC_flag)
            {
                _extensionLength += 2;
            }
            PES_extension_flag = ((buf[1] & 0x01) == 0x01) ? true : false;
            if (PES_extension_flag)
            {
                _extensionLength += 1;
            }
            PES_header_data_length = buf[2];
        }
    }
}

Puis un bout de code du thread principal:

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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
                    while ((nbBytesRead = myStreamIn.Read(readBuffer, 0, 4)) > 0)
                    {
                        switch (BitConverter.ToString(readBuffer, 0, 4))
                        {
                            case "00-00-01-BA":
                                sw.Start();
                                nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, 10);
                                myPackHeader = new MpegPS_PackHeader(readBuffer);
                                myMpegPS_Stream.AddLast(myPackHeader);
                                if (myPackHeader.pack_stuffing_length != 0)
                                    nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, myPackHeader.pack_stuffing_length);
                                myPackHeader.setHeaderData(readBuffer.Take(nbBytesRead).ToArray());
                                sw.Stop();
                                printExecutionTime();
                                sw.Reset();
                                break;
 
                            case "00-00-01-BB":
                                sw.Start();
                                nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, 8);
                                myProgramSystemStream = new MpegPS_ProgramStreamSystemHeader(readBuffer);
                                myMpegPS_Stream.AddLast(myProgramSystemStream);
                                nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, 3);
                                while ((readBuffer[nbBytesRead - 3] & 0x80) == 0x80)
                                {
                                    myProgramSystemStream.addStreamBoundEntry(readBuffer);
                                    nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, 3);
                                }
                                myStreamIn.Seek(-3, SeekOrigin.Current);
                                nbBytesRead -= 3;
                                myProgramSystemStream.setHeaderData(readBuffer.Take(nbBytesRead).ToArray());
                                sw.Stop();
                                printExecutionTime();
                                sw.Reset();
                                break;
 
//                            case "00-00-01-BC":
//                                break;
 
                            case "00-00-01-BE":
                            case "00-00-01-BF":
                                sw.Start();
                                nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, 2);
                                myPESHeader = new MpegPS_PacketizedElementaryStreamHeader(readBuffer);
                                myMpegPS_Stream.AddLast(myPESHeader);
                                myPESHeader.setHeaderData(readBuffer.Take(nbBytesRead).ToArray());
                                myStreamIn.Read(readBuffer, 0, (int)myPESHeader.totalLength);
                                myPESHeader.setPayloadData(readBuffer.Take((int)myPESHeader.totalLength).ToArray());
                                sw.Stop();
                                printExecutionTime();
                                sw.Reset();
                                break;
 
                            case "00-00-01-BD":
                            case "00-00-01-C0":
                            case "00-00-01-C1":
                            case "00-00-01-C2":
                            case "00-00-01-C3":
                            case "00-00-01-C4":
                            case "00-00-01-C5":
                            case "00-00-01-C6":
                            case "00-00-01-C7":
                            case "00-00-01-C8":
                            case "00-00-01-C9":
                            case "00-00-01-CA":
                            case "00-00-01-CB":
                            case "00-00-01-CC":
                            case "00-00-01-CD":
                            case "00-00-01-CE":
                            case "00-00-01-CF":
                            case "00-00-01-D0":
                            case "00-00-01-D1":
                            case "00-00-01-D2":
                            case "00-00-01-D3":
                            case "00-00-01-D4":
                            case "00-00-01-D5":
                            case "00-00-01-D6":
                            case "00-00-01-D7":
                            case "00-00-01-D8":
                            case "00-00-01-D9":
                            case "00-00-01-DA":
                            case "00-00-01-DB":
                            case "00-00-01-DC":
                            case "00-00-01-DD":
                            case "00-00-01-DE":
                            case "00-00-01-DF":
                            case "00-00-01-E0":
                            case "00-00-01-E1":
                            case "00-00-01-E2":
                            case "00-00-01-E3":
                            case "00-00-01-E4":
                            case "00-00-01-E5":
                            case "00-00-01-E6":
                            case "00-00-01-E7":
                            case "00-00-01-E8":
                            case "00-00-01-E9":
                            case "00-00-01-EA":
                            case "00-00-01-EB":
                            case "00-00-01-EC":
                            case "00-00-01-ED":
                            case "00-00-01-EE":
                            case "00-00-01-EF":
                                sw.Start();
                                sw1.Start();
                                nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, 2);
                                sw1.Stop();
                                printExecutionTime1("Read Size");
                                sw1.Reset();
                                sw1.Start();
                                myPESHeader = new MpegPS_PacketizedElementaryStreamHeader(readBuffer);
                                sw1.Stop();
                                printExecutionTime1("Create PES");
                                sw1.Reset();
                                sw1.Start();
                                myMpegPS_Stream.AddLast(myPESHeader);
                                sw1.Stop();
                                printExecutionTime1("Add PES header packet into packet stream");
                                sw1.Reset();
                                sw1.Start();
                                nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, 3);
                                sw1.Stop();
                                printExecutionTime1("Read Mpeg Extension header");
                                sw1.Reset();
                                sw1.Start();
                                myPESHeader.addMpegPS_Extension(readBuffer.Skip(6).ToArray());
                                sw1.Stop();
                                printExecutionTime1("Add Mpeg extension");
                                sw1.Reset();
                                sw1.Start();
                                nbBytesRead += myStreamIn.Read(readBuffer, nbBytesRead, myPESHeader.MpegPS_extension.PES_header_data_length);
                                sw1.Stop();
                                printExecutionTime1("Read Mpeg extension data");
                                sw1.Reset();
                                sw1.Start();
                                myPESHeader.headerLength = (uint)nbBytesRead;
                                sw1.Stop();
                                printExecutionTime1("Set Mpeg extension header length");
                                sw1.Reset();
                                sw1.Start();
                                myPESHeader.setHeaderData(readBuffer.Take((int)myPESHeader.headerLength).ToArray());
                                sw1.Stop();
                                printExecutionTime1("Set Mpeg extension data");
                                sw1.Reset();
                                sw1.Start();
                                myPESHeader.payloadLength = myPESHeader.totalLength - myPESHeader.headerLength + 6;
                                sw1.Stop();
                                printExecutionTime1("Set Mpeg extension payload length");
                                sw1.Reset();
                                sw1.Start();
                                nbBytesRead = myStreamIn.Read(readBuffer, nbBytesRead, (int)myPESHeader.payloadLength);
                                sw1.Stop();
                                printExecutionTime1("Read Mpeg extension payload data");
                                sw1.Reset();
                                sw1.Start();
                                myPESHeader.setPayloadData(readBuffer.Skip((int)myPESHeader.headerLength).ToArray().Take((int)myPESHeader.payloadLength).ToArray());
                                sw1.Stop();
                                printExecutionTime1("Set Mpeg extension payload data");
                                sw1.Reset();
                                sw.Stop();
                                printExecutionTime();
                                sw.Reset();
                                break;
 
                            default:
                                sw.Start();
                                myStreamIn.Seek(0, SeekOrigin.End);
                                sw.Stop();
                                printExecutionTime();
                                sw.Reset();
                                break;
                        }
 
                    }

=> Ne faites pas attention à cet énorme switch et aux cas du case. C'est pas très beau, mais j'arrangerais celà par la suite :-D

Donc enfin, qques morceaux de la sortie d'écran:
Premier timing sur un packet de type PacketHeader (voir premier extrait de code)

Citation:

Main: Seconds :0 - Mili seconds :4,1428

Trois autres timing sur 3 pacquets de type divers dont le code n'est pas donnée ici.

Citation:

Main: Seconds :0 - Mili seconds :1,3407

Citation:

Main: Seconds :0 - Mili seconds :0,1671

Citation:

Main: Seconds :0 - Mili seconds :0,0018

Enfin, celui qui montre clairement que l'ajout de l'extension qui demande le plus de temps, donc là ou je fais le maximum de shifting, et operations logiques sur mes morceaux de buffer. Bon j'ai tendance à pas mal coder dans le code en imbriquant des appels genre sur mon tableau de buffer avec des Take().ToArray().Skip().ToArray(), ce qui ne doit pas non plus accélérer les choses.

Citation:

Read Size: Seconds :0 - Mili seconds :0
Create PES: Seconds :0 - Mili seconds :0,0007
Add PES header packet into packet stream: Seconds :0 - Mili seconds :0,0003
Read Mpeg Extension header: Seconds :0 - Mili seconds :0,0003
Add Mpeg extension: Seconds :0 - Mili seconds :5,246 <=== ICI je viens d'ajouter l'extension au paquet !
Read Mpeg extension data: Seconds :0 - Mili seconds :0,1235
Set Mpeg extension header length: Seconds :0 - Mili seconds :0
Set Mpeg extension data: Seconds :0 - Mili seconds :0,0692
Set Mpeg extension payload length: Seconds :0 - Mili seconds :0
Read Mpeg extension payload data: Seconds :0 - Mili seconds :0,0681
Set Mpeg extension payload data: Seconds :0 - Mili seconds :1,6556<=== ICI encore en ajoutant les données! Fianlement c'est p'tet vraiment les Take, ToArray, Skip etc.. imbriqués. !

Main: Seconds :0 - Mili seconds :7,4032

Allez, feu ;-P

A partir du moment où tu utilises une machine virtuelle pour executer ton code, tu auras des performances moins bonnes que quand tu attaques directement la machine...

Take c'est du Linq (to Objects), donc ça génère des expressions lambda, qui peuvent nuire en effet à la vitesse d'exécution (en fonction du volume, mais surtout dans le cas d'un volume faible).
Si tu fais la même chose avec un classique "for/foreach" tu devrais diviser par deux le temps d’exécution de ce bout de code.

Merci Er3van pour ce retour même si ta première phrase reste obscure. Que veux-tu dire en parlant de machine virtuelle ? Fais-tu allusion au fait que j’exécute le code en debug via visual studio ou sous entends-tu que les operations de type Skip() ou Take() mettent en jeu de telles mécanismes.

Bref, je vais retravailler le code afin de rester sur du code plus basique et d'éviter de tomber sur ce genre de travers ;-P Je vais aussi m'informer de ce que tu as appelé Linq et expressions lambda, j'ai encore beaucoup à apprendre :-D

J'avais oublié de préciser que dans sa première mouture, ce code ne faisait que parser le fichier source en identifiant les paquets de données, je n'y remplissait pas toutes ces classes. De fait l’exécution était immédiate, le fichier source de test fait 25Mo et est stocké sur un RAMDisk, accès quasi instantané donc.

Le fait est que depuis que je crée les classes et que j'en remplis tous les champs via des méthodes génériques j'ai explosé en temps. De quelques dixièmes de secondes pour le parsing global je suis passé à plusieurs minutes d'éxécution. En C le fait de remplir les structures par simple memcpy aurait aussi été quasi immédiat. Je ne m'attendais donc pas à une telle dégradation en passant par ces méthodes de haut niveau.
Je vais aussi passer par du threading, histoire de faire travailler l'ensemble de la machine et pas seulement un seul des coeurs à quelques 15%.

Sinon, sur l'ensemble, y'a des grosses fautes, je veux dire par rapport ax constructeurs des classes annexes et à leur remplissage ou cela vous semble-t-il la bonne méthode ?

Pour les performances je vais ajouter un point trivial mais comme ce n'est pas préciser :
Il faut tester son code en Release et non en Debug. Ainsi le compilo et le JIT peuvent faire toutes les optimisations possibles.
De plus il est possible d'utiliser NGEN pour précompiler le programme et ainsi gagner un peut de temps lors de la première exécution.