Lines Matching refs:thread

36 If a thread uses any floating point register,
37 the kernel generates a fatal error condition and aborts the thread.
42 This mode is used when the application has only a single thread
46 be used by any thread (initialization in skipped on ARM Cortex-M platforms and
60 the kernel supports one or more of the following thread sub-classes:
62 * non-user: A thread that cannot use any floating point registers
64 * FPU user: A thread that can use the standard floating point registers
66 * SSE user: A thread that can use both the standard floating point registers
71 by any thread, then saves and restores these registers during
84 This means that any thread is allowed to access the floating point registers.
85 The ARM kernel automatically detects that a given thread is using the floating
86 point registers the first time the thread accesses them.
88 Pretag a thread that intends to use the FP registers by
91 * A statically-created ARM thread can be pretagged by passing the
94 * A dynamically-created ARM thread can be pretagged by passing the
97 Pretagging a thread with the :c:macro:`K_FP_REGS` option instructs the
99 the thread's guard region to always guarantee stack overflow detection,
100 and enable lazy stacking for the given thread upon thread creation.
102 During thread context switching the ARM kernel saves the *callee-saved*
103 floating point registers, if the switched-out thread has been using them.
105 the thread's stack. If the switched-in thread has been using the floating
107 the switched-in thread and the *caller-saved* FP context is restored from
108 the thread's stack. Thus, the kernel does not save or restore the FP
111 Each thread that intends to use the floating point registers must provide
132 If an ARM thread does not require use of the floating point registers any
134 not to save or restore its FP context during thread context switching.
145 On the ARM64 (Aarch64) architecture the kernel treats each thread as a FPU
149 FPU user to a non-user thread, and then back to the original FPU user.
153 current FPU user context is saved in the thread object and the ISR is resumed
159 Each thread object becomes 512 bytes larger when Shared FP registers mode
165 On the ARCv2 architecture, the kernel treats each thread as a non-user
166 or FPU user and the thread must be tagged by one of the
169 * A statically-created ARC thread can be tagged by passing the
172 * A dynamically-created ARC thread can be tagged by passing the
175 If an ARC thread does not require use of the floating point registers any
177 not to save or restore its FP context during thread context switching.
179 During thread context switching the ARC kernel saves the *callee-saved*
180 floating point registers, if the switched-out thread has been using them.
182 the thread's stack. If the switched-in thread has been using the floating
184 the switched-in thread and the *caller-saved* FP context is restored from
185 the thread's stack. Thus, the kernel does not save or restore the FP
193 On the RISC-V architecture the kernel treats each thread as an FPU
198 FPU user to a non-user thread (or an FPU user that doesn't touch the FPU
203 current FPU user context is saved in the thread object and the ISR is resumed
210 back an "active FPU user" thread that had its FPU context saved away due to
211 FPU usage by another thread. Active FPU users are so designated when they
213 being scheduled out. So if a thread doesn't modify the FPU state within its
214 scheduling slot and another thread claims the FPU for itself afterwards then
215 that first thread will be subjected to the on-demand regime and won't have
217 thread does modify the FPU before being scheduled out then it is likely to
221 Each thread object becomes 136 bytes (single-precision floating point
228 On the SPARC architecture, the kernel treats each thread as a non-user
229 or FPU user and the thread must be tagged by one of the
232 * A statically-created thread can be tagged by passing the
235 * A dynamically-created thread can be tagged by passing the
238 During thread context switch at exit from interrupt handler, the SPARC
240 the switched-out thread. Floating point registers are saved on the thread's
241 stack. Floating point registers are restored when a thread context is restored
249 is required for each FPU user thread to load and store floating point
256 On the x86 architecture the kernel treats each thread as a non-user,
260 switching from an FPU user to a non-user thread, and then back to the original
262 thread must provide so the registers can be saved properly.
273 The x86 kernel automatically detects that a given thread is using
274 the floating point registers the first time the thread accesses them.
275 The thread is tagged as an SSE user if the kernel has been configured
277 not supported. If this would result in a thread that is an FPU user being
280 pretag a thread using one of the techniques listed below.
282 * A statically-created x86 thread can be pretagged by passing the
286 * A dynamically-created x86 thread can be pretagged by passing the
290 * An already-created x86 thread can pretag itself once it has started
294 If an x86 thread uses the floating point registers infrequently it can call
299 When the thread again needs to use the floating point registers it can re-tag
308 No special coding is required for a thread to use floating point arithmetic
347 Also, ensure that any thread that uses the floating point registers has