Floating Point Services

No FP registers mode

This mode is used when the application has no tasks or fibers that use floating point registers. It is the kernel’s default floating point services mode.

If a task or fiber uses any floating point register, the kernel generates a fatal error condition and aborts the thread.

Unshared FP registers mode

This mode is used when the application has only a single task or fiber that uses floating point registers.

The kernel initializes the floating point registers so they can be used by any task or fiber. The floating point registers are left unchanged whenever a context switch occurs.

Shared FP registers mode

This mode is used when the application has two or more tasks or fibers that use floating point registers.

The kernel initializes the floating point registers so they can be used by any task or fiber, then saves and restores these registers during context switches to ensure the computations performed by each FPU user or SSE user are not impacted by the computations performed by the other users. A “lazy save” algorithm is used during context switching which updates the floating point registers only when it is absolutely necessary—for example, the registers are not saved when switching from an FPU user to a thread that does not use the floating point registers, and then switching back to the original FPU user.

Every task that uses the floating point registers must provide stack space where the kernel can save the registers during context switches. An FPU user must provide 108 bytes of added stack space, above and beyond its normal requirements; an SSE user must provide 464 bytes of added stack space.

The kernel automatically detects that a given task or fiber is using the floating point registers the first time the thread accesses them. The thread is tagged as an SSE user if the kernel has been configured to support the SSE registers, or as an FPU user if the SSE registers are not supported. If this would result in a thread that is an FPU user being tagged as an SSE user, or if the application wants to avoid the exception handling overhead involved in auto-tagging threads, it is possible to pre-tag a thread using one of the techniques listed below.

• A task or fiber can tag itself as an FPU user or SSE user by calling task_float_enable() or fiber_float_enable() once it has started executing.
• A fiber can be tagged as an FPU user or SSE user by its creator when the fiber is started.
• A microkernel task can be tagged as an FPU user or SSE user by adding it to the FPU task group or the SSE task group when the task is defined.

If a task or fiber uses the floating point registers infrequently it can call task_float_disable() or fiber_float_disable() to remove its tagging as an FPU user or SSE user. This eliminates the need for the kernel to take steps to preserve the contents of the floating point registers during context switches when there is no need to do so. When the thread again needs to use the floating point registers it can re-tag itself as an FPU user or SSE user using one of the techniques listed above.

Configuring Floating Point Services

To configure unshared FP registers mode, enable the FLOAT configuration option and leave the FP_SHARING configuration option disabled.

To configure shared FP registers mode, enable both the FLOAT configuration option and the FP_SHARING configuration option. Also, ensure that any task that uses the floating point registers has sufficient added stack space for saving floating point register values during context switches, as described above.

Use the SSE configuration option to enable support for SSEx instructions.

Example: Performing Floating Point Arithmetic

This code shows how a routine can use floating point arithmetic to avoid overflow issues when computing the average of a series of integer values. Note that no special coding is required if the kernel is properly configured.

int average(int *values, int num_values)
{
    double sum;
    int i;

    sum = 0.0;

    for (i = 0; i < num_values; i++) {
        sum += *values;
        values++;
    }

    return (int)((sum / num_values) + 0.5);
}