Question

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

Answer 1

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.