Introduction

Ever needed to scale 64 bit integers? I did when I was building a time tracking Kalman Filter. I decided to keep track of time as a 64 bit integer just as the .NET framework does. The big advantage of using the 64 bit integer is that you can keep time up to 100 nanosec. accurate and keep that accuracy after 2012. That is approximately the date after which you can no longer store seconds since 1980 in a double with microsecond accuracy. Another advantage is the easy exchange of times with .NET.

So I coded all the time keeping using __int64. This all went pretty well since the VS C++ compiler supports most arithmetic operations with __int64. You can add, subtract, multiply and divide, but all with the limitation that the result has to fit in a __int64. The problem arose when I wanted to scale a time value. The general idea of scaling is to express the scale factor as the quotient of a numerator and a denominator, then first multiply with the numerator and then divide by the denominator. You can’t use a separate multiplication and division for that since the intermediate result of the multiplication can be too large to fit a __int64. This problem used to exist in the 32 bit world when 64 bit integers were not yet supported by compilers. That’s why Windows provides a MulDiv function that does the multiplication and the division in one call, keeping track of the 64 bit intermediate result. The 32 bit processors for the PC support extended 32 bit divisions. Unfortunately the OS doesn’t provide us with a function to do the same thing with 64 bit integers. This is probably because the div instruction on today’s processors doesn’t support extended 64 divisions, yet.

The main problem lies with the 128 bit intermediate result that is needed to do a full 64 bit MulDiv(). After spending many hours on the web to find a pre-cooked solution I found a few references to the GNU MulDiv64 which scales a 64 bit integer with two 32 bit values and the book “The Art of Assembly Programming” by Randall Hyde. The 64*32/32 MulDiv would do the trick but didn't really satisfy my search for a full 64*64/64 MulDiv that would allow me to use only __int64. Thus I turned to Randall's book. This contained a section on Extended Precision integer arithmetic which was exactly what I needed. I implemented the methods described there in a small C++ library called MulDiv64. This way you don't have to go through all the nitty gritty of puzzling the pieces of the book together and the inline assembly programming.

In situations where the divider can be kept constant at a power of 2, the division can be implemented using a right shift. This results in a much faster scaling because the full 128 bit division is somewhat slow due to the lack of hardware support.

Using the code

The library is implemented as a C++ static library. This way you avoid DLL or COM overhead in your calculations. Most functionality is written using inline assembly, except for the ABS() operations which the compiler can do efficiently itself. I tried to catch special conditions where processor support can be used to speed up the calculation. For example, when the divider is small enough to fit in a DWORD, the division can be done in four chunks instead of bit by bit. The result is always a 128 bit value but both functions clip the result to 64 bit because that is usually what you’re after.

Include the library MulDiv64.lib in the Additional Dependencies for your linker input. This can be found in the project properties dialog. Don't forget to include the header file as well.

Of course, the code could be imported in many other ways. For instance, it might be convenient to compile the library to a DLL or COM object. But usage this way will lead to significant performance loss.

You will see that the included test program is a little more verbose so that it can be run from the command line.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

Share

About the Author

Richard van der Wal is a Software Development Engineer at Fugro Intersite B.V.
He holds a bachelors in mechanical engineering and a bachelors in information technology and had many years of experience in industrial automation before he started his job at Intersite. His current activities focus on software design and system design for real-time data processing in the offshore industry both on Windows PCs and embedded Linux platforms.

I'm working on a project that I have to implement a C++ code, contains __int 64 variables, on NIOSII IDE , which doesn't support this type.how can I use those variables, or how can I do a 64 bit multiply with 32 bit multiplers?becaus it supports int 32.

In your example:
a=0xAAAAAAAAAAAAAAAA=(16^16-1)*(10/15),
b=0x5555555555555555=(16^16-1)*(5/15),
c=0x1000000000000000=16^15,
r=(a*b)/c=(16^16-2+1/16^16)*(3+5/9).
As the statements above indicates, r > 2^64 (16^16), and can't have type __int64. So, your result (0x38E38E38E38E38E2) is incorrect. Since you use Microsoft specific type __int64, in such cases you can use Microsoft's tactics for int type (MulDiv, WinAPI32): if an overflow occurred or denominator was 0, the return value is –1.