Thread Event Synchronization via Wait Data Structure
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing operating systems limit the number of events that threads can wait upon and require an all-or-nothing approach, restricting flexibility and efficiency in multi-threaded environments.
Innovation Solution
A processor-implemented system and method that uses a wait data structure to allow threads to wait on multiple events by storing event conditions and providing a notification mechanism through event objects, enabling synchronization and continuation of execution when conditions are met, without relying on operating system locks.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If operating systems use native event abstractions (CreateEvent, condition variables), then thread synchronization is provided, but the number of events that can be simultaneously waited on is limited
Solution Approach 1:
The patent segments the event waiting mechanism into user-space event objects and kernel-space event handles. By dividing the synchronization functionality across user-mode event structures and kernel-mode event objects, the system allows threads to wait on multiple events simultaneously without being constrained by operating system limits on native event abstractions.
Solution Approach 2:
The patent introduces an intermediary event object layer between the thread and the operating system events. This intermediary structure (containing event handles, condition variables, and mutexes) mediates the waiting process, allowing flexible multi-event waiting while maintaining reliable synchronization through the underlying OS primitives.
2Reliability
If operating systems use native event abstractions, then thread synchronization is enabled, but events are waited on in an all or nothing fashion
Solution Approach 1:
The patent implements dynamic event waiting where a thread can wait on a variable number of events based on runtime conditions. The event object structure allows the thread to wait on one or more events dynamically, and the wait count can be adjusted during execution, providing flexibility while maintaining reliable synchronization through the underlying OS event mechanisms.
Solution Approach 2:
The patent changes the parameter of event waiting from fixed (all or nothing) to variable (any number of events). By modifying the wait count parameter and allowing dynamic adjustment of which events to wait on, the system provides ease of operation while maintaining the reliability of thread synchronization through the event object's internal state management.
3Reliability
If operating systems provide native event abstractions, then basic synchronization is achieved, but operating system overhead is incurred
Solution Approach 1:
The patent performs preliminary actions by creating and initializing event objects in user space before threads need to wait on them. The event objects are pre-configured with handles, condition variables, and mutexes, allowing threads to efficiently wait on multiple events without repeatedly invoking operating system APIs, thus reducing OS overhead while maintaining synchronization reliability.
Solution Approach 2:
The patent implements self-service by allowing threads to manage their own event waiting state through user-space event objects. The thread can independently track which events are signaled and manage its wait queue without requiring continuous operating system intervention, reducing OS overhead while maintaining reliable synchronization through the event object's internal state management.
Data Source
AI summary
Processor-implemented systems and methods are provided for synchronization of a thread, wherein the thread waits for one or more events to occur before continuing execution. A processor-implemented system and method can include a wait data structure which stores event conditions in order to determine when the thread should continue execution. Event objects, executing on one or more data processors, allow for thread synchronization. A pointer is stored with respect to a wait data structure in order to provide visibility of event conditions to the event objects. The thread continues execution when the stored event conditions are satisfied.