/* ---------------------------- Definitions --------------------------------- */
#ifdef CONFIG_EVENT_LOOP_PROFILING
-// loop@<address,name> rx:<total_recieved> dr:<total_dropped> inv:<total_number_of_invocations> run:<total_runtime>
-#define LOOP_DUMP_FORMAT "loop@%p,%s rx:%u dr:%u inv:%u run:%lld us\n"
-// event@<base:id> proc:<total_processed> run:<total_runtime>
-#define EVENT_DUMP_FORMAT "\tevent@%s:%d proc:%u run:%lld us\n"
- // handler@<address> inv:<total_invoked> run:<total_runtime>
-#define HANDLER_DUMP_FORMAT "\t\thandler@%p inv:%u run:%lld us\n"
+// LOOP @<address, name> rx:<recieved events no.> dr:<dropped events no.>
+#define LOOP_DUMP_FORMAT "LOOP @%p,%s rx:%u dr:%u\n"
+ // handler @<address> ev:<base, id> inv:<times invoked> time:<runtime>
+#define HANDLER_DUMP_FORMAT " HANDLER @%p ev:%s,%s inv:%u time:%lld us\n"
#define PRINT_DUMP_INFO(dst, sz, ...) do { \
int cb = snprintf(dst, sz, __VA_ARGS__); \
static int esp_event_dump_prepare()
{
esp_event_loop_instance_t* loop_it;
- esp_event_base_instance_t* base_it;
- esp_event_id_instance_t* id_it;
+ esp_event_loop_node_t *loop_node_it;
+ esp_event_base_node_t* base_node_it;
+ esp_event_id_node_t* id_node_it;
esp_event_handler_instance_t* handler_it;
// Count the number of items to be printed. This is needed to compute how much memory to reserve.
- int loops = 0, events = 0, handlers = 0;
+ int loops = 0, handlers = 0;
portENTER_CRITICAL(&s_event_loops_spinlock);
- SLIST_FOREACH(loop_it, &s_event_loops, loop_entry) {
- SLIST_FOREACH(handler_it, &(loop_it->loop_handlers), handler_entry) {
- handlers++;
- }
- SLIST_FOREACH(base_it, &(loop_it->event_bases), event_base_entry) {
- SLIST_FOREACH(handler_it, &(base_it->base_handlers), handler_entry) {
+ SLIST_FOREACH(loop_it, &s_event_loops, next) {
+ SLIST_FOREACH(loop_node_it, &(loop_it->loop_nodes), next) {
+ SLIST_FOREACH(handler_it, &(loop_node_it->handlers), next) {
handlers++;
}
- // Print event-level handlers
- SLIST_FOREACH(id_it, &(base_it->event_ids), event_id_entry) {
- SLIST_FOREACH(handler_it, &(id_it->handlers), handler_entry) {
+
+ SLIST_FOREACH(base_node_it, &(loop_node_it->base_nodes), next) {
+ SLIST_FOREACH(handler_it, &(base_node_it->handlers), next) {
handlers++;
}
- events++;
+ SLIST_FOREACH(id_node_it, &(base_node_it->id_nodes), next) {
+ SLIST_FOREACH(handler_it, &(id_node_it->handlers), next) {
+ handlers++;
+ }
+ }
}
- events++;
}
- events++;
loops++;
}
// Reserve slightly more memory than computed
int allowance = 3;
- int size = (((loops + allowance) * (sizeof(LOOP_DUMP_FORMAT) + 10 + 20 + 3 * 11 + 20 )) +
- ((events + allowance) * (sizeof(EVENT_DUMP_FORMAT) + 10 + 20 + 11 + 20)) +
- ((handlers + allowance) * (sizeof(HANDLER_DUMP_FORMAT) + 10 + 11 + 20)));
+ int size = (((loops + allowance) * (sizeof(LOOP_DUMP_FORMAT) + 10 + 20 + 2 * 11)) +
+ ((handlers + allowance) * (sizeof(HANDLER_DUMP_FORMAT) + 10 + 2 * 20 + 11 + 20)));
return size;
}
vTaskSuspend(NULL);
}
-// Functions that operate on handler instance
-static esp_event_handler_instance_t* handler_instance_create(esp_event_handler_t event_handler, void* event_handler_arg)
+static void handler_execute(esp_event_loop_instance_t* loop, esp_event_handler_instance_t *handler, esp_event_post_instance_t post)
{
- esp_event_handler_instance_t* handler_instance = calloc(1, sizeof(*handler_instance));
+ ESP_LOGD(TAG, "running post %s:%d with handler %p on loop %p", post.base, post.id, handler->handler, loop);
- if (handler_instance != NULL) {
- handler_instance->handler = event_handler;
- handler_instance->arg = event_handler_arg;
- }
+#ifdef CONFIG_EVENT_LOOP_PROFILING
+ int64_t start, diff;
+ start = esp_timer_get_time();
+#endif
+ // Execute the handler
+ (*(handler->handler))(handler->arg, post.base, post.id, post.data);
- return handler_instance;
-}
+#ifdef CONFIG_EVENT_LOOP_PROFILING
+ diff = esp_timer_get_time() - start;
-static void handler_instance_delete(esp_event_handler_instance_t* handler_instance)
-{
- free(handler_instance);
+ xSemaphoreTake(loop->profiling_mutex, portMAX_DELAY);
+
+ handler->invoked++;
+ handler->time += diff;
+
+ xSemaphoreGive(loop->profiling_mutex);
+#endif
}
-// Functions that operate on handler instance list
-static esp_event_handler_instance_t* handler_instances_find(esp_event_handler_instances_t* handlers, esp_event_handler_t handler)
+static esp_err_t handler_instances_add(esp_event_handler_instances_t* handlers, esp_event_handler_t handler, void* handler_arg)
{
- esp_event_handler_instance_t* it;
+ esp_event_handler_instance_t* handler_instance = calloc(1, sizeof(*handler_instance));
- SLIST_FOREACH(it, handlers, handler_entry) {
- if (it->handler == handler) {
- break;
+ if (!handler_instance) {
+ return ESP_ERR_NO_MEM;
+ }
+
+ handler_instance->handler = handler;
+ handler_instance->arg = handler_arg;
+
+ if(SLIST_EMPTY(handlers)) {
+ SLIST_INSERT_HEAD(handlers, handler_instance, next);
+ }
+ else {
+ esp_event_handler_instance_t *it = NULL, *last = NULL;
+
+ SLIST_FOREACH(it, handlers, next) {
+ if (handler == it->handler) {
+ it->arg = handler_arg;
+ ESP_LOGW(TAG, "handler already registered, overwriting");
+ return ESP_OK;
+ }
+ last = it;
}
+
+ SLIST_INSERT_AFTER(last, handler_instance, next);
}
- return it;
+ return ESP_OK;
}
-static void handler_instances_add(esp_event_handler_instances_t* handlers, esp_event_handler_instance_t* handler_instance)
+static esp_err_t base_node_add_handler(esp_event_base_node_t* base_node, int32_t id, esp_event_handler_t handler, void* handler_arg)
{
- SLIST_INSERT_HEAD(handlers, handler_instance, handler_entry);
-}
+ if (id == ESP_EVENT_ANY_ID) {
+ return handler_instances_add(&(base_node->handlers), handler, handler_arg);
+ }
+ else {
+ esp_err_t err = ESP_OK;
+ esp_event_id_node_t *it = NULL, *id_node = NULL, *last_id_node = NULL;
-static void handler_instances_remove(esp_event_handler_instances_t* handlers, esp_event_handler_instance_t* handler_instance)
-{
- SLIST_REMOVE(handlers, handler_instance, esp_event_handler_instance, handler_entry);
- handler_instance_delete(handler_instance);
-}
+ SLIST_FOREACH(it, &(base_node->id_nodes), next) {
+ if (it->id == id) {
+ id_node = it;
+ }
+ last_id_node = it;
+ }
-static void handler_instances_remove_all(esp_event_handler_instances_t* handlers)
-{
- esp_event_handler_instance_t* it;
- esp_event_handler_instance_t* temp;
+ if (!last_id_node || !id_node) {
+ id_node = (esp_event_id_node_t*) calloc(1, sizeof(*id_node));
+
+ if (!id_node) {
+ ESP_LOGI(TAG, "alloc for new id node failed");
+ return ESP_ERR_NO_MEM;
+ }
+
+ id_node->id = id;
+
+ SLIST_INIT(&(id_node->handlers));
+
+ err = handler_instances_add(&(id_node->handlers), handler, handler_arg);
- SLIST_FOREACH_SAFE(it, handlers, handler_entry, temp) {
- handler_instances_remove(handlers, it);
+ if (err == ESP_OK) {
+ if (!last_id_node) {
+ SLIST_INSERT_HEAD(&(base_node->id_nodes), id_node, next);
+ }
+ else {
+ SLIST_INSERT_AFTER(last_id_node, id_node, next);
+ }
+ }
+
+ return err;
+ }
+ else {
+ return handler_instances_add(&(id_node->handlers), handler, handler_arg);
+ }
}
}
-// Functions that operate on event id instance
-static void* event_id_instance_create(int32_t event_id)
+static esp_err_t loop_node_add_handler(esp_event_loop_node_t* loop_node, esp_event_base_t base, int32_t id, esp_event_handler_t handler, void* handler_arg)
{
- esp_event_id_instance_t* event_id_instance = calloc(1, sizeof(*event_id_instance));
-
- if (event_id_instance != NULL) {
- event_id_instance->id = event_id;
- SLIST_INIT(&(event_id_instance->handlers));
+ if (base == esp_event_any_base && id == ESP_EVENT_ANY_ID) {
+ return handler_instances_add(&(loop_node->handlers), handler, handler_arg);
}
+ else {
+ esp_err_t err = ESP_OK;
+ esp_event_base_node_t *it = NULL, *base_node = NULL, *last_base_node = NULL;
- return event_id_instance;
-}
+ SLIST_FOREACH(it, &(loop_node->base_nodes), next) {
+ if (it->base == base) {
+ base_node = it;
+ }
+ last_base_node = it;
+ }
-static void event_id_instance_delete(esp_event_id_instance_t* event_id_instance)
-{
- handler_instances_remove_all(&(event_id_instance->handlers));
- free(event_id_instance);
-}
+ if (!last_base_node ||
+ !base_node ||
+ (base_node && !SLIST_EMPTY(&(base_node->id_nodes)) && id == ESP_EVENT_ANY_ID) ||
+ (last_base_node && last_base_node->base != base && !SLIST_EMPTY(&(last_base_node->id_nodes)) && id == ESP_EVENT_ANY_ID)) {
+ base_node = (esp_event_base_node_t*) calloc(1, sizeof(*base_node));
-// Functions that operate on event id instance list
-static void event_id_instances_remove(esp_event_id_instances_t* head, esp_event_id_instance_t* event_id_instance)
-{
- SLIST_REMOVE(head, event_id_instance, esp_event_id_instance, event_id_entry);
- event_id_instance_delete(event_id_instance);
-}
+ if (!base_node) {
+ ESP_LOGE(TAG, "alloc mem for new base node failed");
+ return ESP_ERR_NO_MEM;
+ }
-// Functions that operate on event base instance
-static esp_event_base_instance_t* event_base_instance_create(esp_event_base_t event_base)
-{
- esp_event_base_instance_t* event_base_instance = calloc(1, sizeof(*event_base_instance));
+ base_node->base = base;
- if (event_base_instance != NULL) {
- event_base_instance->base = event_base;
- SLIST_INIT(&(event_base_instance->base_handlers));
- SLIST_INIT(&(event_base_instance->event_ids));
- }
+ SLIST_INIT(&(base_node->handlers));
+ SLIST_INIT(&(base_node->id_nodes));
+
+ err = base_node_add_handler(base_node, id, handler, handler_arg);
- return event_base_instance;
+ if (err == ESP_OK) {
+ if (!last_base_node) {
+ SLIST_INSERT_HEAD(&(loop_node->base_nodes), base_node, next);
+ }
+ else {
+ SLIST_INSERT_AFTER(last_base_node, base_node, next);
+ }
+ }
+
+ return err;
+ } else {
+ return base_node_add_handler(base_node, id, handler, handler_arg);
+ }
+ }
}
-static void event_base_instance_delete(esp_event_base_instance_t* event_base_instance)
+static esp_err_t handler_instances_remove(esp_event_handler_instances_t* handlers, esp_event_handler_t handler)
{
- esp_event_id_instance_t* it;
- esp_event_id_instance_t* temp;
+ esp_event_handler_instance_t *it, *temp;
- handler_instances_remove_all(&(event_base_instance->base_handlers));
-
- SLIST_FOREACH_SAFE(it, &(event_base_instance->event_ids), event_id_entry, temp) {
- event_id_instances_remove(&(event_base_instance->event_ids), it);
+ SLIST_FOREACH_SAFE(it, handlers, next, temp) {
+ if (it->handler == handler) {
+ SLIST_REMOVE(handlers, it, esp_event_handler_instance, next);
+ free(it);
+ return ESP_OK;
+ }
}
- free(event_base_instance);
+ return ESP_ERR_NOT_FOUND;
}
-static void event_base_instance_add_event_id_instance(esp_event_base_instance_t* event_base_instance, esp_event_id_instance_t* event_id_instance)
-{
- SLIST_INSERT_HEAD(&(event_base_instance->event_ids), event_id_instance, event_id_entry);
-}
-static esp_event_id_instance_t* event_base_instance_find_event_id_instance(esp_event_base_instance_t* event_base_instance, int32_t event_id)
+static esp_err_t base_node_remove_handler(esp_event_base_node_t* base_node, int32_t id, esp_event_handler_t handler)
{
- esp_event_id_instance_t* it;
-
- SLIST_FOREACH(it, &(event_base_instance->event_ids), event_id_entry) {
- if (it->id == event_id) {
- break;
+ if (id == ESP_EVENT_ANY_ID) {
+ return handler_instances_remove(&(base_node->handlers), handler);
+ }
+ else {
+ esp_event_id_node_t *it, *temp;
+ SLIST_FOREACH_SAFE(it, &(base_node->id_nodes), next, temp) {
+ if (it->id == id) {
+ esp_err_t res = handler_instances_remove(&(it->handlers), handler);
+
+ if (res == ESP_OK) {
+ if (SLIST_EMPTY(&(it->handlers))) {
+ SLIST_REMOVE(&(base_node->id_nodes), it, esp_event_id_node, next);
+ free(it);
+ return ESP_OK;
+ }
+ }
+ }
}
}
- return it;
+ return ESP_ERR_NOT_FOUND;
}
-// Functions that operate on event base instances list
-static void event_base_instances_remove(esp_event_base_instances_t* head, esp_event_base_instance_t* event_base_instance)
+static esp_err_t loop_node_remove_handler(esp_event_loop_node_t* loop_node, esp_event_base_t base, int32_t id, esp_event_handler_t handler)
{
- SLIST_REMOVE(head, event_base_instance, esp_event_base_instance, event_base_entry);
- event_base_instance_delete(event_base_instance);
+ if (base == esp_event_any_base && id == ESP_EVENT_ANY_ID) {
+ return handler_instances_remove(&(loop_node->handlers), handler);
+ }
+ else {
+ esp_event_base_node_t *it, *temp;
+ SLIST_FOREACH_SAFE(it, &(loop_node->base_nodes), next, temp) {
+ if (it->base == base) {
+ esp_err_t res = base_node_remove_handler(it, id, handler);
+
+ if (res == ESP_OK) {
+ if (SLIST_EMPTY(&(it->handlers)) && SLIST_EMPTY(&(it->id_nodes))) {
+ SLIST_REMOVE(&(loop_node->base_nodes), it, esp_event_base_node, next);
+ free(it);
+ return ESP_OK;
+ }
+ }
+ }
+ }
+ }
+
+ return ESP_ERR_NOT_FOUND;
}
-// Functions that operate on loop instances
-static void loop_add_event_base_instance(esp_event_loop_instance_t* loop, esp_event_base_instance_t* event_base_instance) {
- SLIST_INSERT_HEAD(&(loop->event_bases), event_base_instance, event_base_entry);
+static void handler_instances_remove_all(esp_event_handler_instances_t* handlers)
+{
+ esp_event_handler_instance_t *it, *temp;
+ SLIST_FOREACH_SAFE(it, handlers, next, temp) {
+ SLIST_REMOVE(handlers, it, esp_event_handler_instance, next);
+ free(it);
+ }
}
-static void loop_remove_all_event_base_instance(esp_event_loop_instance_t* loop)
+static void base_node_remove_all_handler(esp_event_base_node_t* base_node)
{
- esp_event_base_instance_t* it;
- esp_event_base_instance_t* temp;
+ handler_instances_remove_all(&(base_node->handlers));
- SLIST_FOREACH_SAFE(it, &(loop->event_bases), event_base_entry, temp) {
- event_base_instances_remove(&(loop->event_bases), it);
+ esp_event_id_node_t *it, *temp;
+ SLIST_FOREACH_SAFE(it, &(base_node->id_nodes), next, temp) {
+ handler_instances_remove_all(&(it->handlers));
+ SLIST_REMOVE(&(base_node->id_nodes), it, esp_event_id_node, next);
+ free(it);
}
}
-static esp_event_base_instance_t* loop_find_event_base_instance(esp_event_loop_instance_t* loop, esp_event_base_t event_base)
+static void loop_node_remove_all_handler(esp_event_loop_node_t* loop_node)
{
- esp_event_base_instance_t* it;
+ handler_instances_remove_all(&(loop_node->handlers));
- SLIST_FOREACH(it, &(loop->event_bases), event_base_entry) {
- if (it->base == event_base) {
- break;
- }
+ esp_event_base_node_t *it, *temp;
+ SLIST_FOREACH_SAFE(it, &(loop_node->base_nodes), next, temp) {
+ base_node_remove_all_handler(it);
+ SLIST_REMOVE(&(loop_node->base_nodes), it, esp_event_base_node, next);
+ free(it);
}
-
- return it;
}
-// Functions that operate on post instance
static esp_err_t post_instance_create(esp_event_base_t event_base, int32_t event_id, void* event_data, int32_t event_data_size, esp_event_post_instance_t* post)
{
void* event_data_copy = NULL;
free(post->data);
}
-static esp_event_handler_instances_t* find_handlers_list(esp_event_loop_instance_t* loop, esp_event_base_t event_base,
- int32_t event_id)
-{
- esp_event_handler_instances_t* handlers = NULL;
-
- esp_event_base_instance_t* base = NULL;
- esp_event_id_instance_t* event = NULL;
-
- if (event_base == esp_event_any_base && event_id == ESP_EVENT_ANY_ID) {
- handlers = &(loop->loop_handlers);
- } else {
- base = loop_find_event_base_instance(loop, event_base);
- if (base != NULL) {
- if (event_id == ESP_EVENT_ANY_ID) {
- handlers = &(base->base_handlers);
- } else {
- event = event_base_instance_find_event_id_instance(base, event_id);
- if (event != NULL) {
- handlers = &(event->handlers);
- }
- }
- }
- }
-
- return handlers;
-}
-
/* ---------------------------- Public API --------------------------------- */
esp_err_t esp_event_loop_create(const esp_event_loop_args_t* event_loop_args, esp_event_loop_handle_t* event_loop)
}
#endif
- SLIST_INIT(&(loop->loop_handlers));
- SLIST_INIT(&(loop->event_bases));
+ SLIST_INIT(&(loop->loop_nodes));
// Create the loop task if requested
if (event_loop_args->task_name != NULL) {
#ifdef CONFIG_EVENT_LOOP_PROFILING
portENTER_CRITICAL(&s_event_loops_spinlock);
- SLIST_INSERT_HEAD(&s_event_loops, loop, loop_entry);
+ SLIST_INSERT_HEAD(&s_event_loops, loop, next);
portEXIT_CRITICAL(&s_event_loops_spinlock);
#endif
esp_event_post_instance_t post;
TickType_t marker = xTaskGetTickCount();
TickType_t end = 0;
- esp_event_handler_instance_t* temp;
#if( configUSE_16_BIT_TICKS == 1 )
int32_t remaining_ticks = ticks_to_run;
#endif
while(xQueueReceive(loop->queue, &post, ticks_to_run) == pdTRUE) {
- esp_event_base_instance_t* base = NULL;
- esp_event_id_instance_t* event = NULL;
-
- // Reserve space for three possible matches: (1) the entry for handlers registered to all events in the loop, the
- // (2) entry matching events with a specified base and (3) the entry matching both base and id.
- #define LOOP_LEVEL_HANDLER 0
- #define BASE_LEVEL_HANDLER 1
- #define EVENT_LEVEL_HANDLER 2
-
- esp_event_handler_instances_t* handlers_list[EVENT_LEVEL_HANDLER + 1] = {0};
-
// The event has already been unqueued, so ensure it gets executed.
xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY);
-
+
loop->running_task = xTaskGetCurrentTaskHandle();
-
- handlers_list[LOOP_LEVEL_HANDLER] = &(loop->loop_handlers);
-
- base = loop_find_event_base_instance(loop, post.base);
- if (base) {
- event = event_base_instance_find_event_id_instance(base, post.id);
- handlers_list[BASE_LEVEL_HANDLER] = &(base->base_handlers);
- if (event) {
- handlers_list[EVENT_LEVEL_HANDLER] = &(event->handlers);
- }
- }
bool exec = false;
- for (int i = LOOP_LEVEL_HANDLER; i <= EVENT_LEVEL_HANDLER; i++) {
- if (handlers_list[i] != NULL) {
- esp_event_handler_instance_t* it;
-
- SLIST_FOREACH_SAFE(it, handlers_list[i], handler_entry, temp) {
- ESP_LOGD(TAG, "running post %s:%d with handler %p on loop %p", post.base, post.id, it->handler, event_loop);
+ esp_event_handler_instance_t *handler;
+ esp_event_loop_node_t *loop_node;
+ esp_event_base_node_t *base_node;
+ esp_event_id_node_t *id_node;
-#ifdef CONFIG_EVENT_LOOP_PROFILING
- int64_t start, diff;
- start = esp_timer_get_time();
-#endif
- // Execute the handler
- (*(it->handler))(it->arg, post.base, post.id, post.data);
+ SLIST_FOREACH(loop_node, &(loop->loop_nodes), next) {
+ // Execute loop level handlers
+ SLIST_FOREACH(handler, &(loop_node->handlers), next) {
+ handler_execute(loop, handler, post);
+ exec |= true;
+ }
-#ifdef CONFIG_EVENT_LOOP_PROFILING
- diff = esp_timer_get_time() - start;
-
- xSemaphoreTake(loop->profiling_mutex, portMAX_DELAY);
-
- it->total_times_invoked++;
- it->total_runtime += diff;
-
- if (i == LOOP_LEVEL_HANDLER) {
- loop->loop_handlers_invoked++;
- loop->loop_handlers_runtime += diff;
- } else if (i == BASE_LEVEL_HANDLER) {
- base->base_handlers_invoked++;
- base->base_handlers_runtime += diff;
- } else {
- event->handlers_invoked++;
- event->handlers_runtime += diff;
+ SLIST_FOREACH(base_node, &(loop_node->base_nodes), next) {
+ if (base_node->base == post.base) {
+ // Execute base level handlers
+ SLIST_FOREACH(handler, &(base_node->handlers), next) {
+ handler_execute(loop, handler, post);
+ exec |= true;
}
- loop->total_handlers_invoked++;
- loop->total_handlers_runtime += diff;
-
- xSemaphoreGive(loop->profiling_mutex);
-#endif
+ SLIST_FOREACH(id_node, &(base_node->id_nodes), next) {
+ if(id_node->id == post.id) {
+ // Execute id level handlers
+ SLIST_FOREACH(handler, &(id_node->handlers), next) {
+ handler_execute(loop, handler, post);
+ exec |= true;
+ }
+ // Skip to next base node
+ break;
+ }
+ }
}
}
- exec |= true;
}
post_instance_delete(&post);
#ifdef CONFIG_EVENT_LOOP_PROFILING
xSemaphoreTakeRecursive(loop->profiling_mutex, portMAX_DELAY);
portENTER_CRITICAL(&s_event_loops_spinlock);
- SLIST_REMOVE(&s_event_loops, loop, esp_event_loop_instance, loop_entry);
+ SLIST_REMOVE(&s_event_loops, loop, esp_event_loop_instance, next);
portEXIT_CRITICAL(&s_event_loops_spinlock);
#endif
vTaskDelete(loop->task);
}
- // Remove all registered events in the loop
- handler_instances_remove_all(&(loop->loop_handlers));
- loop_remove_all_event_base_instance(loop);
+ // Remove all registered events and handlers in the loop
+ esp_event_loop_node_t *it, *temp;
+ SLIST_FOREACH_SAFE(it, &(loop->loop_nodes), next, temp) {
+ loop_node_remove_all_handler(it);
+ SLIST_REMOVE(&(loop->loop_nodes), it, esp_event_loop_node, next);
+ free(it);
+ }
// Drop existing posts on the queue
esp_event_post_instance_t post;
esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
- esp_event_base_instance_t* base = NULL;
- esp_event_id_instance_t* event = NULL;
- esp_event_handler_instance_t* handler = NULL;
- esp_event_handler_instances_t* handlers = NULL;
-
- bool base_created = false;
- bool event_created = false;
-
if (event_base == ESP_EVENT_ANY_BASE) {
event_base = esp_event_any_base;
}
+ esp_err_t err = ESP_OK;
+
xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY);
- if (event_base == esp_event_any_base && event_id == ESP_EVENT_ANY_ID) {
- // Add to the loop-level handlers
- handlers = &(loop->loop_handlers);
- } else {
- // If base instance does not exist, create one
- if ((base = loop_find_event_base_instance(loop, event_base)) == NULL) {
- base = event_base_instance_create(event_base);
- if (base == NULL) {
- xSemaphoreGiveRecursive(loop->mutex);
- return ESP_ERR_NO_MEM;
- }
- base_created = true;
- }
- // Add to the event base instance level handlers
- if (event_id == ESP_EVENT_ANY_ID) {
- handlers = &(base->base_handlers);
- } else {
- if (base_created ||
- (event = event_base_instance_find_event_id_instance(base, event_id)) == NULL) {
- event = event_id_instance_create(event_id);
- // If it does not exist, create one
- if (event == NULL) {
- if (base_created) {
- event_base_instance_delete(base);
- }
- xSemaphoreGiveRecursive(loop->mutex);
- return ESP_ERR_NO_MEM;
- }
- event_created = true;
- }
- // Add to the event id instance level handlers
- handlers = &(event->handlers);
- }
+ esp_event_loop_node_t *loop_node = NULL, *last_loop_node = NULL;
+
+ SLIST_FOREACH(loop_node, &(loop->loop_nodes), next) {
+ last_loop_node = loop_node;
}
- // Add handler to the list
- if (base_created || event_created ||
- (handler = handler_instances_find(handlers, event_handler)) == NULL) {
- handler = handler_instance_create(event_handler, event_handler_arg);
- if (handler == NULL) {
- if (event_created) {
- event_id_instance_delete(event);
+ bool is_loop_level_handler = (event_base == esp_event_any_base) && (event_id == ESP_EVENT_ANY_ID);
+
+ if (!last_loop_node ||
+ (last_loop_node && !SLIST_EMPTY(&(last_loop_node->base_nodes)) && is_loop_level_handler)) {
+ loop_node = (esp_event_loop_node_t*) calloc(1, sizeof(*loop_node));
+
+ SLIST_INIT(&(loop_node->handlers));
+ SLIST_INIT(&(loop_node->base_nodes));
+
+ if (!loop_node) {
+ ESP_LOGE(TAG, "alloc for new loop node failed");
+ err = ESP_ERR_NO_MEM;
+ goto on_err;
+ }
+
+ err = loop_node_add_handler(loop_node, event_base, event_id, event_handler, event_handler_arg);
+
+ if (err == ESP_OK) {
+ if (!last_loop_node) {
+ SLIST_INSERT_HEAD(&(loop->loop_nodes), loop_node, next);
}
- if (base_created) {
- event_base_instance_delete(base);
+ else {
+ SLIST_INSERT_AFTER(last_loop_node, loop_node, next);
}
- xSemaphoreGiveRecursive(loop->mutex);
- return ESP_ERR_NO_MEM;
- }
- handler_instances_add(handlers, handler);
- // If a new event base/ event id instance was created, add them to the appropriate list
- if (event_created) {
- event_base_instance_add_event_id_instance(base, event);
}
- if (base_created) {
- loop_add_event_base_instance(loop, base);
- }
- ESP_LOGD(TAG, "registered handler %p for event %s:%d", event_handler, event_base, event_id);
- } else {
- handler->arg = event_handler_arg;
- ESP_LOGW(TAG, "handler %p for event %s:%d already registered, overwriting", event_handler, event_base, event_id);
+ }
+ else {
+ err = loop_node_add_handler(last_loop_node, event_base, event_id, event_handler, event_handler_arg);
}
+on_err:
xSemaphoreGiveRecursive(loop->mutex);
-
- return ESP_OK;
+ return err;
}
-
esp_err_t esp_event_handler_unregister_with(esp_event_loop_handle_t event_loop, esp_event_base_t event_base,
int32_t event_id, esp_event_handler_t event_handler)
{
esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
- esp_event_handler_instance_t* handler = NULL;
- esp_event_handler_instances_t* handlers = find_handlers_list(loop, event_base, event_id);
-
xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY);
- if (handlers != NULL &&
- (handler = handler_instances_find(handlers, event_handler)) != NULL) {
- handler_instances_remove(handlers, handler);
- ESP_LOGD(TAG, "unregistered handler %p from event %s:%d", event_handler, event_base, event_id);
- } else {
- ESP_LOGW(TAG, "handler %p for event %s:%d not registered, ignoring", event_handler, event_base, event_id);
+ esp_event_loop_node_t *it, *temp;
+
+ SLIST_FOREACH_SAFE(it, &(loop->loop_nodes), next, temp) {
+ esp_err_t res = loop_node_remove_handler(it, event_base, event_id, event_handler);
+
+ if (res == ESP_OK && SLIST_EMPTY(&(it->base_nodes)) && SLIST_EMPTY(&(it->handlers))) {
+ SLIST_REMOVE(&(loop->loop_nodes), it, esp_event_loop_node, next);
+ free(it);
+ break;
+ }
}
xSemaphoreGiveRecursive(loop->mutex);
return ESP_OK;
}
+
esp_err_t esp_event_dump(FILE* file)
{
#ifdef CONFIG_EVENT_LOOP_PROFILING
assert(file);
esp_event_loop_instance_t* loop_it;
- esp_event_base_instance_t* base_it;
- esp_event_id_instance_t* id_it;
+ esp_event_loop_node_t *loop_node_it;
+ esp_event_base_node_t* base_node_it;
+ esp_event_id_node_t* id_node_it;
esp_event_handler_instance_t* handler_it;
// Allocate memory for printing
char* buf = calloc(sz, sizeof(char));
char* dst = buf;
+ char id_str_buf[20];
+
// Print info to buffer
portENTER_CRITICAL(&s_event_loops_spinlock);
- SLIST_FOREACH(loop_it, &s_event_loops, loop_entry) {
- PRINT_DUMP_INFO(dst, sz, LOOP_DUMP_FORMAT, loop_it, loop_it->name, loop_it->events_recieved,
- loop_it->events_dropped, loop_it->total_handlers_invoked, loop_it->total_handlers_runtime);
-
- // Print loop-level handler
- PRINT_DUMP_INFO(dst, sz, esp_event_any_base, ESP_EVENT_ANY_ID, loop_it->loop_handlers_invoked,
- loop_it->loop_handlers_runtime);
- SLIST_FOREACH(handler_it, &(loop_it->loop_handlers), handler_entry) {
- PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler, handler_it->total_times_invoked,
- handler_it->total_runtime);
- }
- SLIST_FOREACH(base_it, &(loop_it->event_bases), event_base_entry) {
- // Print base-level handler
- PRINT_DUMP_INFO(dst, sz, EVENT_DUMP_FORMAT, base_it->base, ESP_EVENT_ANY_ID,
- base_it->base_handlers_invoked, base_it->base_handlers_runtime);
- SLIST_FOREACH(handler_it, &(base_it->base_handlers), handler_entry) {
- PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler,
- handler_it->total_times_invoked, handler_it->total_runtime);
+ SLIST_FOREACH(loop_it, &s_event_loops, next) {
+ PRINT_DUMP_INFO(dst, sz, LOOP_DUMP_FORMAT, loop_it, loop_it->task != NULL ? loop_it->name : "none" ,
+ loop_it->events_recieved, loop_it->events_dropped);
+
+ int sz_bak = sz;
+
+ SLIST_FOREACH(loop_node_it, &(loop_it->loop_nodes), next) {
+ SLIST_FOREACH(handler_it, &(loop_node_it->handlers), next) {
+ PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler, "ESP_EVENT_ANY_BASE",
+ "ESP_EVENT_ANY_ID", handler_it->invoked, handler_it->time);
}
- // Print event-level handlers
- SLIST_FOREACH(id_it, &(base_it->event_ids), event_id_entry) {
- PRINT_DUMP_INFO(dst, sz, EVENT_DUMP_FORMAT, base_it->base, id_it->id,
- id_it->handlers_invoked, id_it->handlers_runtime);
+ SLIST_FOREACH(base_node_it, &(loop_node_it->base_nodes), next) {
+ SLIST_FOREACH(handler_it, &(base_node_it->handlers), next) {
+ PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler, base_node_it->base ,
+ "ESP_EVENT_ANY_ID", handler_it->invoked, handler_it->time);
+ }
- SLIST_FOREACH(handler_it, &(id_it->handlers), handler_entry) {
- PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler,
- handler_it->total_times_invoked, handler_it->total_runtime);
+ SLIST_FOREACH(id_node_it, &(base_node_it->id_nodes), next) {
+ SLIST_FOREACH(handler_it, &(id_node_it->handlers), next) {
+ memset(id_str_buf, 0, sizeof(id_str_buf));
+ snprintf(id_str_buf, sizeof(id_str_buf), "%d", id_node_it->id);
+
+ PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler, base_node_it->base ,
+ id_str_buf, handler_it->invoked, handler_it->time);
+ }
}
}
}
+
+ // No handlers registered for this loop
+ if (sz == sz_bak) {
+ PRINT_DUMP_INFO(dst, sz, " NO HANDLERS REGISTERED\n");
+ }
}
+
portEXIT_CRITICAL(&s_event_loops_spinlock);
-
+
// Print the contents of the buffer to the file
fprintf(file, buf);
-
+
// Free the allocated buffer
free(buf);
#endif
/// Configuration for creating event loops
typedef struct {
int32_t queue_size; /**< size of the event loop queue */
- const char* task_name; /**< name of the event loop task; if NULL,
+ const char* task_name; /**< name of the event loop task; if NULL,
a dedicated task is not created for event loop*/
UBaseType_t task_priority; /**< priority of the event loop task, ignored if task name is NULL */
uint32_t task_stack_size; /**< stack size of the event loop task, ignored if task name is NULL */
- BaseType_t task_core_id; /**< core to which the event loop task is pinned to,
+ BaseType_t task_core_id; /**< core to which the event loop task is pinned to,
ignored if task name is NULL */
} esp_event_loop_args_t;
* @param[in] event_loop_args configuration structure for the event loop to create
* @param[out] event_loop handle to the created event loop
*
- * @return
+ * @return
* - ESP_OK: Success
* - ESP_ERR_NO_MEM: Cannot allocate memory for event loops list
* - ESP_FAIL: Failed to create task loop
*
* @param[in] event_loop event loop to delete
*
- * @return
+ * @return
* - ESP_OK: Success
* - Others: Fail
*/
/**
* @brief Create default event loop
- *
- * @return
+ *
+ * @return
* - ESP_OK: Success
* - ESP_ERR_NO_MEM: Cannot allocate memory for event loops list
* - ESP_FAIL: Failed to create task loop
/**
* @brief Delete the default event loop
- *
- * @return
+ *
+ * @return
* - ESP_OK: Success
* - Others: Fail
*/
/**
* @brief Dispatch events posted to an event loop.
*
- * This function is used to dispatch events posted to a loop with no dedicated task, i.e task name was set to NULL
- * in event_loop_args argument during loop creation. This function includes an argument to limit the amount of time
- * it runs, returning control to the caller when that time expires (or some time afterwards). There is no guarantee
- * that a call to this function will exit at exactly the time of expiry. There is also no guarantee that events have
+ * This function is used to dispatch events posted to a loop with no dedicated task, i.e task name was set to NULL
+ * in event_loop_args argument during loop creation. This function includes an argument to limit the amount of time
+ * it runs, returning control to the caller when that time expires (or some time afterwards). There is no guarantee
+ * that a call to this function will exit at exactly the time of expiry. There is also no guarantee that events have
* been dispatched during the call, as the function might have spent all of the alloted time waiting on the event queue.
- * Once an event has been unqueued, however, it is guaranteed to be dispatched. This guarantee contributes to not being
- * able to exit exactly at time of expiry as (1) blocking on internal mutexes is necessary for dispatching the unqueued
- * event, and (2) during dispatch of the unqueued event there is no way to control the time occupied by handler code
+ * Once an event has been unqueued, however, it is guaranteed to be dispatched. This guarantee contributes to not being
+ * able to exit exactly at time of expiry as (1) blocking on internal mutexes is necessary for dispatching the unqueued
+ * event, and (2) during dispatch of the unqueued event there is no way to control the time occupied by handler code
* execution. The guaranteed time of exit is therefore the alloted time + amount of time required to dispatch
* the last unqueued event.
*
- * In cases where waiting on the queue times out, ESP_OK is returned and not ESP_ERR_TIMEOUT, since it is
+ * In cases where waiting on the queue times out, ESP_OK is returned and not ESP_ERR_TIMEOUT, since it is
* normal behavior.
*
* @param[in] event_loop event loop to dispatch posted events from
*
* @note encountering an unknown event that has been posted to the loop will only generate a warning, not an error.
*
- * @return
+ * @return
* - ESP_OK: Success
* - Others: Fail
*/
* - all events of a certain base: specify exact event_base and use ESP_EVENT_ANY_ID as the event_id
* - all events known by the loop: use ESP_EVENT_ANY_BASE for event_base and ESP_EVENT_ANY_ID as the event_id
*
- * Registering multiple handlers to events is possible. Registering a single handler to multiple events is
- * also possible. However, registering the same handler to the same event multiple times would cause the
+ * Registering multiple handlers to events is possible. Registering a single handler to multiple events is
+ * also possible. However, registering the same handler to the same event multiple times would cause the
* previous registrations to be overwritten.
*
* @param[in] event_base the base id of the event to register the handler for
* @param[in] event_handler the handler function which gets called when the event is dispatched
* @param[in] event_handler_arg data, aside from event data, that is passed to the handler when it is called
*
- * @note the event loop library does not maintain a copy of event_handler_arg, therefore the user should
+ * @note the event loop library does not maintain a copy of event_handler_arg, therefore the user should
* ensure that event_handler_arg still points to a valid location by the time the handler gets called
*
- * @return
+ * @return
* - ESP_OK: Success
* - ESP_ERR_NO_MEM: Cannot allocate memory for the handler
- * - ESP_ERR_INVALIG_ARG: Invalid combination of event base and event id
+ * - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
* - Others: Fail
*/
-esp_err_t esp_event_handler_register(esp_event_base_t event_base,
- int32_t event_id,
- esp_event_handler_t event_handler,
+esp_err_t esp_event_handler_register(esp_event_base_t event_base,
+ int32_t event_id,
+ esp_event_handler_t event_handler,
void* event_handler_arg);
/**
* @brief Register an event handler to a specific loop.
*
- * This function behaves in the same manner as esp_event_handler_register, except the additional
+ * This function behaves in the same manner as esp_event_handler_register, except the additional
* specification of the event loop to register the handler to.
*
* @param[in] event_loop the event loop to register this handler function to
* @param[in] event_handler the handler function which gets called when the event is dispatched
* @param[in] event_handler_arg data, aside from event data, that is passed to the handler when it is called
*
- * @return
+ * @note the event loop library does not maintain a copy of event_handler_arg, therefore the user should
+ * ensure that event_handler_arg still points to a valid location by the time the handler gets called
+ *
+ * @return
* - ESP_OK: Success
* - ESP_ERR_NO_MEM: Cannot allocate memory for the handler
- * - ESP_ERR_INVALIG_ARG: Invalid combination of event base and event id
+ * - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
* - Others: Fail
*/
-esp_err_t esp_event_handler_register_with(esp_event_loop_handle_t event_loop,
- esp_event_base_t event_base,
- int32_t event_id,
- esp_event_handler_t event_handler,
+esp_err_t esp_event_handler_register_with(esp_event_loop_handle_t event_loop,
+ esp_event_base_t event_base,
+ int32_t event_id,
+ esp_event_handler_t event_handler,
void* event_handler_arg);
/**
* @brief Unregister a handler with the system event loop.
*
* This function can be used to unregister a handler so that it no longer gets called during dispatch.
- * Handlers can be unregistered for either: (1) specific events, (2) all events of a certain event base,
+ * Handlers can be unregistered for either: (1) specific events, (2) all events of a certain event base,
* or (3) all events known by the system event loop
*
* - specific events: specify exact event_base and event_id
* @param[in] event_handler the handler to unregister
*
* @return ESP_OK success
- * @return ESP_ERR_INVALIG_ARG invalid combination of event base and event id
+ * @return ESP_ERR_INVALID_ARG invalid combination of event base and event id
* @return others fail
*/
esp_err_t esp_event_handler_unregister(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler);
/**
* @brief Unregister a handler with the system event loop.
*
- * This function behaves in the same manner as esp_event_handler_unregister, except the additional specification of
+ * This function behaves in the same manner as esp_event_handler_unregister, except the additional specification of
* the event loop to unregister the handler with.
*
* @param[in] event_loop the event loop with which to unregister this handler function
* @param[in] event_id the id of the event with which to unregister the handler
* @param[in] event_handler the handler to unregister
*
- * @return
+ * @return
* - ESP_OK: Success
- * - ESP_ERR_INVALIG_ARG: Invalid combination of event base and event id
+ * - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
* - Others: Fail
*/
-esp_err_t esp_event_handler_unregister_with(esp_event_loop_handle_t event_loop,
- esp_event_base_t event_base,
- int32_t event_id,
+esp_err_t esp_event_handler_unregister_with(esp_event_loop_handle_t event_loop,
+ esp_event_base_t event_base,
+ int32_t event_id,
esp_event_handler_t event_handler);
/**
- * @brief Posts an event to the system default event loop. The event loop library keeps a copy of event_data and manages
- * the copy's lifetime automatically (allocation + deletion); this ensures that the data the
+ * @brief Posts an event to the system default event loop. The event loop library keeps a copy of event_data and manages
+ * the copy's lifetime automatically (allocation + deletion); this ensures that the data the
* handler recieves is always valid.
- *
+ *
* @param[in] event_base the event base that identifies the event
* @param[in] event_id the the event id that identifies the event
* @param[in] event_data the data, specific to the event occurence, that gets passed to the handler
*
* @note posting events from an ISR is not supported
*
- * @return
+ * @return
* - ESP_OK: Success
* - ESP_ERR_TIMEOUT: Time to wait for event queue to unblock expired
- * - ESP_ERR_INVALIG_ARG: Invalid combination of event base and event id
+ * - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
* - Others: Fail
*/
-esp_err_t esp_event_post(esp_event_base_t event_base,
- int32_t event_id,
- void* event_data,
- size_t event_data_size,
+esp_err_t esp_event_post(esp_event_base_t event_base,
+ int32_t event_id,
+ void* event_data,
+ size_t event_data_size,
TickType_t ticks_to_wait);
/**
- * @brief Posts an event to the specified event loop. The event loop library keeps a copy of event_data and manages
- * the copy's lifetime automatically (allocation + deletion); this ensures that the data the
+ * @brief Posts an event to the specified event loop. The event loop library keeps a copy of event_data and manages
+ * the copy's lifetime automatically (allocation + deletion); this ensures that the data the
* handler recieves is always valid.
*
* This function behaves in the same manner as esp_event_post_to, except the additional specification of the event loop
* @param[in] ticks_to_wait number of ticks to block on a full event queue
*
* @note posting events from an ISR is not supported
- *
- * @return
+ *
+ * @return
* - ESP_OK: Success
* - ESP_ERR_TIMEOUT: Time to wait for event queue to unblock expired
- * - ESP_ERR_INVALIG_ARG: Invalid combination of event base and event id
+ * - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
* - Others: Fail
*/
-esp_err_t esp_event_post_to(esp_event_loop_handle_t event_loop,
- esp_event_base_t event_base,
- int32_t event_id,
- void* event_data,
- size_t event_data_size,
+esp_err_t esp_event_post_to(esp_event_loop_handle_t event_loop,
+ esp_event_base_t event_base,
+ int32_t event_id,
+ void* event_data,
+ size_t event_data_size,
TickType_t ticks_to_wait);
/**
* @brief Dumps statistics of all event loops.
*
* Dumps event loop info in the format:
- *
+ *
@verbatim
event loop
- event
- handler
- handler
- event
- handler
- handler
+ handler
+ handler
+ ...
event loop
- event
- handler
- ...
+ handler
+ handler
...
- ...
-
+
where:
-
+
event loop
- format: address,name rx:total_recieved dr:total_dropped inv:total_number_of_invocations run:total_runtime
+ format: address,name rx:total_recieved dr:total_dropped
where:
address - memory address of the event loop
- name - name of the event loop
+ name - name of the event loop, 'none' if no dedicated task
total_recieved - number of successfully posted events
- total_number_of_invocations - total number of handler invocations performed so far
- total_runtime - total runtime of all invocations so far
-
- event
- format: base:id proc:total_processed run:total_runtime
- where:
- base - event base
- id - event id
- total_processed - number of instances of this event that has been processed
- total_runtime - total amount of time in microseconds used for invoking handlers of this event
-
+ total_dropped - number of events unsucessfully posted due to queue being full
+
handler
- format: address inv:total_invoked run:total_runtime
+ format: address ev:base,id inv:total_invoked run:total_runtime
where:
address - address of the handler function
+ base,id - the event specified by event base and id this handler executes
total_invoked - number of times this handler has been invoked
total_runtime - total amount of time used for invoking this handler
-
+
@endverbatim
*
* @param[in] file the file stream to output to
*
* @note this function is a noop when CONFIG_EVENT_LOOP_PROFILING is disabled
*
- * @return
+ * @return
* - ESP_OK: Success
* - ESP_ERR_NO_MEM: Cannot allocate memory for event loops list
* - Others: Fail
projects / esp-idf / commitdiff