Fastest (optimal in time) way of converting seconds and nanoseconds to microseconds

Question

I want to write function in C that takes seconds and nanoseconds as input. Converts seconds and nanoseconds into microseconds, returns the total in microseconds.

unsigned long long get_microseconds(int seconds, unsigned long long nSeconds);

Now the conversion is pretty trivial. I can use following formula-

mSeconds = Seconds*1000000 + nSeconds/1000 (Loss of precision in nanosecond conversion is alright, my timer has anyway minimum resolution of 100 microseconds)

What would be fastest way of implementing this equation without using multiplication and division operators to get the best accuracy and least number of cpu cycles.

EDIT: I am running on a custom DSP with a GNU based but custom designed toolchain. I have not really tested out performance of the arithmetic operation, I am simply curious to know if it would affect the performance and if is there a way to improve it.

What hardware are you running on? Is this actually a bottleneck, and is the simple implementation failing to meet its performance requirements? — user2357112, Jun 27 '16 at 22:31
Don't do premature optimisations! Any reason you don't just count in the target resolution (i.e. add 100*1000 if your timer has 100µs resolution?) — too honest for this site, Jun 27 '16 at 22:37
What DSP is it? It's pretty important to know what kind of arithmetic and how big integers it can handle. — Matteo Italia, Jun 27 '16 at 22:47
Why a return type of `unsigned long long`, rather than `long long`? If `seconds < 0`, you want a positive result? If not, why not use `unsigned seconds`? — chux - Reinstate Monica, Jun 27 '16 at 22:53

score 6 · Answer 1 · answered Jun 27 '16 at 22:31

6

return Seconds*1000000 + nSeconds/1000;

If there's any worthwhile bit-shifting or other bit manipulation worth doing, your compiler will probably take care of it.

answered Jun 27 '16 at 22:31

Amit

45,440
9
78
110

A succinct way of saying enable optimizations at compile time and let the compiler provide the solution. – David C. Rankin Jun 27 '16 at 22:35
`Seconds*1000000` can readily overflow `int` math. Suggest `Seconds*1000000LL`. – chux - Reinstate Monica Jun 27 '16 at 22:52

score 1 · Answer 2 · answered Jun 27 '16 at 22:37

The compiler will almost certainly optimize the multiplication as far as it can. What it will not do is "accept a small loss" when dividing by 1000, so you will perhaps find it somewhat faster writing

return Seconds*1000000 + nSeconds/1024; /* Explicitly show the error */

...keeping in mind that nSeconds can't grow too much, or the error may become unacceptable.

But whatever you do, test the results - both speed and accuracy over real inputs. Also explore converting the function to a macro and save the call altogether. Frankly, for so simple a calculation there's precious little chance to do better than an optimizing compiler.

Also, consider the weight of this optimization in the scope of the global algorithm. Is this function really called with such a frequency that its savings are worth the hassle?

score 0 · Accepted Answer · answered Jun 27 '16 at 22:53

If nSeconds never gets above 2³² (it shouldn't if you are working with "split time" as from timespec - it should be below 10⁹), you should probably use a 32 bit integer for it.

On a 64 bit machine it's not a problem to use 64 bit integers for everything (the division is optimized to a multiply by inverse+shift), but on a 32 bit one the compiler gets tricked into using a full 64 bit division routine, which is quite heavyweight. So, I would do:

unsigned long long get_microseconds(int seconds, unsigned long nSeconds) {
    return seconds*1000000ULL + nSeconds / 1000;
}

This, at least on x86, doesn't call external routines and manages to keep the 64 bit overhead to a minimum.

Of course, these are tests done on x86 (which has a 32x32=>64 multiply instruction even in 32 bit mode), given that you are working on a DSP you would need to check the actual code produced by your compiler.

Fastest (optimal in time) way of converting seconds and nanoseconds to microseconds

3 Answers3