amos 63bdf4c8bb Add 3 HARD tasks from batch 28: RT-Thread mutex ceilings, LVGL repeat, soft timers
Batch 28 commit ca63702 gave RT-Thread mutex priority ceilings (1 of 3
passed), LVGL repeat cadence and RT-Thread soft-timer wakeup (0 of 3) as
HARD. Each task comes from the commit Qwen measured, its digest matches,
and it is still present at the batch branch head.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 22:20:12 +08:00

146 lines
6.3 KiB
C

#define _XOPEN_SOURCE 700
#include <ucontext.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <rthw.h>
#include "controlled.h"
static struct rt_cpu cpu;
static struct rt_thread application;
static rt_thread_t worker;
static rt_tick_t now;
static ucontext_t driver_context, worker_context;
static unsigned char execution_stack[131072];
static rt_list_t ready;
static int in_worker, injecting, initialized, duplicate_ready, operations, interleavings;
static int capture;
static struct rt_spinlock *captured, *after_lock, *before_lock;
static void (*after_fn)(void *), (*before_fn)(void *);
static void *after_arg, *before_arg;
static rt_base_t irq;
static void budget(void) { if (++operations > 2000000) { fputs("port operation budget\n", stderr); exit(7); } }
static void interleave(void (*fn)(void *), void *arg)
{
rt_thread_t previous = cpu.current_thread;
int previous_in = in_worker;
cpu.current_thread = &application;
in_worker = 0; injecting = 1; interleavings++;
fn(arg);
injecting = 0; in_worker = previous_in; cpu.current_thread = previous;
}
struct rt_cpu *rt_cpu_self(void) { return &cpu; }
int rt_hw_cpu_id(void) { return 0; }
rt_base_t rt_hw_local_irq_disable(void) { rt_base_t saved = irq; irq = 1; return saved; }
void rt_hw_local_irq_enable(rt_base_t saved) { irq = saved; }
rt_base_t rt_cpus_lock(void) { return rt_hw_local_irq_disable(); }
void rt_cpus_unlock(rt_base_t saved) { rt_hw_local_irq_enable(saved); }
rt_bool_t rt_hw_interrupt_is_disabled(void) { return irq != 0; }
void rt_spin_lock_init(struct rt_spinlock *lock) { lock->lock = 0; }
rt_base_t rt_spin_lock_irqsave(struct rt_spinlock *lock)
{
budget();
if (capture) { capture = 0; captured = lock; }
if (!injecting && before_fn && lock == before_lock) {
void (*fn)(void *) = before_fn; void *arg = before_arg; before_fn = NULL;
interleave(fn, arg);
}
lock->lock++;
return rt_hw_local_irq_disable();
}
void rt_spin_unlock_irqrestore(struct rt_spinlock *lock, rt_base_t saved)
{
budget();
lock->lock--;
rt_hw_local_irq_enable(saved);
if (!injecting && after_fn && lock == after_lock) {
void (*fn)(void *) = after_fn; void *arg = after_arg; after_fn = NULL;
interleave(fn, arg);
}
}
void rt_spin_lock(struct rt_spinlock *lock) { (void)rt_spin_lock_irqsave(lock); }
void rt_spin_unlock(struct rt_spinlock *lock) { rt_spin_unlock_irqrestore(lock, 0); }
rt_tick_t rt_tick_get(void) { budget(); return now; }
void rt_object_init(struct rt_object *object, enum rt_object_class_type type, const char *name)
{
memset(object, 0, sizeof(*object));
strncpy(object->name, name, RT_NAME_MAX - 1);
object->type = type | RT_Object_Class_Static;
rt_list_init(&object->list);
}
rt_uint8_t rt_object_get_type(rt_object_t object) { return object->type & ~RT_Object_Class_Static; }
rt_bool_t rt_object_is_systemobject(rt_object_t object) { return !!(object->type & RT_Object_Class_Static); }
void rt_object_detach(rt_object_t object) { rt_list_remove(&object->list); }
rt_uint8_t *rt_hw_stack_init(void *entry, void *parameter, rt_uint8_t *stack, void *exit_fn)
{ (void)entry; (void)parameter; (void)exit_fn; return stack; }
void rt_thread_defunct_enqueue(rt_thread_t thread) { (void)thread; }
void rt_schedule_remove_thread(rt_thread_t thread) { rt_list_remove(&thread->tlist_schedule); }
void rt_schedule_insert_thread(rt_thread_t thread)
{
if (!rt_list_isempty(&thread->tlist_schedule)) duplicate_ready++;
else rt_list_insert_before(&ready, &thread->tlist_schedule);
thread->stat = (thread->stat & ~RT_THREAD_STAT_MASK) | RT_THREAD_READY;
if (strcmp(thread->parent.name, "timer") == 0) worker = thread;
}
void rt_schedule(void)
{
budget();
if (in_worker && ((worker->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK ||
(worker->stat & RT_THREAD_STAT_MASK) == RT_THREAD_CLOSE))
swapcontext(&worker_context, &driver_context);
else if (in_worker && (worker->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY) {
rt_list_remove(&worker->tlist_schedule);
worker->stat = (worker->stat & ~RT_THREAD_STAT_MASK) | RT_THREAD_RUNNING;
}
}
static void worker_entry(void)
{
((void (*)(void *))worker->entry)(worker->parameter);
worker->stat = RT_THREAD_CLOSE;
swapcontext(&worker_context, &driver_context);
}
void port_init(rt_tick_t tick)
{
now = tick; rt_list_init(&ready);
rt_object_init(&application.parent, RT_Object_Class_Thread, "application");
application.stat = RT_THREAD_RUNNING; cpu.current_thread = &application;
rt_system_timer_init(); rt_system_timer_thread_init();
}
void port_pump(void)
{
if (!worker || (worker->stat & RT_THREAD_STAT_MASK) != RT_THREAD_READY) return;
if (!initialized) {
initialized = 1; getcontext(&worker_context);
worker_context.uc_stack.ss_sp = execution_stack;
worker_context.uc_stack.ss_size = sizeof(execution_stack);
worker_context.uc_link = &driver_context;
makecontext(&worker_context, worker_entry, 0);
}
rt_list_remove(&worker->tlist_schedule);
worker->stat = (worker->stat & ~RT_THREAD_STAT_MASK) | RT_THREAD_RUNNING;
cpu.current_thread = worker; in_worker = 1;
swapcontext(&driver_context, &worker_context);
in_worker = 0; cpu.current_thread = &application;
}
void port_advance(rt_tick_t tick) { now = tick; rt_timer_check(); port_pump(); }
rt_thread_t port_worker(void) { return worker; }
void port_capture_lock(void) { captured = NULL; capture = 1; }
struct rt_spinlock *port_captured_lock(void) { return captured; }
void port_after_unlock(struct rt_spinlock *lock, void (*fn)(void *), void *arg)
{ after_lock = lock; after_fn = fn; after_arg = arg; }
void port_before_lock(struct rt_spinlock *lock, void (*fn)(void *), void *arg)
{ before_lock = lock; before_fn = fn; before_arg = arg; }
int port_duplicate_ready(void) { return duplicate_ready; }
int port_ready_count(rt_thread_t thread)
{
int count = 0; rt_list_t *p;
for (p = ready.next; p != &ready && count < 100; p = p->next)
if (p == &thread->tlist_schedule) count++;
return count;
}
int port_interleavings(void) { return interleavings; }
void rt_assert_handler(const char *ex, const char *func, rt_size_t line)
{ fprintf(stderr, "assert:%s:%s:%lu\n", ex, func, (unsigned long)line); exit(8); }
void *rt_memset(void *s, int c, rt_ubase_t count) { return memset(s, c, count); }