You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
177 lines
6.7 KiB
177 lines
6.7 KiB
// Copyright 2021 Nick Brassel (@tzarc)
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <stddef.h>
|
|
#include <timer.h>
|
|
#include <deferred_exec.h>
|
|
|
|
#ifndef MAX_DEFERRED_EXECUTORS
|
|
# define MAX_DEFERRED_EXECUTORS 8
|
|
#endif
|
|
|
|
//------------------------------------
|
|
// Helpers
|
|
//
|
|
|
|
static deferred_token current_token = 0;
|
|
|
|
static inline bool token_can_be_used(deferred_executor_t *table, size_t table_count, deferred_token token) {
|
|
if (token == INVALID_DEFERRED_TOKEN) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < table_count; ++i) {
|
|
if (table[i].token == token) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static inline deferred_token allocate_token(deferred_executor_t *table, size_t table_count) {
|
|
deferred_token first = ++current_token;
|
|
while (!token_can_be_used(table, table_count, current_token)) {
|
|
++current_token;
|
|
if (current_token == first) {
|
|
// If we've looped back around to the first, everything is already allocated (yikes!). Need to exit with a failure.
|
|
return INVALID_DEFERRED_TOKEN;
|
|
}
|
|
}
|
|
return current_token;
|
|
}
|
|
|
|
//------------------------------------
|
|
// Advanced API: used when a custom-allocated table is used, primarily for core code.
|
|
//
|
|
|
|
deferred_token defer_exec_advanced(deferred_executor_t *table, size_t table_count, uint32_t delay_ms, deferred_exec_callback callback, void *cb_arg) {
|
|
// Ignore queueing if the table isn't valid, it's a zero-time delay, or the token is not valid
|
|
if (!table || table_count == 0 || delay_ms == 0 || !callback) {
|
|
return INVALID_DEFERRED_TOKEN;
|
|
}
|
|
|
|
// Find an unused slot and claim it
|
|
for (int i = 0; i < table_count; ++i) {
|
|
deferred_executor_t *entry = &table[i];
|
|
if (entry->token == INVALID_DEFERRED_TOKEN) {
|
|
// Work out the new token value, dropping out if none were available
|
|
deferred_token token = allocate_token(table, table_count);
|
|
if (token == INVALID_DEFERRED_TOKEN) {
|
|
return false;
|
|
}
|
|
|
|
// Set up the executor table entry
|
|
entry->token = current_token;
|
|
entry->trigger_time = timer_read32() + delay_ms;
|
|
entry->callback = callback;
|
|
entry->cb_arg = cb_arg;
|
|
return current_token;
|
|
}
|
|
}
|
|
|
|
// None available
|
|
return INVALID_DEFERRED_TOKEN;
|
|
}
|
|
|
|
bool extend_deferred_exec_advanced(deferred_executor_t *table, size_t table_count, deferred_token token, uint32_t delay_ms) {
|
|
// Ignore queueing if the table isn't valid, it's a zero-time delay, or the token is not valid
|
|
if (!table || table_count == 0 || delay_ms == 0 || token == INVALID_DEFERRED_TOKEN) {
|
|
return false;
|
|
}
|
|
|
|
// Find the entry corresponding to the token
|
|
for (int i = 0; i < table_count; ++i) {
|
|
deferred_executor_t *entry = &table[i];
|
|
if (entry->token == token) {
|
|
// Found it, extend the delay
|
|
entry->trigger_time = timer_read32() + delay_ms;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Not found
|
|
return false;
|
|
}
|
|
|
|
bool cancel_deferred_exec_advanced(deferred_executor_t *table, size_t table_count, deferred_token token) {
|
|
// Ignore request if the table/token are not valid
|
|
if (!table || table_count == 0 || token == INVALID_DEFERRED_TOKEN) {
|
|
return false;
|
|
}
|
|
|
|
// Find the entry corresponding to the token
|
|
for (int i = 0; i < table_count; ++i) {
|
|
deferred_executor_t *entry = &table[i];
|
|
if (entry->token == token) {
|
|
// Found it, cancel and clear the table entry
|
|
entry->token = INVALID_DEFERRED_TOKEN;
|
|
entry->trigger_time = 0;
|
|
entry->callback = NULL;
|
|
entry->cb_arg = NULL;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Not found
|
|
return false;
|
|
}
|
|
|
|
void deferred_exec_advanced_task(deferred_executor_t *table, size_t table_count, uint32_t *last_execution_time) {
|
|
uint32_t now = timer_read32();
|
|
|
|
// Throttle only once per millisecond
|
|
if (((int32_t)TIMER_DIFF_32(now, (*last_execution_time))) > 0) {
|
|
*last_execution_time = now;
|
|
|
|
// Run through each of the executors
|
|
for (int i = 0; i < table_count; ++i) {
|
|
deferred_executor_t *entry = &table[i];
|
|
deferred_token curr_token = entry->token;
|
|
|
|
// Check if we're supposed to execute this entry
|
|
if (curr_token != INVALID_DEFERRED_TOKEN && ((int32_t)TIMER_DIFF_32(entry->trigger_time, now)) <= 0) {
|
|
// Invoke the callback and work work out if we should be requeued
|
|
uint32_t delay_ms = entry->callback(entry->trigger_time, entry->cb_arg);
|
|
|
|
// If the token has changed, then the callback has canceled and re-queued. Skip further processing.
|
|
if (entry->token != curr_token) {
|
|
continue;
|
|
}
|
|
|
|
// Update the trigger time if we have to repeat, otherwise clear it out
|
|
if (delay_ms > 0) {
|
|
// Intentionally add just the delay to the existing trigger time -- this ensures the next
|
|
// invocation is with respect to the previous trigger, rather than when it got to execution. Under
|
|
// normal circumstances this won't cause issue, but if another executor is invoked that takes a
|
|
// considerable length of time, then this ensures best-effort timing between invocations.
|
|
entry->trigger_time += delay_ms;
|
|
} else {
|
|
// If it was zero, then the callback is cancelling repeated execution. Free up the slot.
|
|
entry->token = INVALID_DEFERRED_TOKEN;
|
|
entry->trigger_time = 0;
|
|
entry->callback = NULL;
|
|
entry->cb_arg = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------
|
|
// Basic API: used by user-mode code, guaranteed to not collide with core deferred execution
|
|
//
|
|
|
|
static uint32_t last_deferred_exec_check = 0;
|
|
static deferred_executor_t basic_executors[MAX_DEFERRED_EXECUTORS] = {0};
|
|
|
|
deferred_token defer_exec(uint32_t delay_ms, deferred_exec_callback callback, void *cb_arg) {
|
|
return defer_exec_advanced(basic_executors, MAX_DEFERRED_EXECUTORS, delay_ms, callback, cb_arg);
|
|
}
|
|
bool extend_deferred_exec(deferred_token token, uint32_t delay_ms) {
|
|
return extend_deferred_exec_advanced(basic_executors, MAX_DEFERRED_EXECUTORS, token, delay_ms);
|
|
}
|
|
bool cancel_deferred_exec(deferred_token token) {
|
|
return cancel_deferred_exec_advanced(basic_executors, MAX_DEFERRED_EXECUTORS, token);
|
|
}
|
|
void deferred_exec_task(void) {
|
|
deferred_exec_advanced_task(basic_executors, MAX_DEFERRED_EXECUTORS, &last_deferred_exec_check);
|
|
}
|