Thread: Bit Sized Variable

***Background Information

A byte is 8 bits.

Bool is 1 byte.
Char is 1 byte.
Int is 4 bytes (therefore: 32 bits)

***What I want..

I've been programming for quite a while.
As many know, less bytes = better performance.
Many replace 'int' with 'char' when doing small tasks. Like, how many hours are in a day. You don't need the range of 0 - ~32000 (int), 0-255 (char) is sufficient.

However, I want to have true BOOLEAN, instead of 0-255 possible bool.

***How would I do this?

In C, or any language (if there is one)..
I'd like to create a bit-sized variable.

Example (in text):
declare new type of 3 bits named 3bit
Then this new 3 bit variable would have
000 - 111
In base 10: 0 - 7

Then when I declare the 3 bit variable, instead of the 8 bit variable, I theoretically save 5 bits during creation, but have less bits to actually manipulate.

If there is a way, it would then be possible to create a 1 bit variable, which would be (bool), so when you do a bit-test (or a simple if statement), it will only have 1 bit to check and there would be no waste to the other 7. But I'm not looking for a response to save the speed for bool solely. I'd like the power to create a 3, 4.. 17, 11, any size bit variable. Instead of crunching 8 bits together, which is just a structure of chars combined.

Thank you, I'd love to hear this is possible. Cannot find a narrow result in searches.

Crosility

>> As many know, less bytes = better performance.
Is it?
Boolean Expressions and Variables
The C Book — Bitfields

As many know, less bytes = better performance.

That's not necessarily true.

In C, or any language (if there is one)..
I'd like to create a bit-sized variable.

You can't in C. You can use a bitfield:

Code:

struct b
{
  unsigned char b:1;
};

The “b” member is a bitfield of size 1, but your struct will still be at least a byte long (no type in C can be smaller than a byte). The advantage to bitfields is that you can pack many elements into a byte, not that you can create a type smaller than a byte.

If you're worried about performance, use a profiler like gprof or callgrind. Don't make assumptions about what will be fast, make tests.

Originally Posted by iMalc

If you're refering to a variable used as a loop counter, then those "many"
... //scroll up to read//
BTW, the range of an int is typically -2147483648 to 2147483647.

Haha, guess my compiler is slightly outdated, and my reading is not the same as the posted. I have 2 byte ints. (Reran a quick loop to check.)
Haha. Anyhow..

I understand now that the processor can't access 1 bit data types. But I still don't understand how it'd hurt performance, because it'd be the same number of variables accessed. If you made 50 variables of char/int/long int in one program. Why wouldn't a program where you allocate 50 variables of a self-bit width variable be any different? Except to save space and increase speed?

Originally Posted by Crosility

Can you explain why this isn't true?
Wouldn't the CPU only be checking / storing 1 bit of information. Instead of going through a check of 8 bits of information, or storing 7 unnecessary bits?
I would believe that if you stored a smaller variable for the CPU to process it would be easier to access, and also easier to change.

Altho' it seems like using less memory would speedup things, yet it takes more micro processing for bitfileds due to reasons like specialized instructions needed to unpack them.

Originally Posted by Crosility

I actually have never looked into bit fields till Salem posted the link. From reading the wikipedia version a few times, it doesn't look as if your actually getting 1 bit, but an entire char (8 bits) of information.

The reason I assume the speed of using bit variables, because of the obvious - it holds more. I am still not sure how I am suppose to test if it is quicker or not, because I can't do the test of passing a single bit of information, compared to a single byte.

Yep! you can.

Originally Posted by Crosility

Now, I have possibly a silly question.

Code:

struct b {
unsigned char a : 1;
unsigned char b : 1;
unsigned char c : 1;
unsigned char d : 1;
... // etc.
};

Does this create a 1 byte variable, in which I can edit b by doing
b.a = 1;
?

Or would this create a 4 byte structure because I have declared 4 unsigned chars?

It'd create a struct variable that is 1 byte long because bitfields are packed together for compactness.

Originally Posted by Crosility

I did some reading, some clarity would be nice.


If I create this, and say add
unsigned char remainder : 4;
to the end of the structure

I would then have a full byte? Then each variable in the structure is accessible.. therefore saving memory. So, if I had 4 true false statements, and 1 4bit number I needed to store.. I could?

Savings in memory doesn't equate to better performance because of the specialized processing needed for bitfields.

So, from what each one of you is saying is:

When computers were made, and then the processes that access information, someone made it so only an entire byte is read/writeable. Unless you used bit operations, but because the information is stored in a byte, it would need to deconstruct the byte, change the information, then put the byte back together.

That is sad. I wish they'd made the processes access 2 bits, or even 1 bit, not 8!

Would I be taking a performance hit if I had 8 bools stored as a single byte?
Because of the (de / re)construction of the byte (due to bit shifting), using a larger amount of space would actually be faster?

I wish there was a way around this. Think of the possibilities, if the processes(processor) could read/write single bits, and spit them back out. You could actually manipulate data much faster.

Now I understand bitfield, and may do a test to see the time in seconds it takes to edit the information 500 times, for both ways (bool, and if I did a 1 bit bool inside of a struct)

Graphical applications you'd know are a heck of a lot more resource intensive, and the fact that they use bitfields may have something to do with it

Well, say I have 8 images for different rotations. Having a 3 bit variable is perfect.
A case statement to see what the 3 bit variable is, would allow it to display the image based on the number 0-7 (of a 3 bit variable).

You're not going to be passing a bit at a time over the network, so there's no point in trying to reduce all operations like that. You'll be passing at least a byte (and probably more).

So you need a 3-bit variable? Even if you had one, you'd have to pass it as a byte, so just use (at least) a byte.

You need 8 boolean values? Pack them all into a char and pass that, if you're really worried about network usage. Something like:

Code:

#define FLAG1 0x01
#define FLAG2 0x02
#define FLAG3 0x04
/* ... */
unsigned char flags = 0;
if(set_flag_1) flags |= FLAG1;
/* ... */
if(flags & FLAG1) /* it is set */

But really, it's a better idea to test to find where a bottleneck is rather than assume you know.