Shared State Memory Array for Concurrent Process Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional methods for sharing state information between concurrently-running processes or threads are inefficient in terms of resource usage and predictability, often leading to blocking and invalid data reads due to asynchronous access patterns.
Innovation Solution
A system comprising a mutator, an observer, and an N-element memory array, utilizing pointers managed by a memory manager to facilitate efficient sharing of state information through APIs like Begin(), End(), Push(), and Poll() functions, which prevent blocking and ensure valid data access by managing writes and reads asynchronously.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If conventional methods are used for sharing state information between concurrently-running processes or threads, then resource usage is high and performance predictability is poor, but implementing a new pointer-based system increases device complexity
Solution Approach 1:
The memory array is segmented into N elements with dedicated pointers (first pointer for mutator, second pointer for observer) to enable independent concurrent access. Each process/thread operates on its own pointer without blocking the other, eliminating contention while maintaining simple individual operations.
Solution Approach 2:
The memory manager acts as an intermediary that manages the pointers and coordinates access between mutator and observer. It provides Begin(), End(), Push(), and Poll() functions that handle the complexity of synchronization, allowing the mutator and observer to operate independently while ensuring data consistency.
2Reliability
If data copying is used to share state information, then data validity is ensured, but memory usage increases
Solution Approach 1:
Instead of physically copying data, the system copies pointer references. The first pointer and second pointer both reference elements in the shared memory array, allowing the observer to access mutator's data without duplication. This maintains data validity through consistent referencing while using minimal memory.
Solution Approach 2:
The shared memory array serves multiple functions: it stores state information, acts as a communication channel between processes, and provides synchronization through pointer management. This multi-functionality eliminates the need for separate data copies while ensuring data validity.
3Quantity of substance
If asynchronous access patterns are used, then resource usage is reduced, but blocking and invalid data reads occur
Solution Approach 1:
The mutator calls Begin() to prepare the memory element before writing, and the observer calls Poll() to check readiness before reading. These preliminary actions ensure that data is valid before access, preventing invalid reads while maintaining asynchronous operation and low resource usage.
Solution Approach 2:
The Poll() function provides feedback to the observer about whether data is ready for reading. The memory manager monitors the state of memory elements and returns information about their readiness, enabling the observer to asynchronously access only valid data without blocking or risking invalid reads.
Data Source
AI summary
In a system where data is shared by a first module writing the information to memory, and a second module then reading the information from the memory, asynchronous and/or unpredictable operation of the two modules may lead to instances of blocking and/or instances of the second module reading invalid data from the memory. Aspects of the present disclosure manage reads and writes to memory such that blocking by either the first module and/or the second module, and/or reads of invalid data by the second module, may be prevented if so desired.