DevHeads IoT Integration Server•2y ago

Memory Operations During Context Switch: Impact on Priority Tasks?

Hi @Middleware & OS I have two tasks,

A

A and

B

B, with

A

A being high priority and

B

B low priority. There are two global variables,

condition

condition

condition

condition and

mem

mem

mem

mem. Let's say Task

B

B is currently running and performing memory operations. If Task

A

A becomes ready while Task

B

B is running, resulting in a context switch, will the memory operation continue even if the condition is set to false? If so, at which index will it restart? And what will the content of mem be after Task

B

B finishes executing?

***Task B - Low priority task ***             
   if (condition) {
      .....
      for (i = 0; i< 10; i++){
          // example we are at i=4  
          mem[i] = mem[i] +1;
      }
      ..... 
    }

***Task B - Low priority task ***             
   if (condition) {
      .....
      for (i = 0; i< 10; i++){
          // example we are at i=4  
          mem[i] = mem[i] +1;
      }
      ..... 
    }

***Task B - Low priority task ***             
   if (condition) {
      .....
      for (i = 0; i< 10; i++){
          // example we are at i=4  
          mem[i] = mem[i] +1;
      }
      ..... 
    }

***Task B - Low priority task ***             
   if (condition) {
      .....
      for (i = 0; i< 10; i++){
          // example we are at i=4  
          mem[i] = mem[i] +1;
      }
      ..... 
    }

And

*** TASK A - High priority task
***
    ......
    enter_critical();
    condition = false;
    mem[i] = 0;  
    exit_critical();
    ......

*** TASK A - High priority task
***
    ......
    enter_critical();
    condition = false;
    mem[i] = 0;  
    exit_critical();
    ......

*** TASK A - High priority task
***
    ......
    enter_critical();
    condition = false;
    mem[i] = 0;  
    exit_critical();
    ......

*** TASK A - High priority task
***
    ......
    enter_critical();
    condition = false;
    mem[i] = 0;  
    exit_critical();
    ......

now Task

A

A is finshed and yields resources for Task

B

B to run.

Priyanka SinghAPP•5/6/24, 4:47 PM

Yes, in most multitasking operating systems, if Task A becomes ready while Task B is performing a memory operation and a context switch occurs, the memory operation will likely continue even if

condition

condition

is set to

false

false

. Here's what might happen:

Context Switch and Memory Operations:

When a context switch happens due to Task A becoming high priority, the CPU state for Task B is saved, including the program counter (which points to the current instruction) and register values. This includes any registers involved in the memory operation.
Task A starts running, and when it finishes or needs to yield, control switches back to Task B.
During the context switch back to Task B, the saved CPU state is restored, placing the task at the exact point it was interrupted, including the memory operation.

Completion and

mem

mem

Content:

Assuming the memory operation itself doesn't rely on the value of
```
condition
```
```
condition
```
, it will continue from where it left off and complete as intended.
The final content of
```
mem
```
```
mem
```
will depend on the specific memory operation Task B was performing:
- If it was writing data to memory, the memory location will contain the intended data written by Task B.
- If it was reading data,
```
mem
```
```
mem
```
  will contain the value read from memory at the point of interruption.

condition

condition

Check:

The value of
```
condition
```
```
condition
```
likely won't affect the continuation of the memory operation itself.
However, the logic within Task B might check the value of
```
condition
```
```
condition
```
after the memory operation is complete. If
```
condition
```
```
condition
```
is
```
false
```
```
false
```
at that point, Task B might need to handle that situation appropriately (e.g., stop further processing, discard the memory operation result, etc.).
Although, this is a general explanation, and the exact behavior can vary depending on the specific operating system, hardware architecture, and programming language used. Some systems might offer mechanisms to preempt or abort tasks mid-operation, but this is less common for basic memory accesses.

barafaelAPP•5/6/24, 4:47 PM

In case you are interested in a fresh take on this domain, have a look at rtic.rs
Hardware-based RTOS-like scheduling for cortex-m and riscv clic, statically guaranteeing absence of priority inversion, deadlock, and data races. Locking is 1x RMW

Marvee AmasiAPP•5/6/24, 4:47 PM

Wow thanks @Priyanka Singh , so it means that if Task B is interrupted by Task A and then resumes after Task A completes, could Task B potentially encounter any race conditions or synchronization issues with other tasks accessing the same memory locations?

Priyanka SinghAPP•5/6/24, 4:48 PM

Yes, if Task B is interrupted by Task A and then resumes after Task A completes, there's a potential for race conditions or synchronization issues with other tasks accessing the same memory locations, especially if condition is used to control access to the memory operations in Task B

Marvee AmasiAPP•5/6/24, 4:48 PM

Sure thanks @barafael

Memory Operations During Context Switch: Impact on Priority Tasks?

Similar Threads

Similar Threads

Similar Threads