Task Switching in Arm - arm

Question

I am reading the Arm Architecture Reference Manual and I think I have some theoritical questions.
Well at first I am confused whether by context switching we mean task switching?
Secondly, by having an experience with architecture of Intel 80386 I remember there were Task Descriptors and some other mechanisms that automatically saved the state of the task, here in arm how is it done? Is it done, let's say "manually", by saving registers in stack?
And that ASID(Application Space ID) is linked to the previous that I asked somehow?

Answer 1

Well at first I am confused whether by context switching we mean task switching?
Yes, task switching is exactly same to context switch.
here in arm how is it done? Is it done, let's say "manually", by saving registers in stack?
Yes, we save the task context on the stack, usually on the privileged mode(IRQ/SVC) stack, copy the context into the task control block, then restore the context from another task control block which is going to run. Here is a presudo code:
irq_handler:
sub lr, lr, 4
push {lr}
// push cpu context
// copy the context to task's tcb
// get tcb of another task which is going to run
// copy the tcb context back to stack
// pop cpu context
pop {pc}
And that ASID(Application Space ID) is linked to the previous that I asked somehow?
Don't know this

Answer 2

If you have 2 threads with one stack each (array of the registers value), then if you have an ISR that saves the state of the thread and switches to the other thread, then that is a context switch. The simplest example is an operating system with 2 threads (1 producer, 1 consumer) where the switch can look similar to the code here.
/*
* threadswitch - change thread
*
* The thread stack-pointer is supplied as a parameter.
* The old thread's stack-pointer value is saved to the array
* os_thread_info_array, and a new thread is selected from the array.
* The stack pointer of the new thread is returned.
*/
unsigned int os_internal_threadswitch( unsigned int old_sp )
{
unsigned int new_sp;
os_number_of_thread_switches += 1; /* Increase thread-switch counter. */
/* Print line 1 of an informational message. */
printf( "\nPerforming thread-switch number %d. The system has been running for %d ticks.\n",
os_number_of_thread_switches,
os_get_internal_globaltime() );
/* Save the stack pointer of the old thread. */
os_thread_info_array[ os_currently_running_thread ].thread_sp = old_sp;
/* Print part 1 of a message saying which threads are involved this time. */
printf( "Switching from thread-ID %d ",
os_thread_info_array[ os_currently_running_thread ].thread_id );
/* Perform the scheduling decision (round-robin). */
os_currently_running_thread += 1;
if( os_currently_running_thread >= os_current_thread_count )
{
os_currently_running_thread = 0;
}
/* Print part 2 of the informational message. */
printf( "to thread-ID %d.\n",
os_thread_info_array[ os_currently_running_thread ].thread_id );
/* Get the stack pointer of the new thread. */
new_sp = os_thread_info_array[ os_currently_running_thread ].thread_sp;
/* Return. */
return( new_sp );
}

Answer 3

The "context" generally refers to the current state of the CPU; i.e. contents of the the registers. Each "task" (a.k.a. thread) has its own Task Control Block structure (TCB) that stores the pertinent information that the OS knows about the task, such as priority, entry point, name, stack size, etc. Generally, the current CPU context is saved on the stack the of the running task whenever that task is swapped out (the TCB has a pointer to the task stack). The stack pointer is then saved to a known location (usually in the TCB), and the CPU context is restored with info from the TCB and stack of the next task to run. After the switch, the stack pointer is pointing to the stack of the newly running task, and a return goes back to the next instruction after the last call made by that task. That is a context switch.
I don't know why people are indicating that a context switch would be in an ISR. A context switch usually occurs during a system call that causes the running task to block, such as a sleep call, or a semaphore get call, though it may also occur when the system tick ISR runs and wakes up a higher priority task, or determines that the current task's timeslice has expired and another task of equal priority is ready to run. The context switch is just a function called by the OS scheduler, which is called from various other system functions, and it does not make sense for it to be an ISR, though i suppose it could be implemented as a "software" interrupt call, and perhaps that was they had in mind.
The point is that context switches don't only occur as a result of an interrupt, which is the impression I got from other responses. In fact, they occur far more often when a system call is made by a task.

Answer 4

Here is a code that does exactly what you ask for - https://github.com/DISTORTEC/distortos/blob/master/source/architecture/ARM/ARMv6-M-ARMv7-M/ARMv6-M-ARMv7-M-PendSV_Handler.cpp . On exception entry some registers are saved automatically, so you just save remaining ones, switch stack pointer and do the opposite - unstack "remaining" registers and exit the exception. This gets a bit harder if you also need to save FPU registers, because these don't need to be saved every time (they are unused if the thread doesn't do any FPU calculations).