[C++] Bitprogramming probleem

[pinkwin|IA]

Tijdens het ontwikkelen van een nieuw programma loop ik tegen het volgende probleem aan. Alle variabelen uit een classe moeten binair opgeslagen worden in 3 rijen. In de onderstaande code heb ik het desbetreffende stuk code gekopieerd. In dit stuk heb ik de variabelen vervangen door binaire data welke de maximum waarde van de variabele representeert.

C++:

union {
  WORD w[3];
  struct {
    unsigned nLTO  : 5;
    unsigned nSense: 1;
    unsigned nMin  : 6;
    unsigned nHour : 5;
    unsigned nMJD : 17;
    unsigned nFree : 3;
    unsigned nDum : 11;
  };
} w3Blocks;
CGroup *g = (CGroup*)aGroups[0];
w3Blocks.w[0] = w3Blocks.w[1] = w3Blocks.w[2] = 0;
w3Blocks.nLTO = 0x1F;
w3Blocks.nSense = 0x1;
w3Blocks.nMin = 0x3F;
w3Blocks.nHour = 0x1F;
w3Blocks.nMJD = 0x1FFFF;
w3Blocks.nFree = 0x7;
w3Blocks.nDum = 0x7FF;

Als ik na deze code de w3Blocks.w[0], w3Blocks.w[1] en w3Blocks.w[2] bekijk, hebben deze respectievelijk de waarden:
1111.1111.1111.1111
0000.0000.0000.0001
1111.1111.1111.1111

Dit begrijp ik niet. ik verwacht de waarden:
1111.1111.1111.1111
1111.1111.1111.1111
0000.0000.0001.1111

Ik heb iedere variabele op zich geprobeerd en daarmee heb ik ontdekt dat de nLTO, nSense, nMin en nHour wel goed werken (bovense rij en de laatste bit van de tweede), maar de nMJD sluit niet direct aan, maar laat eerst 15 bits leeg en begint daarna de bits in de word array te zetten. Het probleem is dat deze direct na de nHour moet verder gaan zonder lege bits.

Ik hoop dat het probleem duidelijk genoeg is.. Anders wil ik het best nog eens proberen uit te leggen.

Kan iemand mij hiermee helpen?

[Soultaker]

Misschien een alignment probleem? Wat is de grootte van je w3Blocks union?

[.oisyn]

Dit begrijp ik niet. ik verwacht de waarden:
1111.1111.1111.1111
1111.1111.1111.1111
0000.0000.0001.1111

moet die laatste rij ook niet 1111.1111.1111.1111 zijn? (je zet iig alle bits aan met je code)

Maar is sizeof (w3Blocks) wel gelijk aan 6? Controleer dat even

(anonymous structs zijn overigens niet ISO C++)

[ Voor 11% gewijzigd door .oisyn op 30-09-2003 15:27 ]

[pinkwin|IA]

.oisyn schreef op 30 september 2003 @ 15:26:
[...]


moet die laatste rij ook niet 1111.1111.1111.1111 zijn? (je zet iig alle bits aan met je code)

Maar is sizeof (w3Blocks) wel gelijk aan 6? Controleer dat even

(anonymous structs zijn overigens niet ISO C++)

