#if HAS_STACK_GUARD
#include <ao_mpu.h>
#endif
+#include <picotls.h>
#define DEBUG 0
static struct ao_list run_queue;
static struct ao_list alarm_queue;
-static struct ao_list sleep_queue[SLEEP_HASH_SIZE];
+static struct ao_list ao_sleep_queue[SLEEP_HASH_SIZE];
static void
ao_task_to_run_queue(struct ao_task *task)
static struct ao_list *
ao_task_sleep_queue(void *wchan)
{
- return &sleep_queue[(uintptr_t) wchan % SLEEP_HASH_SIZE];
+ return &ao_sleep_queue[(uintptr_t) wchan % SLEEP_HASH_SIZE];
}
static void
#define ao_task_validate_alarm_queue()
#endif
-uint16_t ao_task_alarm_tick;
+AO_TICK_TYPE ao_task_alarm_tick;
static void
ao_task_to_alarm_queue(struct ao_task *task)
}
void
-ao_task_check_alarm(uint16_t tick)
+ao_task_check_alarm(AO_TICK_TYPE tick)
{
struct ao_task *alarm, *next;
ao_list_init(&alarm_queue);
ao_task_alarm_tick = 0;
for (i = 0; i < SLEEP_HASH_SIZE; i++)
- ao_list_init(&sleep_queue[i]);
+ ao_list_init(&ao_sleep_queue[i]);
}
#if DEBUG
#endif /* HAS_TASK_QUEUE */
+static inline void *
+ao_stack_top(struct ao_task *task)
+{
+ uint8_t *top = &task->stack8[AO_STACK_SIZE];
+
+ /* Subtract off the TLS space, but keep the resulting
+ * stack 8-byte aligned
+ */
+#if USE_TLS
+ return top - ((_tls_size() + 7) & ~3);
+#else
+ return top;
+#endif
+}
+
void
-ao_add_task(struct ao_task * task, void (*start)(void), const char *name)
+ao_add_task(struct ao_task * task, void (*task_func)(void), const char *name)
{
uint8_t task_id;
uint8_t t;
* Construct a stack frame so that it will 'return'
* to the start of the task
*/
- ao_arch_init_stack(task, start);
+ uint32_t *sp = ao_stack_top(task);
+#if USE_TLS
+ _init_tls(sp);
+#endif
+ ao_arch_init_stack(task, sp, task_func);
ao_arch_critical(
#if HAS_TASK_QUEUE
ao_task_init_queue(task);
else
{
#if HAS_SAMPLE_PROFILE
- uint16_t tick = ao_sample_profile_timer_value();
- uint16_t run = tick - ao_cur_task->start;
+ AO_TICK_TYPE tick = ao_sample_profile_timer_value();
+ AO_TICK_TYPE run = tick - ao_cur_task->start;
if (run > ao_cur_task->max_run)
ao_cur_task->max_run = run;
++ao_cur_task->yields;
#endif
#if AO_CHECK_STACK
in_yield = 0;
+#endif
+#if USE_TLS
+ _set_tls(ao_stack_top(ao_cur_task));
#endif
ao_arch_restore_stack();
}
}
uint8_t
-ao_sleep_for(void *wchan, uint16_t timeout)
+ao_sleep_for(void *wchan, AO_TICK_TYPE timeout)
{
uint8_t ret;
if (timeout) {
static uint8_t ao_forever;
void
-ao_delay(uint16_t ticks)
+ao_delay(AO_TICK_TYPE ticks)
{
if (!ticks)
ticks = 1;
{
uint8_t i;
struct ao_task *task;
- uint16_t now = ao_time();
+ AO_TICK_TYPE now = ao_time();
for (i = 0; i < ao_num_tasks; i++) {
task = ao_tasks[i];