C atmega2560 Division of large integers

Question

So I'm wondering about the costs of division on a atmega2560 as well as in general: Let's say I got something like this

    unsigned long long a=some-large-value;
    unsigned long long b=some-other-large-value;
    unsigned long result=(a-b)/A_CONSTANT
    //A_CONSTANT i.e. 16

How long does it actually take? Are we speaking about hundrets or thousands of cycles? And does it make a difference if I change the division to a multiplication i.e. like so

    unsigned long result=(a-b)*1/A_CONSTANT

I want to use that in a time-critical application for calculating a time span which is used for determining when to execute another part of the program. Assuming the division takes too much time, what other options do I have?

You should proably not use `-` in C-like pseudo code, since it's an actual operator. — unwind, May 16 '14 at 12:38
`A_CONSTANT` value of `16` is a bad example because it will replaced by a `>> 4`, basically a `1` cycle operation. — ouah, May 16 '14 at 12:44
I would recommend compiling it, and reading the generated code. — unwind, May 16 '14 at 12:46
@ouah You're right, but at the same time it won't be just one cycle. Looked up the thing and it's obviously an 8 bit processor. — Mario, May 16 '14 at 12:50
@Mario in the 8-bit AVR architecture a shift is 1 cycle. Add a few more cycles for a 32-bit (`unsigned long`) value. — ouah, May 16 '14 at 13:00
It's a 8-bit MCU so it's gonna perform incredibly bad at 32 bit integer division. If there is no native 32 bit division instruction available, the compiler will toss in library calls in your code, which leads to special functions for this. Disassemble the C program and have a look: it won't be pretty. So if your program relies heavily on 32 bit arithmetic, you picked the wrong MCU for the project. This is one of many reasons why all professionals have stopped using 8 bit MCUs for new projects. — Lundin, May 16 '14 at 13:04

score 2 · Accepted Answer · answered May 16 '14 at 12:50

This really depends on your A_CONSTANT and how good the compiler is IMO.

I've looked up the chip and it's obviously an 8 bit processor with 8 or 16 MHz.

As such, I'd consider those unsigned long long integer to be the biggest hurdle to take, if your division is trivial.

For this it would have to be a power of two (like 2, 4, 8, 16, etc.). What would happen then, would be an optimization, replacing the whole division with a simple right shift, which would be completed in far less cycles.

Switching to a multiplication won't net you anything good. You'll at least suffer precision issues and your current code would result in the result 0 all the time, unless A_CONSTANT is 1 (since you're obviously doing an integer division, where the result is rounded down).

So what to do or whether to consider this something for optimization heavily depends on the actual value of A_CONSTANT.

Probably the easiest way solving this (or comparing solutions) would be comparing the resulting assembly code, because it will be the final result that's actually processed. Optimizing this purely on theory is rather complicated and might even get you wrong or misleading results.

score 0 · Answer 2 · edited May 23 '17 at 12:05

AVR instructions set doesn't have a divide operation on its own so as being mentioned in the comments it's all goes to point how compiler you are using implements this operation.

You might want to have a look on generated machine instructions to see what's actually generated and think of possible optimisation.

There are a lot of information available on google about different implementations of integer divisions, like for example this

Also very good source of information.

C atmega2560 Division of large integers

2 Answers2