Zephyr study notes 2, scheduling

Chapter two ： Scheduler （Scheduling）.

The kernel priority based scheduler allows application threads to share CPU.

The thread changes from running state to pending or waiting state , For example, through k_sem_take() perhaps k_sleep().

The thread transitions to the ready state , For example, using k_sem_give() perhaps k_thread_start().

Return the thread context after processing the interrupt , When the running thread calls k_yield() when .

When a thread actively starts an operation that converts itself to a suspended or waiting state , It will sleep .

Collaborative

Preemptive

Scheduler Locking

The preemptive thread that does not want to be preempted when performing critical operations can be called k_sched_lock(). Once the critical operation is completed , Preemptable threads must call k_sched_unlock() To restore its normal preemptive state .

Thread Sleeping

k_sleep()

k_wakeup()

Threads can call k_busy_wait() To perform busy waiting , This wait delays its processing for a specified period of time , Instead of CPU Give up to another ready thread .

CPU Idling

static k_sem my_sem;

void my_isr(void *unused)
{
    k_sem_give(&my_sem);
}

void main(void)
{
    k_sem_init(&my_sem, 0, 1);

    /* wait for semaphore from ISR, then do related work */

    for (;;) {

        /* wait for ISR to trigger work to perform */
        if (k_sem_take(&my_sem, K_NO_WAIT) == 0) {

            /* ... do processing */

        }

        /* put CPU to sleep to save power */
        k_cpu_idle();
    }
}