Use of floating point in the Linux kernel

by

Because…

  • many programs don’t use floating point or don’t use it on any given time slice; and
  • saving the FPU registers and other FPU state takes time; therefore

…an OS kernel may simply turn the FPU off. Presto, no state to save and restore, and therefore faster context-switching. (This is what mode meant, it just meant that the FPU was enabled.)

If a program attempts an FPU op, the program will trap into the kernel, the kernel will turn the FPU on, restore any saved state that may already exist, and then return to re-execute the FPU op.

At context switch time, it knows to actually go through the state save logic. (And then it may turn the FPU off again.)

By the way, I believe the book’s explanation for the reason kernels (and not just Linux) avoid FPU ops is … not perfectly accurate.1

The kernel can trap into itself and does so for many things. (Timers, page faults, device interrupts, others.) The real reason is that the kernel doesn’t particularly need FPU ops and also needs to run on architectures without an FPU at all. Therefore, it simply avoids the complexity and runtime required to manage its own FPU context by not doing ops for which there are always other software solutions.

It’s interesting to note how often the FPU state would have to be saved if the kernel wanted to use FP . . . every system call, every interrupt, every switch between kernel threads. Even if there was a need for occasional kernel FP,2 it would probably be faster to do it in software.


1. That is, dead wrong.
2. There are a few cases I know about where kernel software contains a floating point arithmetic implementation. Some architectures implement traditional FPU ops in hardware but leave some complex IEEE FP operations to software. (Think: denormal arithmetic.) When some odd IEEE corner case happens they trap to software which contains a pedantically correct emulation of the ops that can trap.

More Related Contents:

  1. create a file with prefix =file1 followed by the random number
  2. How do the likely/unlikely macros in the Linux kernel work and what is their benefit?
  3. Increasing the maximum number of TCP/IP connections in Linux
  4. Finding which process was killed by Linux OOM killer [closed]
  5. How to debug the Linux kernel with GDB and QEMU?
  6. Is there any API for determining the physical address from virtual address in Linux?
  7. Handling multiple SIGCHLD
  8. kernel stack and user space stack
  9. How to mmap a Linux kernel buffer to user space?
  10. Using gdb to single-step assembly code outside specified executable causes error “cannot find bounds of current function”
  11. How to continuously monitor the directory using dnotify /inotify command
  12. Why can’t I mmap(MAP_FIXED) the highest virtual page in a 32-bit Linux process on a 64-bit kernel?
  13. Accurate calculation of CPU usage given in percentage in Linux?
  14. How to “hibernate” a process in Linux by storing its memory to disk and restoring it later?
  15. What is the interface for ARM system calls and where is it defined in the Linux kernel?
  16. How does Linux determine the next PID?
  17. Do Kernel pages get swapped out?
  18. Just black screen after running Qemu
  19. How is the Linux kernel tested?
  20. How to avoid transparent_hugepage/defrag warning from mongodb?
  21. Converting jiffies to milli seconds
  22. Direct Memory Access in Linux
  23. Linux Stack Sizes
  24. How to decode /proc/pid/pagemap entries in Linux?
  25. init function invocation of drivers compiled into kernel
  26. Signed executables under Linux
  27. How can I monitor the NIC status(up/down) in a C program without polling the kernel?
  28. Using software floating point on x86 linux
  29. How can I create a device node from the init_module code of a Linux kernel module?
  30. Sending UDP packets from the Linux Kernel

Leave a Comment