laatste moet inderdaad ook allemaal 1 zijn. (bij mijn vorige test stond de laatste waarde op 0, waardoor wel die 0000.0000.0001.1111 eruit zou moeten komen.

sizeof (w3Blocks) geeft als resultaat 8.

[.oisyn]

En moet dat niet 6 zijn, volgens jou? 3 words van 2 bytes is immers 6 bytes

antwoord: packing
zie ook [rml][ C] Probleem met bitjes[/rml]

[curry684]

Dit zit 'm in alignment ja, en in endianness. De hele union als geheel wordt gepad tot 8 bytes.

Dit kun je afhankelijk van je compiler afvangen met een pragma

[pinkwin|IA]

Het lukt niet direct, maar ik denk dat ik hier genoeg informatie aan heb en verder moet komen. Alvast bedankt!

[MSalters]

Voor alle duideklijkheid: dit soort code is altijd non-portable, er is een behoorlijk arbitraire keus hoe je bitfields in een word stopt, los van eventuele endianness. Dat wil dus zeggen dat twee x86 compilers het anders kunnen doen. De reden hiervoor is dat de adressen van members i.h.a op moeten lopen, maar bitfields hebben geen adres en daar geldt die regel niet voor.

[pinkwin|IA]

ik heb ondertussen het andere topic ([C] Probleem met bitjes) helemaal doorgelezen en ben opzoek gegaan naar informatie over packing en #pragma pack(), maar waarschijnlijk zie ik wat over het hoofd. De union heeft namelijk nog steeds een grootte van 8 bytes..

Deze code heb ik nu:

C++:

#include "stdafx.h"
...
# pragma pack( push, packing )
# pragma pack( 1 )

...
void CRds04a::Encode(){
union { 
  WORD w[3]; 
  struct { 
    unsigned nLTO  : 5; 
    unsigned nSense: 1; 
    unsigned nMin  : 6; 
    unsigned nHour : 5; 
    unsigned nMJD : 17; 
    unsigned nFree : 3; 
    unsigned nDum : 11; 
  }; 
} w3Blocks; 
w3Blocks.w[0] = w3Blocks.w[1] = w3Blocks.w[2] = 0; 
w3Blocks.nLTO = 0x1F; 
w3Blocks.nSense = 0x1; 
w3Blocks.nMin = 0x3F; 
w3Blocks.nHour = 0x1F; 
w3Blocks.nMJD = 0x1FFFF; 
w3Blocks.nFree = 0x7; 
w3Blocks.nDum = 0x7FF;

nog steeds gaat het fout bij de nMJD. Wat mij wel opgevallen is, is dat als ik deze ipv 17, 15 bits groot maak, het verder wel goed gaat. Alleen is dat in het programma niet mogelijk omdat 17 bits vereist is..

Doe ik iets fout met packing en alignement, of zit de fout mogelijk toch ergens anders?

[.oisyn]

Waarschijnlijk omdat nMJD over een doubleword boundary heen gaat. Met 15 bits stop je precies voor de grens, maar vanaf 16 ga je er overheen
Welke compiler gebruik je eigenlijk?

[pinkwin|IA]

die van ms visual c++ 6

[Reptile209]

.oisyn schreef op 01 October 2003 @ 12:07:
Waarschijnlijk omdat nMJD over een doubleword boundary heen gaat. Met 15 bits stop je precies voor de grens, maar vanaf 16 ga je er overheen
Welke compiler gebruik je eigenlijk?

Ga je dan met hour niet net zo hard de mist in? Als ik 'm uitteken, gaat Hour ook sowieso over een grens heen:

code:

|       w[0]      |       w[1]      |       w[2]      |       w[-]      |
|76543210|76543210|76543210|76543210|76543210|76543210|76543210|76543210|

 |  nDum    || ||     nMJD        ||nHr ||nMin| ||LTO|
            nFree                             NSense

 |LTO|||nMin ||nHr ||     nMJD        || || nDum     |
   nSense                              nFree

Even twee keer gedaan, afhankelijk van de volgorde waarop de bitfields ook al weer worden toegewezen... Maar in alle gevallen lijken zowel nHour als nMJD over word-grenzen heen te gaan. Misschien dat je door wat te rommelen met dummy-align velden de boel alsnog recht kunt trekken?

[pinkwin|IA]

hour gaat ook over de grens heen. dat klopt, maar om een of andere reden doet dat het wel goed. als ik alleen de hour een waarde geef, krijg ik eruit:
1111.0000.0000.0000
0000.0000.0000.0001
0000.0000.0000.0000

maar wat bedoel je met dummy-align velden?

[.oisyn]

Reptile209 schreef op 01 oktober 2003 @ 12:24:
[...]

Ga je dan met hour niet net zo hard de mist in? Als ik 'm uitteken, gaat Hour ook sowieso over een grens heen:

een doubleword is 32 bits, niet 16

[.oisyn]

Ik heb het hier even getest met MSVC++ 7.1, en ik krijg sizeof (w3Blocks) met geen mogelijkheid op 6.

Ik denk dat je het dan maar bij die 3 words moet houden, en bijvoorbeeld functies moet maken zodat je de aparte bits kunt zetten

[pinkwin|IA]

ik heb er alsnog 15 bits van gemaakt en dan de twee overgebleven bits met de hand gezet (checken op grootte van nMJD en dat verminderen met 65536 voor de eerste bit en met 32768 voor de tweede bit. Dit lijkt goed te werken.
In ieder geval bedankt voor de moeite!!

[MSalters]

Misschien is het toch makkelijker om dit soort bitops met de hand te schrijven. Dan krijg je dus

code:

void w3Blocks::setLTO( int i )
{
  // bits 15-11
  w[0] &= (0x07FF);
  w[0] |= i * 0x800;
} 
int w3Blocks::getLTO( ) const
{
  // bits 15-11
  return w[0]  / 0x0800;
}

De compiler zou toch dit soort code moeten maken, en zo heb je volledige controle. Als je over een word grens heenwil, dan gebruik je simpelweg w[i] en w[i+1]. Overigens is het netter om in zo'n geval unsigned char[]s te gebruiken, die zijn altijd packed.