# Does bit operation always work more efficiently than math operation?

Discussion in 'C Programming' started by david ullua, Feb 28, 2006.

1. ### david ulluaGuest

Hi,
In Expand.c of BSD system, I met the following codes, the expression
(column & 07) if used to compare variable column and 7, if column<=7,
it returns true, else false. It use (column & 07) rather than
(column<=7), thus it brings me a question, does bit operation always
work more efficiently than math operation? How about plus without
carry? and minus without borrow?
I have searched through google web and newsgroups, haven't found any
relative topics

int column = 0;
//other codes .....
do {
putchar(' ');
column++;
} while (column & 07);

david ullua, Feb 28, 2006

david ullua wrote:
> Hi,
> In Expand.c of BSD system, I met the following codes, the expression
> (column & 07) if used to compare variable column and 7, if column<=7,
> it returns true, else false. It use (column & 07) rather than
> (column<=7), thus it brings me a question, does bit operation always
> work more efficiently than math operation? How about plus without
> carry? and minus without borrow?
>
> int column = 0;
> //other codes .....
> do {
> putchar(' ');
> column++;
> } while (column & 07);

The bitwise and operator allows the do loop to perform a generalized tab
operation, assuming stops every 8 characters. It also works if column >
7, while a simple compare wouldn't. Perhaps in this case, column never
exceeds 7 (depending on what "other code"" includes), in which case a
compare would be functionally equivalent. C doesn't dictate the
relative efficiency, but on most processors both forms would be very
simple and efficient.

--

3. ### NeilGuest

david ullua wrote:
> Hi,
> In Expand.c of BSD system, I met the following codes, the expression
> (column & 07) if used to compare variable column and 7, if column<=7,
> it returns true, else false. It use (column & 07) rather than
> (column<=7), thus it brings me a question, does bit operation always
> work more efficiently than math operation? How about plus without
> carry? and minus without borrow?
> I have searched through google web and newsgroups, haven't found any
> relative topics
>
> int column = 0;
> //other codes .....
> do {
> putchar(' ');
> column++;
> } while (column & 07);
>

It would depend on the CPU. The Compiler converts the C to opcodes.
CPUs have a different assortment of opcodes. So what is "better" on one
machine is worse on another. Or, exactly the same.

It is the Compilers optimizers job to minimize the effect.

Neil, Feb 28, 2006
4. ### Guest

david ullua wrote:
> In Expand.c of BSD system, I met the following codes, the expression
> (column & 07) if used to compare variable column and 7, if column<=7,
> it returns true, else false. It use (column & 07) rather than
> (column<=7), thus it brings me a question, does bit operation always
> work more efficiently than math operation? How about plus without
> carry? and minus without borrow?
> I have searched through google web and newsgroups, haven't found any
> relative topics
>
> int column = 0;
> //other codes .....
> do {
> putchar(' ');
> column++;
> } while (column & 07);

Bit operations are not necessarily always more efficient than
arithmetic. More importantly, (column & 07) is not the same
as (column <= 7). Consider what happens when column is 9, 16,
23, 24, ...

, Feb 28, 2006
5. ### david ulluaGuest

> david ullua wrote:
> > Hi,
> > In Expand.c of BSD system, I met the following codes, the expression
> > (column & 07) if used to compare variable column and 7, if column<=7,
> > it returns true, else false. It use (column & 07) rather than
> > (column<=7), thus it brings me a question, does bit operation always
> > work more efficiently than math operation? How about plus without
> > carry? and minus without borrow?
> >
> > int column = 0;
> > //other codes .....
> > do {
> > putchar(' ');
> > column++;
> > } while (column & 07);

>
> The bitwise and operator allows the do loop to perform a generalized tab
> operation, assuming stops every 8 characters. It also works if column >
> 7, while a simple compare wouldn't. Perhaps in this case, column never
> exceeds 7 (depending on what "other code"" includes), in which case a
> compare would be functionally equivalent. C doesn't dictate the
> relative efficiency, but on most processors both forms would be very
> simple and efficient.
>
> --

_other_ _codes_ does not modify the value of column.

david ullua, Feb 28, 2006
6. ### Christian BauGuest

In article <>,
"david ullua" <> wrote:

> Hi,
> In Expand.c of BSD system, I met the following codes, the expression
> (column & 07) if used to compare variable column and 7, if column<=7,
> it returns true, else false. It use (column & 07) rather than
> (column<=7), thus it brings me a question, does bit operation always
> work more efficiently than math operation? How about plus without
> carry? and minus without borrow?

The tests are different.

if (column & 0x07) ...

will execute the code following the if-statement when column is 1 to 7,
9 to 15, 17 to 23, 25 to 31, and so on.

The basic rule is: Write code in a way that is most readable and most
clearly expresses what you want to do, and not worry about speed.

If it turns out that speed is a problem (your software is not acceptable
because it is too slow), you start _measuring_ the speed. Any attempt to
improve speed without measuring is futile.

If you want your code to run fast in general, write readable code and
write code in the same way as everyone else. That improves the chance
that the code falls into a pattern that the compiler recognises and can
produce better code for than normally.

Christian Bau, Feb 28, 2006
7. ### david ulluaGuest

Christian Bau å†™é“ï¼š

> In article <>,
> "david ullua" <> wrote:
>
> > Hi,
> > In Expand.c of BSD system, I met the following codes, the expression
> > (column & 07) if used to compare variable column and 7, if column<=7,
> > it returns true, else false. It use (column & 07) rather than
> > (column<=7), thus it brings me a question, does bit operation always
> > work more efficiently than math operation? How about plus without
> > carry? and minus without borrow?

>
> The tests are different.
>
> if (column & 0x07) ...
>
> will execute the code following the if-statement when column is 1 to 7,
> 9 to 15, 17 to 23, 25 to 31, and so on.
>
> The basic rule is: Write code in a way that is most readable and most
> clearly expresses what you want to do, and not worry about speed.
>
> If it turns out that speed is a problem (your software is not acceptable
> because it is too slow), you start _measuring_ the speed. Any attempt to
> improve speed without measuring is futile.
>
> If you want your code to run fast in general, write readable code and
> write code in the same way as everyone else. That improves the chance
> that the code falls into a pattern that the compiler recognises and can
> produce better code for than normally.

Good idea.

david ullua, Feb 28, 2006
8. ### Robin HaighGuest

"david ullua" <> wrote in message
news:...
> Hi,
> In Expand.c of BSD system, I met the following codes, the expression
> (column & 07) if used to compare variable column and 7, if column<=7,
> it returns true, else false. It use (column & 07) rather than
> (column<=7), thus it brings me a question, does bit operation always
> work more efficiently than math operation? How about plus without
> carry? and minus without borrow?
> I have searched through google web and newsgroups, haven't found any
> relative topics
>
> int column = 0;
> //other codes .....
> do {
> putchar(' ');
> column++;
> } while (column & 07);

With unsigned numbers, if you want to divide by a power of two, you can
shift the appropriate number of bits to the right:

(x >> 3) is the same as (x / 8)

(3 because 8 == 2^3)

and if you want the remainder, you look at the bits that would be lost on
shifting, so

(x & 7) is the same as (x % 8)

(7 because 7 == 8-1)

So testing (x & 7) tests for a non-zero remainder, i.e. non-divisibility by
8.

These are common enough idioms, and were more common when compilers were
more primitive. This is an old program. The programmer probably wasn't
worrying about speed, he was just doing what he always did from force of
habit.

It's unlikely the bit operations will ever be slower, but they may not be
faster, because compilers can recognise * / % with powers of 2 and generate
the same code.

--
RSH

Robin Haigh, Feb 28, 2006
9. ### peteGuest

david ullua wrote:
>
> Hi,
> In Expand.c of BSD system, I met the following codes, the expression
> (column & 07) if used to compare variable column and 7, if column<=7,
> it returns true, else false. It use (column & 07) rather than
> (column<=7), thus it brings me a question, does bit operation always
> work more efficiently than math operation?

No.

> carry? and minus without borrow?
> I have searched through google web and newsgroups, haven't found any
> relative topics
>
> int column = 0;
> //other codes .....
> do {
> putchar(' ');
> column++;
> } while (column & 07);

while ((column | ~7U) == 0);

--
pete

pete, Feb 28, 2006
10. ### CBFalconerGuest

pete wrote:
> david ullua wrote:
>

.... snip ...
>>
>> int column = 0;
>> //other codes .....
>> do {
>> putchar(' ');
>> column++;
>> } while (column & 07);

>
> while ((column | ~7U) == 0);

Looks like another way of spelling "once". You may as well write:

} while (0);

--
"If you want to post a followup via groups.google.com, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the

CBFalconer, Feb 28, 2006
11. ### peteGuest

CBFalconer wrote:
>
> pete wrote:
> > david ullua wrote:
> >

> ... snip ...
> >>
> >> int column = 0;
> >> //other codes .....
> >> do {
> >> putchar(' ');
> >> column++;
> >> } while (column & 07);

> >
> > while ((column | ~7U) == 0);

>
> Looks like another way of spelling "once".

while ((column & ~7U) == 0);

--
pete

pete, Mar 1, 2006
12. ### Micah CowanGuest

pete <> writes:

> CBFalconer wrote:
> >
> > pete wrote:
> > > david ullua wrote:
> > >

> > ... snip ...
> > >>
> > >> int column = 0;
> > >> //other codes .....
> > >> do {
> > >> putchar(' ');
> > >> column++;
> > >> } while (column & 07);
> > >
> > > while ((column | ~7U) == 0);

> >
> > Looks like another way of spelling "once".

>
> while ((column & ~7U) == 0);

Why is this better than:

while (column & 07);

which is what OP wrote in the first place?

Micah Cowan, Mar 1, 2006
13. ### teduGuest

Micah Cowan wrote:
> pete <> writes:
> > while ((column & ~7U) == 0);

>
> Why is this better than:
>
> while (column & 07);
>
> which is what OP wrote in the first place?

it's a replacement for (column <= 7); the original is not.

tedu, Mar 1, 2006
14. ### peteGuest

tedu wrote:
>
> Micah Cowan wrote:
> > pete <> writes:
> > > while ((column & ~7U) == 0);

> >
> > Why is this better than:
> >
> > while (column & 07);
> >
> > which is what OP wrote in the first place?

>
> it's a replacement for (column <= 7); the original is not.

If column was unsigned, then it would be a valid replacement.
It was the best I could do otherwise.

--
pete

pete, Mar 1, 2006