[!] sched/event: Replace semaphore with direct scheduler operations in event implementation to improve performance

[wangchdo]

Summary

The current event implementation uses semaphores for wait and post
operations. Since semaphores are relatively heavy-weight and intended
for resource-based synchronization, this is suboptimal.

So this patch replaced the semaphore-based mechanism with direct
scheduler operations to improve performance and reduce memory footprint.

This patch also introduce a new task state TSTATE_WAIT_EVENT to indicate
the task is waiting for a event.

Impact

improvement for the event module, no impact to other nuttx parts

Testing

ostest passed on board a2g-tc397-5v-tft (including event testcases)

[xiaoxiang781216]

but spinlock could avoid the global big lock, why do we switch back?

[wangchdo]

This is mainly for removing reliance on semaphore, after removing semaphore, we will use critical section to protect event, and spinlock is not needed any more.

The reason to remove semaphore is that it is too heavy for event timeout:

1. It has global big lock inside the sema_wait/sema_post api，so in fact there are double lock here: spinlock for event and critical section lock for semaphore
2. Semaphore object costs more memory
3. It has lost of logic inside sema_wait and sema_post that are not related to event timeout, these logic is even more complicated than event itself

Indeed the lock scope is very small in event, and after removing semaphore it is even smaller, so i think this would be better

By the way The current spinlock is also a global one for event post, it uses flags = spin_lock_irqsave_nopreempt(&event->lock) api.

I also submitted #17244 to remove the event's dependency on wait object, please check detailed information below, thanks

[anchao]

I think there needs to be a balance here with the SMP mode, I prefer to use spinlock

[wangchdo]

I think there needs to be a balance here with the SMP mode, I prefer to use spinlock

Hi @anchao

My key point here is removing semaphore, becasue:

The current event implementation uses a spinlock plus a semaphore — the spinlock protects the event object, while the semaphore manages synchronization between the event waiter and poster. However, this design feels unnecessarily heavy. The semaphore internally relies on enter_critical_section()/leave_critical_section() to protect its own object, and its internal logic is overly complex for such a simple synchronization scenario. In addition, the semaphore object itself consumes extra memory.

Therefore, I decided to remove the semaphore dependency and instead directly use enter_critical_section()/leave_critical_section() to both protect the event object and synchronize between the waiter and poster. This should be more efficient

[wangchdo]

Besides, if you check PR #17244
, you’ll see that removing the semaphore also provides an opportunity to eliminate the wait object used by event-waiting tasks. Removing the wait object not only reduces memory usage but also makes the event mechanism safer and the API cleaner and more straightforward.

[xiaoxiang781216]

why not continue use TSTATE_WAIT_SIG with alias

[wangchdo]

I think event is different than sleep... the scheduler need to treat task waiting on event separately for things like task cancellation, so a new task state is really needed... you can refer to the function nxevent_wait_irq() I implemented and it is called from nxnotify_cancellation():

You can also refer to PR17244 for more information I explained, in this PR i continued to remove the separate wait object in event implementation

[wangchdo]

@xiaoxiang781216 @anchao

This PR removed event's reliance on semaphore, I also submited a PR to remove event's reliance on a separate wait object, please also check : PR17244

FYI:
#17223 plus this #17224 change summary is:

Refactors the event module by removing its dependency on semaphores and separate wait objects, and introduces a new task state TSTATE_WAIT_EVENT to simplify scheduling and improve maintainability.

Detailed Changes are

1. Remove semaphore dependency

Reason:

• Semaphore objects consume more memory than necessary for event synchronization.
• Semaphore interfaces are relatively complex, involving global locks and logic that exceeds
  the needs of the event mechanism.

Benefit:

• Simplifies the event module and reduces runtime and memory overhead.

2. Remove wait object dependency

Reason:

• Wait objects introduce additional memory usage.
• The current design either uses a local wait object in the waiting task (which is unsafe because the posting task also accesses it) or requires users to define global wait objects and call event_tickwait_wait(). This leads to complicated and error-prone usage.
• By removing wait objects, the event module can be implemented more cleanly.

Benefit:

• Simplifies API usage.
• Improves safety and code maintainability.

3. Introduce TSTATE_WAIT_EVENT and move the scheduling list to the event object

Reason:

• Makes the event module implementation more concise.
• Allows the scheduler to handle tasks blocked on events more flexibly in special cases (e.g., task deletion).

Benefit:

• Improves modularity and better integrates event handling with the scheduler.

[jerpelea]

please signal the breaking change with [!] before the commit and PR title
ex:
[!] sched/event: Replace semaphore with direct scheduler operations in event

[wangchdo]

please signal the breaking change with [!] before the commit and PR title ex: [!] sched/event: Replace semaphore with direct scheduler operations in event

HI @jerpelea

Done, please check:

[xiaoxiang781216]

@wangchdo why dup with #17244

[wangchdo]

@wangchdo why dup with #17244

This PR is in the same branch with 17244， let me close this duplicated one