[Top] [All Lists]

[RFC] FPU context switch

Subject: [RFC] FPU context switch
From: Jun Sun <>
Date: Tue, 17 Sep 2002 11:04:23 -0700
Original-recipient: rfc822;
User-agent: Mutt/1.2.5i
I am rewriting the FPU management code with the following
objectives in my mind:

1) to make it work for SMP.  Right now, processes can migrate
to different CPUs leaving their FPU context on another CPU.
And the global variable last_task_used_math is shared by
multiple CPUs. :-)

2) to provide a layer to generic kernel code that hides
the differences between fpu emul case and hard FPU case,
so that we don't see many "if (mips_cpu.options & MIPS_CPU_FPU)"

3) to simplify some existing code (such as those in signal.c)
so that we don't see many "if (last_task_used_math == ...)" around.

I am now facing a couple of choices in the implementation and 
like to hear back from you.  Those choices mainly differ at when we 
should save fpu context and when we should restore it.

1) always blindly save and restore during context switch (switch_to())

Not interesting.  Just list it here for completeness.

2) save PFU context when process is switched off *only if* 
   FPU is used in the last run.  
   restore FPU context on next use of FPU.

Need to use an additional flag to remember whether it is used
in the current run.  Perhaps overridding used_math?  In that
case, used_math == 2 indicates it used in the current run.
used_math is set back to 1 when process is switched off.

Very simply to implement.

3) save FPU context when process is switched off *only if* 
   FPU is used in the last run.  
   restore FPU context on the next use of FPU and *only* if other 
   processes have tampered FPU context since the last use of FPU by 
   the current process.

This requires each CPU to remember the last owner of FPU.
In order to support possible process migration cases in a SMP
system, each process also needs to remember the processor
on which it used FPU last.  A process has a valid live FPU
context on a CPU if those two variables match to each other.
Therefore we can avoid unnecessary restoring FPU context.

Fairly complex in implementation. 

4) don't save or restore any FPU context during context switches.
   Instead, we implement a full SMP-safe version of lazy fpu 

This introduces three states in terms of FPU context status:
        a) live FPU context in current CPU
        b) saved FPU context in memory
        c) live FPU context in another CPU
Before we only have a) and b) states.  c) is new in this approach.

To deal with c), we need to provide an inter-processor call so that
we can ask another CPU to save FPU context in case we need to access
it on this CPU.

Additionally we need similar variables required in 3) to keep track
who owns FPU at any time.

Very complex to implement.  Has the best performance, though.

Currently I am leaning towards 2) or 3).  What is your opinion?


<Prev in Thread] Current Thread [Next in Thread>