I'm an embedded developer. I haven't worked with RTOS/linux. I was going through RTOS concepts when I stumbled upon 'context switching'. I understand that when context switch occurs, all the registers along with PC(Program Counter) gets saved in stack before another thread is loaded to the processor. Isn't a similar thing happening when an interrupt occurs(in a controller which doesn't use any kind of OS)?
How different are those two terms?
There isn't a fundamental difference, it's more a question of degree — the amount of context that needs to be saved.
When an RTOS thread context switch occurs, all of the CPU state that any thread might use must be saved. This usually includes all of the CPU registers, including flag or status registers, so that when they're restored, the thread resumes as though nothing ever happened.
When an interrupt occurs, there's still a context switch, but only the context that the interrupt handler actually needs to use needs to be saved and then subsequently restored. If you write your interrupt handler in a high-level language, this will pretty much be equivalent to a full thread context switch, because there are no constraints on what resources such an interrupt handler might touch. However, if you write your interrupt handler in assembly language, you can keep track of exactly which registers it touches and save only those. This allows the execution of the interrupt handler to be extremely fast, reducing its impact on the rest of the system, and/or allowing it to handle interrupts at a higher rate.
Both interrupts and context switches are interrupts. The main difference is in what happens after the interrupt or context switch.
With an interrupt the current state (or context) is stored in a temporary area (usually, but not always, the stack). The ISR then does its thing, and the state is then restored and the interrupt routine returns. The crucial thing here is that the ISR returns exactly where it left off in the same thread.
A context switch looks just like an interrupt. The state is stored in the stack as per usual. However, the location of that stack and any extra state information is stored elsewhere (in the thread). A new set of data from another thread is then substituted with the current data and the ISR returns. Here though the ISR doesn't return to where it left off, but it returns to where the newly switched in thread was interrupted the last time a context switch occurred while it was running.
It's this change of return location and data that, besides what the content of the ISR may be, distinguishes an ISR form a context switch.
an interrupt is a signal sent to a thread to indicate that it should stop what it is doing and perform some other task, while context switching is the process of saving the state of a currently executing thread and restoring the state of a different thread so that it can continue executing.
