Does bit operation always work more efficiently than math operation?

[david ullua]

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);

[Thad Smith]

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.

--
Thad

[Neil]

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.

[jjf]

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, ...

[david ullua]

Thad Smith 写�：

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.

--
Thad

_other_ _codes_ does not modify the value of column.

[Christian Bau]

In article <11**********************@t39g2000cwt.googlegroups .com>,
"david ullua" <da*********@gmail.com> 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.

[david ullua]

Christian Bau 写�：

In article <11**********************@t39g2000cwt.googlegroups .com>,
"david ullua" <da*********@gmail.com> 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.

[Robin Haigh]

"david ullua" <da*********@gmail.com> wrote in message
news:11**********************@t39g2000cwt.googlegr oups.com...

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

[pete]

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.
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);

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

--
pete

[CBFalconer]

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
"Reply" at the bottom of the article headers." - Keith Thompson
More details at: <http://cfaj.freeshell.org/google/>
Also see <http://www.safalra.com/special/googlegroupsreply/>

[pete]

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

[Micah Cowan]

pete <pf*****@mindspring.com> 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?

[tedu]

Micah Cowan wrote:

pete <pf*****@mindspring.com> 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.

[pete]

tedu wrote:

Micah Cowan wrote:

pete <pf*****@mindspring.com> 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