microPython的源码解析之 scheduler.c

MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。
下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.

---

microPython Python最小内核源码解析
NI-motion运动控制c语言示例代码解析
python编程示例系列 python编程示例系列二
python的Web神器Streamlit

---

这段代码是 MicroPython 调度器的一部分，它负责管理任务调度、事件处理和异常管理。代码中的注释已经翻译成中文，并且我添加了一些额外的注释来帮助理解代码的功能和结构。如果您有任何具体问题或需要进一步的解释，请随时提问。

#include <stdio.h>

#include "py/mphal.h"
#include "py/runtime.h"

// 在主线程上调度一个异常（用于由异步源 "抛出" 的异常，比如中断和UNIX信号处理器）。
void MICROPY_WRAP_MP_SCHED_EXCEPTION(mp_sched_exception)(mp_obj_t exc) {
   
    MP_STATE_MAIN_THREAD(mp_pending_exception) = exc;

    #if MICROPY_ENABLE_SCHEDULER && !MICROPY_PY_THREAD
    // 优化情况，当我们有调度器但没有线程时。
    // 允许虚拟机进行单一检查，排除挂起的异常和排队的任务。
    if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) {
   
        MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
    }
    #endif
}

#if MICROPY_KBD_EXCEPTION
// 这个函数可能会在任何时候异步调用，因此只做最少的操作。
void MICROPY_WRAP_MP_SCHED_KEYBOARD_INTERRUPT(mp_sched_keyboard_interrupt)(void) {
   
    MP_STATE_VM(mp_kbd_exception).traceback_data = NULL;
    mp_sched_exception(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)));
}
#endif

#if MICROPY_ENABLE_VM_ABORT
// 调度虚拟机中止。
void MICROPY_WRAP_MP_SCHED_VM_ABORT(mp_sched_vm_abort)(void) {
   
    MP_STATE_VM(vm_abort) = true;
}
#endif

#if MICROPY_ENABLE_SCHEDULER

#define IDX_MASK(i) ((i) & (MICROPY_SCHEDULER_DEPTH - 1))

// 这是一个宏，因此它保证在像 mp_sched_schedule 这样的函数中被内联，这些函数可能位于特殊的内存区域。
#define mp_sched_full() (mp_sched_num_pending() == MICROPY_SCHEDULER_DEPTH)

static inline bool mp_sched_empty(void) {
   
    // 静态断言确保 MICROPY_SCHEDULER_DEPTH 适合 8 位
    MP_STATIC_ASSERT(MICROPY_SCHEDULER_DEPTH <= 255);
    // 静态断言确保 MICROPY_SCHEDULER_DEPTH 是 2 的幂
    MP_STATIC_ASSERT((IDX_MASK(MICROPY_SCHEDULER_DEPTH) == 0));

    return mp_sched_num_pending() == 0;
}

static inline void mp_sched_run_pending(void) {
   
    mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
    if (MP_STATE_VM(sched_state) != MP_SCHED_PENDING) {
   
        // 其他事务（例如硬件中断）在我们获取锁的时候锁定了调度器。
        MICROPY_END_ATOMIC_SECTION(atomic_state);
        return;
    }

    // 相当于 mp_sched_lock()，但我们已经在原子部分，并且知道我们正在挂起。
    MP_STATE_VM(sched_state) = MP_SCHED_LOCKED;

    #if MICROPY_SCHEDULER_STATIC_NODES
    // 运行所有挂起的 C 回调。
    while (MP_STATE_VM(sched_head) != NULL) {
   
        mp_sched_node_t *node = MP_STATE_VM(sched_head);
        MP_STATE_VM(sched_head) = node->next;
        if (MP_STATE_VM(sched_head) == NULL) {
   
            MP_STATE_VM(sched_tail) = NULL;
        }
        mp_sched_callback_t callback = node->callback;
        node->callback = NULL;
        MICROPY_END_ATOMIC_SECTION(atomic_state);
        callback(node);
        atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
    }
    #endif

    // 运行至多一个挂起的 Python 回调。
    if (!mp_sched_empty()) {
   
        mp_sched_item_t item = MP_STATE_VM(sched_queue)[MP_STATE_VM(sched_idx)];
        MP_STATE_VM(sched_idx) = IDX_MASK(MP_STATE_VM(sched_idx) + 1);
        --MP_STATE_VM(sched_len);
        MICROPY_END_ATOMIC_SECTION(atomic_state);
        mp_call_function_1_protected(item.func, item.arg);
    } else {
   
        MICROPY_END_ATOMIC_SECTION(atomic_state);
    }

    // 恢复 MP_STATE_VM(sched_state) 到空闲状态（或者如果队列中仍有任务，则设置为挂起）。
    mp_sched_unlock();
}

// 锁定调度器阻止任务执行（不阻止添加新任务）。我们在执行调度任务时锁定调度器，也在硬件中断或GC最终释放器中锁定。
void mp_sched_lock(void) {
   
    mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
    if (MP_STATE_VM(sched_state) < 0) {
   
        // 已经锁定，递增锁（递归锁定）。
        --MP_STATE_VM(sched_state);
    } else {
   
        // 挂起或空闲。
        MP_STATE_VM(sched_state) = MP_SCHED_LOCKED;
    }
    MICROPY_END_ATOMIC_SECTION(atomic_state);
}

void mp_sched_unlock(void) {
   
    mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
    assert(MP_STATE_VM(sched_state) < 0);
    if (++MP_STATE_VM(sched_state) == 0) {