State Machine Controller for Shared Object Lock Management
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing multi-threaded software systems face challenges in coordinating access to shared resources, particularly due to coherency and latency issues when serializing access to objects, and lack an independent control mechanism for managing shared locks.
Innovation Solution
Implementing a state machine that manages shared objects accessible by multiple threads, allowing threads to request and control the locking and unlocking of objects independently, using a state machine controller to transition between defined states such as locked and unlocked states.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If threads serialize access to shared objects through locking mechanisms, then coherency is improved, but latency increases
Solution Approach 1:
A state machine controller is introduced as an intermediary between threads and shared objects. The controller manages lock state transitions (locked/unlocked) and coordinates access requests from multiple threads, thereby maintaining coherency while reducing latency by automating the locking/unlocking coordination process.
2Ease of operation
If threads directly control locking and unlocking of shared objects, then ease of operation is improved, but device complexity increases due to lack of independent control mechanism
Solution Approach 1:
The state machine controller serves as an intermediary that simplifies thread operation while managing complexity internally. Threads interact with the controller through standardized state transition requests, making operation easier, while the controller handles the complex coordination logic for multiple threads and lock state management.
Solution Approach 2:
The state machine controller automatically manages lock state transitions based on thread requests, eliminating the need for threads to directly coordinate with each other. The controller self-manages the complexity of tracking locked/unlocked states and coordinating multiple thread access requests.
Data Source
AI summary
Embodiments relate to systems and methods for a shared object lock under state machine control. An operating system or virtual machine environment can host a set of multiple executing threads, and provide those threads with mutual access to one or more objects such as storage objects, memory objects, or others. The threads can independently request that the object be locked or unlocked, and the locked or unlocked state can be shared between the threads. Rather than communicate with the object(s) directly, in embodiments the threads communicate with a state machine that in turn controls the state of the object(s). When a request to change the state of the object(s) is received, the state machine can permit the object(s) to change between locked, unlocked, or other states based on the current state of the machine and the received message. Contention between threads can be reduced or eliminated.