Atomic Data Addition in Complex Containers via Package Objects
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional methods for adding non-contiguous data items to complex memory containers face inefficiencies and challenges in ensuring atomicity and serialization, particularly during document processing and graphics handling, where selected portions of graphical objects may reside in discontiguous memory locations.
Innovation Solution
A method involving the creation of a package object with an array of pointer-integer pairs, where each pointer points to a data item's start location and the integer represents its size, along with a size function and write function, allows for the sequential addition of data items to a complex container, ensuring atomicity and serialization by determining the required memory and invoking the container's external interface for efficient addition.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If multiple functional interfaces are called to add each distinct portion of graphical objects to the display list, then each portion can be added individually, but the atomicity of the entire transaction cannot be guaranteed and processing becomes slower
Solution Approach 1:
The patent segments the data addition process into two distinct phases: (1) a preparation phase where all data portions are collected and validated without modifying the container, and (2) an atomic commit phase where all segments are added in a single transaction. This segmentation allows individual data validation while ensuring overall atomicity, resolving the contradiction between reliability and productivity.
Solution Approach 2:
The patent performs preliminary actions by collecting all data portions, validating their integrity, and preparing the complete transaction before invoking the container's add method. This preliminary validation and preparation ensures that when the atomic operation is executed, all conditions are met, guaranteeing both atomicity and efficient processing without repeated trial-and-error calls.
2Reliability
If the entire graphical object is added to the display list, then atomicity is maintained, but memory resources are used inefficiently because selected portions may be small relative to the entire object
Solution Approach 1:
The patent extracts only the necessary data portions from the complete graphical object. By identifying and separating the specific segments that need to be added to the display list, the system avoids adding unnecessary data, thus optimizing memory usage while maintaining atomicity through the single transaction approach.
Solution Approach 2:
The patent applies partial action by adding only the specific portions of the graphical object that are required, rather than the entire object. This selective addition optimizes memory resources by including only the necessary data segments while still achieving the atomicity goal through a single transactional operation.
3Ease of operation
If selected portions of graphical objects are copied into a contiguous memory block before addition, then the functional interface can be invoked successfully, but additional copy steps contribute to processing delays
Solution Approach 1:
The patent utilizes copying by creating a temporary buffer that contains all the selected data portions in their original memory locations. This buffer serves as an intermediate copy that the functional interface can process efficiently, eliminating the need for multiple individual copy operations while maintaining compatibility with the container's add method.
Solution Approach 2:
The patent merges multiple scattered data portions into a single contiguous memory buffer before passing it to the functional interface. This merging operation consolidates the data in one efficient step rather than performing separate copy operations for each portion, thereby improving processing speed while ensuring the interface receives data in the required format.
4Quantity of substance
If non-contiguous data items are added to complex containers, then memory efficiency is improved, but the complexity of managing serialization and atomicity increases
Solution Approach 1:
The patent introduces an intermediary data structure that manages the collection and coordination of multiple non-contiguous data portions. This intermediary layer handles the complexity of serialization and atomicity management, shielding the container from the complexity while allowing efficient use of non-contiguous memory resources.
Data Source
AI summary
Systems and methods for managing data in complex containers permit atomic addition of a plurality of data items to the containers. Each data item can occupy contiguous memory locations, although the plurality of data items may be mutually discontiguous. The method comprises creating a package object, which comprises an externally accessible array of pointer and associated integers. Each pointer points to the start of a memory location holding a distinct data item and the associated integer represents the size of the data item referenced by the pointer. A function associated with an external interface of the container determines a quantity of memory to hold the plurality of data items and invokes an externally accessible write function in the package object to add the plurality of individual data items to the container at specified locations if there is adequate memory available to hold the plurality of data items.