Singly Linked List Data Exchange with Segmented Pointers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing data structures for communication between writing and reading processes, such as singly linked lists, do not allow for safe removal of elements other than the last one without conflicting with the reading process, and do not efficiently manage unread elements.
Innovation Solution
A computer-implemented data structure using three pointer data structures: one pointing to the oldest element, another to the next writable element, and a third to the next unread element, allowing the writing process to remove read elements and the reading process to modify the third pointer, while ensuring data integrity and avoiding race conditions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a singly linked list is used for data exchange between writing and reading processes, then the writing process can continuously write new data, but the writing process cannot safely remove elements other than the last one without conflicting with the reading process
Solution Approach 1:
The patent segments the singly linked list into two distinct parts: a first part containing elements from the head up to and including the element pointed to by the third pointer (unread elements), and a second part containing elements from the next element after the third pointer up to the element pointed to by the second pointer (read elements). This segmentation allows the writing process to safely remove elements from the second part without interfering with the reading process, as these elements have already been read and are no longer needed by readers.
Solution Approach 2:
The patent introduces a third pointer data structure as an intermediary between the first pointer (pointing to the oldest element) and the second pointer (pointing to the next writable element). This third pointer, which can be modified exclusively by reading processes, serves as a mediator that marks the boundary between read and unread elements. The writing process uses this intermediary pointer to determine which elements are safe to remove, thereby avoiding conflicts with the reading process while enabling flexible element removal.
2Reliability
If the writing process removes only the last element, then data structure consistency is maintained, but unread elements cannot be efficiently managed and removed
Solution Approach 1:
The patent implements preliminary action by having reading processes modify the third pointer data structure to mark elements as read before the writing process removes them. This preliminary marking action allows the writing process to identify and remove only those elements that have been marked as read, ensuring that unread elements are never accidentally removed while enabling efficient cleanup of read elements without requiring the writing process to track read status independently.
3Ease of operation
If multiple pointer data structures are introduced to manage read and unread elements, then element removal flexibility improves, but data structure complexity increases
Solution Approach 1:
The patent applies universality by designing the third pointer data structure to serve multiple functions: it marks the boundary between read and unread elements, guides the writing process on which elements are safe to remove, and can be modified exclusively by reading processes to update their read status. This multi-functional design reduces the need for additional separate data structures while maintaining element removal flexibility and data consistency.
Data Source
AI summary
A computer-implemented data structure for a singly linked list for data exchange between a writing process and at least one reading process. The computer-implemented data structure including a first pointer data structure and a second pointer data structure, the first pointer data structure pointing to the oldest element in the list and the second pointer data structure pointing to the next writable element in the list, a third pointer data structure pointing to the next unread element in the list.