Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method for implementing a data structure in a flash memory, the method comprising: storing nodes of the data structure in the flash memory, wherein the nodes of the data structure are configured to be changed in the flash memory at least once without requiring the nodes to be erased and written in a new location in the flash memory, the nodes including a first node having a first data portion and a first pointer portion that is configured to store a pointer to a second node that includes a second data portion and a second pointer portion; updating the pointer portion of the first node only when updating the first pointer portion only requires setting bits in the first pointer portion, wherein the first pointer portion of the first node is updated by storing a new pointer in a table in a memory separate from the flash memory, without deleting the first node from the data structure or the flash memory, when the first pointer portion cannot be updated by only setting bits in the pointer portion.
This invention relates to optimizing data structure management in flash memory, addressing inefficiencies in traditional approaches that require erasing and rewriting nodes when pointers are updated. Flash memory has limitations in in-place updates, particularly for pointer modifications, which often necessitate moving entire nodes to new locations due to the inability to overwrite existing data. The invention provides a method to store nodes of a data structure in flash memory, where nodes can be modified at least once without erasure or relocation. Each node contains a data portion and a pointer portion, with the pointer portion initially designed to allow updates by setting bits. When a pointer update cannot be achieved by simple bit setting, the method stores a new pointer in a separate memory table instead of modifying the flash memory directly. This avoids the need to erase or relocate the node, preserving flash memory endurance and reducing write amplification. The approach maintains data structure integrity by ensuring pointers remain valid, either through direct bit manipulation or indirect table references, while minimizing the overhead of flash memory operations. This technique is particularly useful for systems requiring frequent pointer updates, such as file systems or databases, where flash memory wear and performance are critical concerns.
2. The method of claim 1 , wherein a command for updating the pointer portion is specified by a client.
A system and method for managing data storage involves a distributed storage architecture where data is stored across multiple nodes, and a pointer portion is used to track the location of data blocks. The pointer portion is dynamically updated to reflect changes in data distribution, ensuring efficient data retrieval. The invention addresses the challenge of maintaining accurate and up-to-date pointers in a distributed storage environment, where data may be frequently moved or replicated across nodes. This ensures that clients can reliably access the latest version of stored data without delays or inconsistencies. In this method, a client can specify a command to update the pointer portion, allowing for direct control over pointer management. This enables clients to request updates when data is moved, modified, or replicated, ensuring that the pointer portion remains synchronized with the actual data distribution. The system may also include mechanisms to validate the client's command before updating the pointer portion, ensuring data integrity and preventing unauthorized modifications. The method may further involve logging pointer updates for auditing and recovery purposes, providing a historical record of changes to the pointer portion. This approach enhances the reliability and efficiency of data access in distributed storage systems.
3. The method of claim 1 , wherein the command is one of a compare and swap operation or an OR operation.
This invention relates to atomic memory operations in computing systems, specifically addressing the need for efficient and reliable execution of low-level memory commands. The method involves performing atomic operations on memory locations to ensure data consistency in multi-threaded or distributed environments. The invention focuses on two key operations: a compare-and-swap (CAS) operation and a bitwise OR operation. The CAS operation atomically checks if a memory location contains a specified value and, if so, updates it to a new value. This is critical for synchronization in concurrent systems. The bitwise OR operation atomically combines a memory value with a new value using a logical OR, which is useful for flag-based operations. Both operations are executed in a single, indivisible step to prevent race conditions and ensure correctness. The method is designed to work with memory systems that support atomic instructions, such as those found in modern processors, and is particularly valuable in high-performance computing, databases, and real-time systems where data integrity is paramount. The invention improves upon existing techniques by providing a standardized approach to atomic operations, reducing complexity and enhancing reliability in memory management.
4. The method of claim 2 , wherein the command is one of a compare and swap operation or an OR operation.
This invention relates to atomic memory operations in computing systems, specifically addressing the need for efficient and reliable synchronization mechanisms in multi-threaded or distributed environments. The method involves performing atomic operations on memory locations to ensure data consistency without race conditions. The invention focuses on two key atomic operations: compare-and-swap (CAS) and bitwise OR. In a compare-and-swap operation, the system checks if a memory location contains a specified value and, if so, updates it to a new value atomically. This is critical for implementing lock-free data structures and thread-safe algorithms. The bitwise OR operation allows multiple threads to set bits in a shared memory location without conflicts, useful for tracking flags or permissions. The method ensures these operations are executed atomically, preventing partial updates that could lead to corruption. By supporting these operations, the invention enables robust synchronization in high-performance computing, distributed systems, and concurrent programming scenarios where multiple processes or threads access shared memory. The approach improves efficiency by reducing the need for locks and minimizing contention, while maintaining data integrity.
5. The method of claim 1 , wherein the data structure is one of a tree, a graph, a linked list, a Bloom filter, a hash table, or an array.
6. The method of claim 1 , wherein the first pointer portion includes an invalid bit configured to be set by overwriting to indicate that the first pointer portion is not valid and that the new pointer is stored in the memory.
7. The method of claim 1 , further comprising inserting a new node into the data structure, the new node including a data portion and a pointer portion.
8. The method of claim 7 , further comprising one of: inserting the new node at an end of the data structure, wherein the pointer portion of the new node is configured to be overwritten when the new node is inserted at the end of the data structure; inserting the new node in a middle of the data structure between a second node and a third node, wherein a pointer portion of the second node is overwritten such that the pointer portion of the second node points to the new node and wherein the pointer portion of the new node is overwritten to point to the third node.
9. The method of claim 8 , wherein the pointer portion of the second node is not overwritten and a pointer to the new node is stored in the table in the memory.
A method for managing data structures in a memory system involves updating a linked data structure while preserving existing pointer references. The method addresses the problem of maintaining data integrity and avoiding pointer corruption during dynamic updates in linked structures, such as linked lists or trees, where nodes are frequently added, removed, or modified. In a linked data structure stored in memory, a second node contains a pointer portion that references another node. When a new node is introduced, the pointer portion of the second node is intentionally left unchanged to preserve its existing reference. Instead, a separate table in memory is updated to store a pointer to the new node, allowing the new node to be accessed indirectly without altering the original pointer structure. This approach ensures that existing references remain valid while enabling the integration of new nodes into the data structure. The method is particularly useful in systems where pointer stability is critical, such as in real-time databases, embedded systems, or memory-constrained environments where direct pointer manipulation may be risky or inefficient. By decoupling the addition of new nodes from the modification of existing pointers, the method reduces the risk of pointer-related errors and simplifies memory management.
10. The method of claim 1 , wherein the nodes of the data structure each include a plurality of pointer portions, wherein the plurality of pointer portions are overwritten when possible before writing any new pointer to the table in the memory.
This invention relates to optimizing memory management in data structures, particularly for systems where pointer updates must be performed efficiently. The problem addressed is the overhead and potential inefficiencies in updating pointers within a data structure, which can lead to performance bottlenecks in memory-intensive applications. The invention describes a method for managing pointers in a data structure where each node contains multiple pointer portions. These pointer portions are overwritten in a prioritized manner before any new pointer is written to a table in memory. This approach ensures that existing pointer portions are reused whenever possible, reducing the need for new memory allocations and minimizing fragmentation. The method is designed to work with a data structure that includes a table in memory, where pointers are stored and managed. The data structure itself may include nodes that are linked or organized in a specific way, such as a tree or graph, where each node has multiple pointer portions. These portions can be overwritten in a sequence or based on certain conditions to maximize memory efficiency. The invention also involves determining when a pointer portion is available for overwriting, ensuring that the process does not disrupt ongoing operations or data integrity. By reusing existing pointer portions before allocating new ones, the method reduces memory overhead and improves performance in systems where frequent pointer updates are required. This is particularly useful in applications like databases, file systems, or real-time processing systems where efficient memory management is critical.
11. The method of claim 1 , further comprising deleting a node between a second node and a third node.
A method for modifying a data structure, such as a linked list or tree, involves deleting a node positioned between two other nodes. The method addresses the challenge of efficiently removing an intermediate node from a sequence of connected nodes without disrupting the overall structure. The deletion process ensures that the connections between the adjacent nodes (the second and third nodes) are properly maintained, preserving the integrity of the data structure. This technique is particularly useful in dynamic data environments where nodes are frequently added or removed, such as in memory management, database indexing, or network routing tables. The method may include identifying the node to be deleted, updating the pointers or references of the adjacent nodes to bypass the deleted node, and optionally freeing the memory or resources associated with the removed node. This ensures seamless operation of the data structure after the deletion, maintaining performance and correctness. The approach is applicable to various data structures where nodes are interconnected, including but not limited to linked lists, binary trees, and graphs.
12. The method of claim 11 , further comprising, when deleting the node, overwriting a pointer portion of the second node to point to the third node when possible.
13. The method of claim 11 , further comprising setting the pointer portion of the second node as invalid and writing a pointer to the third node and associated with the second node to the memory when the pointer portion of the second node cannot be overwritten.
14. The method of claim 1 , further comprising traversing the data structure, wherein pointers to subsequent nodes in the data structure are accessed from the pointer portions of the nodes or wherein the pointers are accessed from the table in memory when the pointer portions of any of the nodes are invalid.
15. The method of claim 14 , further comprising marking the data portion of a node as invalid, wherein the pointer portion remains valid such that the data structure can be traversed using an existing pointer portion in the node whose data portion is marked as invalid.
16. A non-transitory computer readable medium comprising computer executable instructions configured to implement method for implementing a data structure in a flash memory, the method comprising: storing nodes of the data structure in the flash memory, wherein the nodes of the data structure are configured to be changed in the flash memory at least once without requiring the nodes to be erased and written in a new location in the flash memory, the nodes including a first node having a first data portion and a first pointer portion that is configured to store a pointer to a second node that includes a second data portion and a second pointer portion; updating the pointer portion of the first node only when updating the first pointer portion only requires setting bits in the first pointer portion, wherein the first pointer portion of the first node is updated by storing a new pointer in a table in a memory separate from the flash memory, without deleting the first node from the data structure or the flash memory, when the first pointer portion cannot be updated by only setting bits in the pointer portion.
17. The non-transitory computer readable medium of claim 16 , wherein the command is specified by a client or by a controller of the flash memory and wherein the command is one of a compare and swap operation, or an OR operation.
The invention relates to a non-transitory computer-readable medium storing instructions for managing data in a flash memory system. The system addresses the challenge of efficiently performing atomic operations on flash memory, which is inherently slower and less flexible than traditional RAM due to its block-based architecture. The instructions enable the execution of specific commands, such as a compare-and-swap (CAS) operation or a bitwise OR operation, initiated either by a client device or a controller within the flash memory system. These operations are critical for ensuring data consistency and integrity in scenarios where multiple processes or devices may attempt concurrent access or modification of the same memory location. The CAS operation allows conditional updates by comparing a current value to an expected value before performing a swap, while the OR operation enables bitwise logical operations across memory locations. The system optimizes these operations to minimize latency and maximize throughput, particularly in distributed or multi-user environments where flash memory is used for storage or caching. The instructions further ensure compatibility with existing flash memory architectures while enhancing functionality for advanced data management tasks.
18. The non-transitory computer readable medium of claim 16 , wherein the data structure is one of a tree, a graph, a linked list, a Bloom filter, a hash table, or an array.
The invention relates to data structures used in computer systems for efficient data storage and retrieval. The problem addressed is the need for flexible and scalable data organization methods that can adapt to different types of data and access patterns. The invention provides a non-transitory computer-readable medium containing instructions for implementing a data structure that can be configured as a tree, graph, linked list, Bloom filter, hash table, or array. These structures are used to store and manage data in a way that optimizes performance for specific operations, such as searching, insertion, or deletion. The choice of data structure depends on the application requirements, such as the need for fast lookups, memory efficiency, or support for complex relationships between data elements. The invention allows systems to dynamically select or switch between these structures based on runtime conditions, improving adaptability and efficiency in data processing tasks. The solution enhances the versatility of data management systems by providing multiple structural options within a unified framework.
19. The non-transitory computer readable medium of claim 16 , the method further comprising: inserting a new node at an end of the data structure, wherein a pointer portion of the new node is configured to be overwritten when the new node is inserted at the end of the data structure; inserting the new node in a middle of the data structure between a second node and a third node, wherein a pointer portion of the second node is overwritten such that the pointer portion of the second node points to the new node and wherein the pointer portion of the new node is overwritten to point to the third node.
20. The non-transitory computer readable medium of claim 16 , the method further comprising: deleting a node between a second node and a third node, and, when deleting the node, overwriting a pointer portion of the second node with a pointer to point to the third node when possible or setting the pointer portion of the second node as invalid and writing the pointer to the third node and associated with the second node to the table in the memory; and/or traversing the data structure, wherein pointers are accessed from the pointer portions of the nodes to find the next node or wherein the pointers are accessed from the table in memory when the pointer portions of any of the nodes are invalid.
This invention relates to data structures and methods for managing nodes in a linked data structure, particularly focusing on efficient node deletion and traversal. The problem addressed is the inefficiency in traditional linked data structures when nodes are deleted, as it often requires updating multiple pointers or maintaining complex reference mechanisms. The solution involves a system where nodes in a linked data structure can be deleted while minimizing pointer updates. When a node is deleted, the pointer from the preceding node (second node) is either directly updated to point to the following node (third node) if possible, or the pointer is marked as invalid, and the new pointer to the third node is stored in a separate table in memory. During traversal, the system checks the pointer portions of nodes. If a pointer is valid, it is used to find the next node. If a pointer is invalid, the system retrieves the correct pointer from the table in memory. This approach reduces the overhead of pointer updates during deletion while ensuring efficient traversal. The method ensures that the data structure remains consistent and traversable even after deletions, improving performance in dynamic environments where frequent insertions and deletions occur.
Unknown
March 2, 2021
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.