CODEWITHSUNDEEP
carchitecture
Thomas O
Thomas O

Reputation: 6220

On embedded platforms, is it more efficient to use unsigned int instead of (implicity signed) int?

I've got into this habit of always using unsigned integers where possible in my code, because the processor can do divides by powers of two on unsigned types, which it can't with signed types. Speed is critical for this project. The processor operates at up to 40 MIPS.

My processor has an 18 cycle divide, but it takes longer than the single cycle barrel shifter. So is it worth using unsigned integers here to speed things up or do they bring other disadvantages? I'm using a dsPIC33FJ128GP802 - a member of the dsPIC33F series by Microchip. It has single cycle multiply for both signed and unsigned ints. It also has sign and zero extend instructions.

For example, it produces this code when mixing signed and unsigned integers.

026E4  97E80F     mov.b [w15-24],w0
026E6  FB0000     se w0,w0
026E8  97E11F     mov.b [w15-31],w2
026EA  FB8102     ze w2,w2
026EC  B98002     mul.ss w0,w2,w0
026EE  400600     add.w w0,w0,w12
026F0  FB8003     ze w3,w0
026F2  100770     subr.w w0,#16,w14

I'm using C (GCC for dsPIC.)

Upvotes: 2

Views: 641

Answers (4)

Ioan
Ioan

Reputation: 2412

I'm going to guess the unsigned divide of powers of two are faster because it can simply do a right shift as needed without needing to worry about sign extension.

As for disadvantages: detecting arithmetic overflows, overflowing a signed type because you didn't realize it while using unsigned, etc. Nothing blocking, just different things to watch out for.

Upvotes: 0

Paul Nathan
Paul Nathan

Reputation: 40309

Generate assembly both ways and count cycles.

Upvotes: 0

nategoose
nategoose

Reputation: 12382

I don't know much about the instruction set available on your processor but a quick look makes me think that it has instructions that may be used for both arithmetic and logical shifts, which should mean that shifting a signed value costs about the same as shifting an unsigned value, and dividing by powers of 2 for each using the shifts should also cost the same. (my knowledge about this is from a quick glance at some intrinsic functions for a C compiler that targets your processor family).

That being said, if you are working with values which are to be interpreted as unsigned then you might as well declare them as unsigned. For the last few years I've been using the types from stdint.h more and more, and usually I end up using the unsigned versions because my values are either inherently unsigned or I'm just using them as bit arrays.

Upvotes: 0

AlastairG
AlastairG

Reputation: 4314

I think we all need to know a lot more about the peculiarities of your processor to answer this question. Why can't it do divides by powers of two on signed integers? As far as I remember the operation is the same for both. I.e.

10/2 = 00001010 goes to 00000101

-10/2 = 11110110 goes to 11111011

Maybe you should write some simple code doing an unsigned divide and a signed divide and compare the compiled output.

Also benchmarking is a good idea. It doesn't need to be precise. Just have a an array of a few thousand numbers, start a timer and start dividing them a few million times and time how long it takes. Maybe do a few billion times if your processor is fast. E.g.

int s_numbers[] = { etc. etc. };
int s_array_size = sizeof(s_numbers);
unsigned int u_numbers[] = { etc. etc.};
unsigned int u_array_size = sizeof(u_numbers);
int i;
int s_result;
unsigned int u_result;

/* Start timer. */

for(i = 0; i < 100000000; i++)
{
  i_result = s_numbers[i % s_array_size] / s_numbers[(i + 1) % s_array_size];
}

/* Stop timer and print difference. */

/* Repeat for unsigned integers. */

Written in a hurry to show the principle, please forgive any errors.

It won't give precise benchmarking but should give a general idea of which is faster.

Upvotes: 2

Related Questions