Shulou(Shulou.com)06/02 Report--

At present, most CPU support floating-point unit FPU,FPU as a separate coprocessor outside the processor core, but for embedded processors, floating-point computing is rarely used, and some embedded processors will remove floating-point coprocessors.

X86 processors generally have FPU. On the other hand, the ARM PPC MIPS processor will have no FPU.

How linux kernel handles floating-point operations is divided into processors with FPU and processors without FPU.

(the following is a summary of personal knowledge. The study is not deep. I hope you can correct the mistakes and learn together.)

A pair of processors with FPU

1 for linux kernel, kernel itself compiles using the-msoft-float option by default, and compiles soft floating-point programs by default, which means that the gcc compiler simulates floating-point operations (provided by the glibc library) and replaces floating-point operation codes with fixed-point operations.

For processors with FPU, we can remove the compilation option-msoft-float, usually in arch/xxx/Makefile. Compile kernel to hard floating point, that is, let the processor's floating point instructions calculate floating point

Hard floating-point operations are certainly more efficient than simulated fixed-point operations. (there is usually no floating-point operation in kernel code, so the efficiency effect is small.)

2 for app running on kernel, especially for graphics programs, such as QT, there are more floating-point operations, we can compile directly, because the processor supports floating-point operations and floating-point instructions.

Second, for a processor without FPU

1 for linux kernel, the-msoft-float option is used by default, and the soft floating point program is compiled by default. Linux kernel compilation does not rely on linking any libraries, and the corresponding simulated floating point ABI is implemented in kernel.

2 for app running on kernel, there are two ways to handle floating-point operations:

(1) soft floating point is simulated by kernel.

The application is compiled directly using a hard floating point (the compiler compiles to a hard floating point program by default).

As for kernel, all the PPC MIPS processors I know have special floating-point operation exception handling. when the program encounters floating-point instructions and cannot run floating-point instructions, the hardware will produce corresponding interrupt exceptions. Kernel floating-point exception handler carries out soft floating-point simulation operation according to the instruction content, returns the operation result and then resumes the execution to user space.

For ARM I did not find an exception entry for floating-point computing in its exception introduction, but there is also support for soft floating-point calculations in kernel

When you configure the ARM Linux kernel, you should see a configuration like this:

Menu "Floating point emulation" comment "At least one emulation must be selected" config FPE_NWFPE...

This is used to configure the analog floating-point processor in the kernel.

Specific ARM how to implement support exception simulation soft floating point, the specific implementation of time also need to take a closer look at the code, in arch/arm/nwfpe.

The advantage of this approach is that the application does not need to be recompiled, and the floating-point simulation needs to be turned on in kernel, which is very convenient to use.

But the disadvantage is also obvious, each floating-point operation has to trigger interrupt exception, user space and kernel space switch, the execution efficiency is too low.

(2) recompile app with soft floating point

This can avoid the above problems, app compilation needs to connect to the glibc library, use-- msoft-float, use glibc analog floating point, replace with fixed-point operation, the advantage is that the performance will be better.

But the disadvantage is that because different compilation options are used, the ABI used may change, if a library or application does not use the same compilation options (ABI is different)

Unexpected conditions will occur when the system is running, and even cause a crash.

According to the recent debugging record of a processor in PPC, kernel died at a certain address after normal boot into console, and there were many floating-point operations in user space. After asking IC, I learned that FPU was removed, but the processor floating-point exception did not enable.

When you encounter a floating-point instruction, the processor does not trigger an exception and does not know how to run the instruction.

Therefore, when transplanting kernel, we should also know whether the processor has FPU or not. if the processor removes the FPU and the core does not do the corresponding processing (enable floating-point exception), then the floating-point instruction running result of APP is unpredictable, and the soft floating-point toolchain can be used to compile APP.

Here's a little thought:

For a processor, there are floating-point exceptions in the processor design (both MIPS PPC), and FPU can also be connected to it.

After connecting to FPU, floating-point exceptions must be shielded in the processor core, otherwise floating-point operations will still generate floating-point exceptions, and FPU will be of no practical significance.

Without FPU, you have to enable floating-point exceptions in the processor core, otherwise, like the problem I encountered above, the processor does not know how to run the floating-point instruction and the result is unpredictable.

The above article about linux kernel's support for floating-point operations is all the content that the editor has shared with you. I hope I can give you a reference and I hope you will support it.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.