Shared Memory Framework for Concurrent Data Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing digital data processing systems face challenges in efficiently managing shared data access across multiple user and program sessions, particularly in scenarios requiring concurrent access to large datasets, where existing solutions lack effective mechanisms for ensuring data consistency and availability.
Innovation Solution
A framework for creating and managing shared objects in a shared memory environment, which allows for the definition of shared objects' properties declaratively, supports locking mechanisms to prevent parallel changes, and enables versioning and transactional management to ensure data consistency and availability.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple users and program sessions access large datasets concurrently, then data availability and access efficiency are improved, but data consistency and reliability deteriorate
Solution Approach 1:
The patent introduces a shared memory framework as an intermediary layer between multiple users/program sessions and the underlying data storage. This framework provides standardized access methods, locking mechanisms, and transaction management that mediate concurrent access requests, ensuring data consistency while maintaining high availability. The shared memory acts as a buffer and coordination point that reconciles multiple access requests without requiring direct access to the base data.
Solution Approach 2:
The patent implements feedback mechanisms through locking systems and version control that monitor and regulate concurrent access. When data is being modified, lock signals are sent back to preventing other users from making conflicting changes. Versioning systems provide feedback about data state changes, allowing users to coordinate their access patterns and maintain consistency across concurrent operations.
2Reliability
If a shared memory framework with locking mechanisms is implemented, then data consistency is improved, but system complexity increases
Solution Approach 1:
The shared memory framework provides self-service capabilities by automatically managing locks, versions, and transactions without requiring complex external coordination. The system handles conflict resolution, data synchronization, and consistency maintenance through built-in mechanisms that operate transparently to users, reducing the need for complex application-level synchronization logic.
Solution Approach 2:
The patent segments the data access system into distinct layers: the shared memory framework layer that handles complexity of locking and consistency, and the application layer that focuses on business logic. This segmentation isolates complexity to a manageable framework layer while keeping user applications simple. The framework can be further segmented into memory management, locking mechanisms, and version control components.
3Speed
If shared objects are stored in shared memory, then access speed and productivity are improved, but memory management complexity increases
Solution Approach 1:
The shared memory framework provides universal access methods that work consistently across different data types and access patterns. A single set of access methods and programming interface handles various scenarios (reading, writing, locking, versioning) uniformly, simplifying memory management despite the underlying complexity. The framework serves multiple functions including memory allocation, access control, and data management through a unified interface.
Data Source
AI summary
A shared memory technology where shared objects can be used by any of multiple users, applications, or program sessions with programming language support during development and at runtime. The developer can declare shared memory behaviors at design time to cause one or more area classes to be generated for use at runtime. A shared objects memory is managed by the runtime environment. Content is stored at runtime in an area instance of an area class. Class methods to be generated that include methods for attaching and detaching a running session to and from an area instance, and for detaching a session from a change request on an area instance with a commit or a rollback. The runtime environment manages locks for area instances. There are programming language constructs for creating area instances and for creating data objects of arbitrary data type within area instances.