32 位 x86 上的 64 位 int 算术（来自 c ）

Question

Is there a fast way of using 64bit ints on 32 x86 machines (in c (added: and c++) language compilers)?

32 bit x86 support 64 bit operations in some extent (there is some movq instruction in old mmx and some other commands probably), but how to use it from c?

What if someone want to use a 64bit ints arithmetic in c on 32 bit x86 machines - how to do it most easy and efficient?

//EdiT

do by now I found some of candidates for it

    uint64_t A;
    long long a;
    int64 a;
    __int64 a;

what should be used ? is there a chance that some implementation of above arthimetic is better/faster than other?

Answer 1

To perform 64 bit operations you can use either int64_t or uint64_t .

They are defined in C99 by the header file stdint.h .

Answer 2

Is there a fast way of using 64bit ints on 32 x86 machines (in c language compilers)?

int isn't guaranteed to be 64 bits wide; It's guaranteed to be at least 16 bits wide. If you want a type that's guaranteed to be at least 64 bits wide, use long long instead. Talking about optimisation at this level is quite fruitless. You're better off coming up with a complete solution, profiling it to determine what the slowest part of the solution is and targeting that part of your code for optimisation or choosing a different algorithm that performs that slow operation more quickly. Note: By solution, I mean "a program that solves an actual problem".

32 bit x86 support 64 bit operations in some extent (there is some movq instruction in old mmx and some other commands probably), but how to use it from c?

Whether or not your compiler performs the movq and/or mmx optimisations you mentioned automatically is questionable, as you haven't told us which compiler you're using. However, given the simplicity of this sort of optimisation compared to others (eg. dead code optimisation, tail call optimisation, even loop unrolling), I'd guess that your compiler does it automatically. This is another reason talking about optimisation at this level is fruitless; Those who write compilers are usually very good programmers, with a keen understanding of algorithms who can write automaton to perform simple optimisations easily.

What if someone want to use a 64bit ints arithmetic in c on 32 bit x86 machines - how to do it most easy and efficient?

Have you tried compiling a fully-optimised testcase and looking for movq operations in it's machine code? If I haven't convinced you that you should profile your code to determine whether or not this is actually worth targetting, then do this: Compile your solution (something that solves a problem, remember... and compile as "fully optimised"), benchmark it so that you have something to measure your optimisations against, convert the machine code to assembly, perform any manual optimisations in assembly, recompile and benchmark again. You might:

1. spend a week looking optimising and benchmarking to find that you've shaved a few microseconds and give up... This would be a good indication that your compiler spends a few seconds producing code that is as good as the code you'd take weeks to write. Keep the compiler, but give up on the micro-optimisation.
2. find a significant optimisation that your compiler doesn't perform (fairly unlikely). Either choose a more optimal compiler, or get in contact with the people who wrote your compiler, and explain it to them...

Either way, progress!

Answer 3

据我所知，在32位系统上的Assemby中有些复杂的过程，因此可能无法在32位系统上进行加速的64位乘法或除法（使用了软件例程）（这将是对它的部分回答），但是我仍然不确定100％是否正确，因此，如果我错了，请更正此错误。

Answer 4

As others have said, the compilers do a lot of optimizations automatically. To mess with those optimizations, you'd have to go into the compiler settings or add commands, but in your case, people have had 50 years to solve this problem so it's best to leave it be unless you want to write your own compiler.