3

I can think of three ways to do this off the top of my head. I'll outline them real quick.

char mask = (1<<top)
mask = mask-1
mask = mask>>bot
mask = mask<<bot
3 shifts, 1 addition

char topMask = (1<<top)
topMask = topMask -1
char botMask = (1<<bot)
botMask = botMask - 1
char mask = topMask - botMask
2 shifts, 3 additions

char mask = (1<<(top-bot))
mask = mask - 1
mask = mask << bot
2 shifts, 2 additions

It seems like the first one would be a little faster? Is one considered best for style reasons? Is there a really good way I'm missing, or am I doing something stupid? Thanks!

I'd especially be interested if anyone could point me to a place this is done in the linux kernel.

EDIT: someone posted something like this as another way and deleted it? Pretty similar to the second one. But XOR instead of subtract. 

char mask = ((1<<top)-1)^((1<<bot)-1)
rekh127
  • 139
  • 1
  • 10
  • This hardly has a "best practice" answer. Pick whichever version seems clearest, comment what it does, then move on. – Timothy Shields Jan 30 '14 at 19:40
  • duplicates: [Masking bits within a range given in parameter in C](https://stackoverflow.com/q/28035794/995714), [uint64_t setting a range of bits to 1](https://stackoverflow.com/q/48436659/995714), [Fastest way to produce a mask with n ones starting at position i](https://stackoverflow.com/q/39321580/995714), [Obtain a specific subset of bits of an int in Java](https://stackoverflow.com/q/16001819/995714), [set the m-bit to n-bit](https://stackoverflow.com/q/15917454/995714) – phuclv Jun 09 '19 at 02:11

1 Answers1

1

You could try a lookup table approach:

static const char LUT[][] = { // index like this LUT[bot][top]
//top:    0     1     2     3     4     5     6     7     8
       0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, // bot: 0
       0x00, 0x00, 0x02, 0x06, 0x0E, 0x1E, 0x3E, 0x7E, 0xFE, // bot: 1
       0x00, 0x00, 0x00, 0x04, 0x0C, 0x1C, 0x3C, 0x7C, 0xFC, // bot: 2
       0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x78, 0xF8, // bot: 3
       0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x30, 0x70, 0xF0, // bot: 4
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x60, 0xE0, // bot: 5
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC0, // bot: 6
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, // bot: 7
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // bot: 8
};

char mask = LUT[bot][top];

Also: If for whatever reason you go with bit manipulation this solution requires less ops. In addition a superscalar processor should evaluate the left and right side of the xor in parallel.

char mask = (0xFF << top) ^ (0xFF << bot);
Apriori
  • 2,308
  • 15
  • 16