Batch 28 commit b7fd210 gave ESP NVS iterator versions and RT-Thread workqueue timer state as HARD: all 3 attempts of each ran out of model context, which counts as a failure. 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>
105 lines
6.0 KiB
C
105 lines
6.0 KiB
C
/* SPDX-License-Identifier: Apache-2.0
|
|
* Deterministic single-CPU platform: contexts, interrupt masking, IPC and objects.
|
|
*/
|
|
#define _XOPEN_SOURCE 700
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ucontext.h>
|
|
#include <rtthread.h>
|
|
#include <rthw.h>
|
|
#include "port.h"
|
|
#define THREADS 16
|
|
struct host_thread {
|
|
rt_thread_t thread;
|
|
ucontext_t ctx;
|
|
char stack[131072];
|
|
void (*entry)(void *);
|
|
void *arg;
|
|
int ready, dead, masked, critical;
|
|
rt_sem_t wait;
|
|
rt_tick_t wake;
|
|
int finite, result;
|
|
};
|
|
static struct host_thread threads[THREADS];
|
|
static int count, current=-1, main_mask, main_critical;
|
|
static ucontext_t supervisor;
|
|
static rt_tick_t ticks;
|
|
void (*rt_object_take_hook)(struct rt_object *);
|
|
void (*rt_object_put_hook)(struct rt_object *);
|
|
static struct host_thread *find(rt_thread_t t) {
|
|
int i; for(i=0;i<count;i++) if(threads[i].thread==t) return &threads[i];
|
|
fputs("unknown thread\n",stderr);exit(70);
|
|
}
|
|
static void yield(void) { if(current>=0) swapcontext(&threads[current].ctx,&supervisor); }
|
|
static void start(int i) { threads[i].entry(threads[i].arg);threads[i].dead=1;threads[i].ready=0;yield();abort(); }
|
|
void os_init(void) { count=0;current=-1;main_mask=main_critical=0;ticks=0; }
|
|
int os_step(const char *name) {
|
|
int i;
|
|
for(i=0;i<count;i++) if(threads[i].ready && !threads[i].dead && (!name || !strcmp(threads[i].thread->parent.name,name))) {
|
|
current=i;swapcontext(&supervisor,&threads[i].ctx);current=-1;return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
void os_drain(void) { int budget=10000;while(os_step(NULL)) if(--budget==0) {fputs("scheduler budget\n",stderr);exit(71);} }
|
|
void os_tick(rt_tick_t tick) {
|
|
int i;ticks=tick;
|
|
for(i=0;i<count;i++) if(threads[i].wait && threads[i].finite && (ticks-threads[i].wake)<RT_TICK_MAX/2) {
|
|
threads[i].wait=NULL;threads[i].ready=1;threads[i].result=-RT_ETIMEOUT;
|
|
}
|
|
}
|
|
rt_tick_t rt_tick_get(void) { return ticks; }
|
|
void rt_tick_set(rt_tick_t t) {os_tick(t);}
|
|
rt_base_t rt_hw_interrupt_disable(void) {int *p=current<0?&main_mask:&threads[current].masked;int old=*p;*p=1;return old;}
|
|
void rt_hw_interrupt_enable(rt_base_t level) {
|
|
int *p=current<0?&main_mask:&threads[current].masked;*p=(int)level;
|
|
if(current>=0 && !*p && !threads[current].critical) yield();
|
|
}
|
|
rt_base_t rt_enter_critical(void) {if(current<0)return main_critical++;return threads[current].critical++;}
|
|
void rt_exit_critical(void) {if(current<0)main_critical--;else threads[current].critical--;}
|
|
rt_uint8_t rt_interrupt_get_nest(void) {return 1;}
|
|
rt_err_t rt_sched_lock(rt_sched_lock_level_t *p) {*p=rt_hw_interrupt_disable();return RT_EOK;}
|
|
rt_err_t rt_sched_unlock(rt_sched_lock_level_t v) {rt_hw_interrupt_enable(v);return RT_EOK;}
|
|
rt_err_t rt_sched_thread_timer_start(rt_thread_t t) {(void)t;return RT_EOK;}
|
|
void rt_schedule(void) {yield();}
|
|
rt_thread_t rt_thread_self(void) {return current<0?NULL:threads[current].thread;}
|
|
rt_err_t rt_thread_init(rt_thread_t t,const char *name,void (*entry)(void *),void *arg,void *stack,rt_uint32_t size,rt_uint8_t priority,rt_uint32_t tick) {
|
|
struct host_thread *h;
|
|
(void)stack;(void)size;(void)priority;(void)tick;
|
|
if(count==THREADS)return -RT_ERROR;
|
|
h=&threads[count];memset(h,0,sizeof(*h));h->thread=t;h->entry=entry;h->arg=arg;
|
|
rt_object_init(&t->parent,RT_Object_Class_Thread,name);
|
|
getcontext(&h->ctx);h->ctx.uc_stack.ss_sp=h->stack;h->ctx.uc_stack.ss_size=sizeof(h->stack);h->ctx.uc_link=&supervisor;
|
|
makecontext(&h->ctx,(void (*)(void))start,1,count++);return RT_EOK;
|
|
}
|
|
rt_thread_t rt_thread_create(const char *n,void (*e)(void *),void *a,rt_uint32_t s,rt_uint8_t p,rt_uint32_t t) {
|
|
rt_thread_t thread=calloc(1,sizeof(*thread));if(thread)rt_thread_init(thread,n,e,a,NULL,s,p,t);return thread;
|
|
}
|
|
rt_err_t rt_thread_startup(rt_thread_t t) {find(t)->ready=1;return RT_EOK;}
|
|
rt_err_t rt_thread_resume(rt_thread_t t) {find(t)->ready=1;return RT_EOK;}
|
|
rt_err_t rt_thread_suspend_with_flag(rt_thread_t t,int flag) {(void)flag;find(t)->ready=0;return RT_EOK;}
|
|
rt_err_t rt_thread_delete(rt_thread_t t) {find(t)->dead=1;find(t)->ready=0;return RT_EOK;}
|
|
rt_err_t rt_sem_init(rt_sem_t s,const char *n,rt_uint32_t value,rt_uint8_t flag) {rt_object_init(&s->parent.parent,RT_Object_Class_Semaphore,n);s->value=value;s->max_value=RT_SEM_VALUE_MAX;(void)flag;return RT_EOK;}
|
|
rt_err_t rt_sem_detach(rt_sem_t s) {(void)s;return RT_EOK;}
|
|
rt_err_t rt_sem_trytake(rt_sem_t s) {if(!s->value)return -RT_ETIMEOUT;s->value--;return RT_EOK;}
|
|
rt_err_t rt_sem_take(rt_sem_t s,rt_int32_t timeout) {
|
|
struct host_thread *h;
|
|
if(s->value){s->value--;return RT_EOK;}if(!timeout)return -RT_ETIMEOUT;
|
|
if(current<0){fputs("main blocked\n",stderr);exit(72);}
|
|
h=&threads[current];h->wait=s;h->ready=0;h->finite=timeout>0;h->wake=ticks+(rt_tick_t)timeout;yield();return h->result;
|
|
}
|
|
rt_err_t rt_sem_release(rt_sem_t s) {
|
|
int i;for(i=0;i<count;i++)if(threads[i].wait==s){threads[i].wait=NULL;threads[i].ready=1;threads[i].result=RT_EOK;return RT_EOK;}
|
|
if(s->value<s->max_value)s->value++;return RT_EOK;
|
|
}
|
|
rt_err_t rt_sem_control(rt_sem_t s,int cmd,void *arg) {if(cmd==RT_IPC_CMD_SET_VLIMIT)s->max_value=(rt_ubase_t)arg;return RT_EOK;}
|
|
void rt_object_init(rt_object_t o,enum rt_object_class_type type,const char *name) {memset(o,0,sizeof(*o));o->type=type|RT_Object_Class_Static;strncpy(o->name,name,RT_NAME_MAX-1);rt_list_init(&o->list);}
|
|
void rt_object_detach(rt_object_t o) {o->type=RT_Object_Class_Null;}
|
|
rt_uint8_t rt_object_get_type(rt_object_t o) {return o->type&~RT_Object_Class_Static;}
|
|
rt_bool_t rt_object_is_systemobject(rt_object_t o) {return !!(o->type&RT_Object_Class_Static);}
|
|
rt_object_t rt_object_allocate(enum rt_object_class_type type,const char *name) {rt_object_t o=calloc(1,sizeof(struct rt_timer));if(o){rt_object_init(o,type,name);o->type=type;}return o;}
|
|
void rt_object_delete(rt_object_t o) {free(o);}
|
|
void *rt_malloc(rt_size_t size) {return calloc(1,size);}
|
|
void rt_free(void *p) {free(p);}
|
|
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(73);}
|