Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A computing device having a processor and a memory, the memory storing computer-executable instructions executable by the processor to cause the computing device to: execute, with the processor, a software application at the computing device, thereby modifying a parameter values of corresponding state information of the software application persistently stored in the computing device as a data item in a first copy of a distributed data structure having the data item and multiple additional data items holding additional parameter values and with pointers pointing to each of the data item and the multiple additional data items; and in response to modifying the data item in the first copy of the distributed data structure, generate and transmit, at the computing device, an instruction to another computing device interconnected to the computing device via a computer network while continue to execute the software application at the computing device, the another computing device containing a second copy of the distributed data structure storing another copy of the state information of the software application, the transmitted instruction containing the modified parameter value of the data item in the first copy and the pointer corresponding to the data item, wherein the instruction indicates to the another computing device to (i) perform the same modification to another data item in the second copy of the distributed data structure corresponding to the pointer in the transmitted instruction as that performed to the first copy of the distributed data structure and (ii) locking an entry corresponding to the pointer in the second copy of the distributed data structure to prevent other operations from being performed on the second copy of the distributed data structure.
This invention relates to distributed data synchronization in computing systems, specifically for maintaining consistent state information across multiple computing devices executing a shared software application. The problem addressed is ensuring that modifications to application state data are propagated and synchronized efficiently while preventing conflicts or inconsistencies between distributed copies of the data. The system involves a computing device with a processor and memory, where the memory stores executable instructions for running a software application. The application modifies parameter values of state information stored as a data item in a distributed data structure. This data structure includes multiple data items, each holding parameter values and interconnected via pointers. When a data item is modified in the first copy of the distributed data structure on the computing device, an instruction is generated and transmitted to another interconnected computing device over a network. This instruction contains the modified parameter value and the pointer to the data item, directing the receiving device to apply the same modification to its corresponding data item in a second copy of the distributed data structure. Additionally, the instruction locks the entry in the second copy to prevent other operations until the modification is complete, ensuring data consistency. The software application continues executing on the original device while the synchronization occurs. This approach enables real-time state synchronization across distributed systems while minimizing conflicts and maintaining data integrity.
2. The computing device of claim 1 , wherein the memory contains additional computer-executable instructions executable by the processor to cause the computing device to: receive a confirmation from the another computing device, the confirmation indicating that the modification is performed on the second copy stored on the another computing device.
This invention relates to computing systems that manage data synchronization between multiple devices. The problem addressed is ensuring reliable and consistent updates to shared data across distributed computing environments, particularly when modifications are made to replicated copies of data stored on different devices. The system involves a computing device with a processor and memory storing executable instructions. The device is configured to detect a modification to a first copy of data stored locally and then transmit a request to another computing device to perform the same modification on a second copy of the data stored on that device. The system further includes functionality to receive a confirmation from the other device verifying that the requested modification was successfully applied to the second copy. This confirmation mechanism ensures that changes are properly propagated and synchronized across all relevant devices, maintaining data consistency in distributed systems. The solution is particularly useful in collaborative environments where multiple users or devices may independently modify shared data, requiring robust synchronization protocols to prevent conflicts and ensure integrity.
3. The computing device of claim 1 , wherein the memory contains additional computer-executable instructions executable by the processor to cause the computing device to: receive a confirmation from the another computing device, the confirmation indicating that the modification is performed on the second copy stored on the another computing device, and wherein the confirmation includes a conditional result.
A computing device is configured to manage data synchronization between multiple devices. The device includes a processor and memory storing executable instructions. The instructions enable the device to create a first copy of data and transmit it to another computing device, which stores a second copy. The device then receives a confirmation from the other device indicating that a modification has been performed on the second copy. This confirmation includes a conditional result, which may represent the outcome of applying the modification or a validation status. The system ensures data consistency by verifying that changes made to the second copy are properly reflected and validated. This approach is useful in distributed computing environments where multiple devices need to maintain synchronized copies of data, such as in collaborative applications, cloud storage systems, or peer-to-peer networks. The conditional result allows the device to assess whether the modification was successfully applied or if further action is required, improving reliability in data synchronization processes.
4. The computing device of claim 1 , wherein the memory contains additional computer-executable instructions executable by the processor to cause the computing device to: generate and transmit a commit instruction to the another computing device, the commit instruction indicating to the another computing device to persistently store the modified second copy on the another computing device.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of data. The problem addressed is ensuring data consistency and reliability across distributed systems, particularly when modifications are made to a copy of data on one device and need to be propagated and persisted on another device. The system includes at least two computing devices, each storing a copy of the same data. When a modification is made to a first copy on one device, the system generates and transmits a commit instruction to another computing device. This commit instruction directs the other device to persistently store the modified second copy, ensuring that changes are reliably saved and synchronized across the distributed system. The commit instruction may include metadata or validation information to confirm the integrity of the modified data before persistence. The system may also include mechanisms to handle conflicts, network failures, or device unavailability during the commit process. The overall goal is to maintain data consistency and availability in distributed environments where multiple devices may independently modify shared data.
5. The computing device of claim 1 , wherein the memory contains additional computer-executable instructions executable by the processor to cause the computing device to: receive a confirmation from the another computing device, the confirmation indicating that the modification is performed on the second copy on the another computing device; and generate and transmit a commit instruction to the another computing device based on the received confirmation, the commit instruction indicating to the another computing device to persistently store the modified second copy on the another computing device.
A computing device is configured to manage data synchronization between multiple devices, particularly in distributed systems where data consistency must be maintained. The device includes a processor and memory storing executable instructions. The system addresses the challenge of ensuring that modifications to data are properly synchronized and committed across multiple devices without data loss or inconsistency. The computing device receives a confirmation from another computing device, verifying that a modification has been applied to a second copy of the data stored on that device. Upon receiving this confirmation, the computing device generates and transmits a commit instruction to the other device, directing it to persistently store the modified second copy. This ensures that the changes are finalized and retained in a durable storage medium, maintaining consistency across the distributed system. The process involves validating the modification before committing it, reducing the risk of incomplete or conflicting updates. This mechanism is particularly useful in collaborative environments where multiple users or systems may access and modify shared data.
6. The computing device of claim 1 wherein: the first and second copies of the state information include first and second copies of one of a distributed blocking queue or a distributed queue slim.
A computing device is configured to manage state information in a distributed computing environment, particularly for data structures like distributed blocking queues or distributed queue slims. These data structures are used to coordinate tasks across multiple nodes in a distributed system, ensuring thread-safe operations and preventing race conditions. The challenge addressed is maintaining consistency and reliability of state information across distributed nodes, which is critical for fault tolerance and performance in large-scale systems. The computing device includes a processor and memory storing state information for a distributed data structure. The state information is replicated across multiple nodes to ensure redundancy and availability. The device generates and maintains first and second copies of the state information, where each copy corresponds to either a distributed blocking queue or a distributed queue slim. A distributed blocking queue is a thread-safe data structure that allows multiple threads to enqueue and dequeue elements while blocking when the queue is empty or full. A distributed queue slim is a more lightweight version, optimized for performance with fewer synchronization overheads. The device ensures that operations on these queues are consistent and atomic, even in the presence of network partitions or node failures. This is achieved through replication and synchronization mechanisms that propagate state updates across nodes. The system may also include mechanisms to detect and resolve conflicts or inconsistencies between the replicated state copies. The overall goal is to provide a reliable and efficient way to manage shared state in distributed systems, supporting high-throughput and low-latency operations.
7. The computing device of claim 1 wherein the memory contains additional computer-executable instructions executable by the processor to cause the computing device to: generate and transmit an instruction to enqueue a data item to the second copy of the distributed data structure on the another computing device.
A computing device is configured to manage distributed data structures across multiple computing devices in a network. The device includes a processor and memory storing computer-executable instructions. The instructions enable the device to maintain a primary copy of a distributed data structure and a secondary copy on another computing device. The device synchronizes changes between the primary and secondary copies to ensure data consistency. Additionally, the device can generate and transmit instructions to enqueue a data item to the secondary copy on the remote computing device, facilitating distributed data processing and storage. This system addresses challenges in maintaining consistency and availability of distributed data structures in networked environments, particularly in scenarios requiring fault tolerance and high availability. The solution ensures that data modifications are propagated efficiently across distributed copies, reducing the risk of data loss or inconsistency. The device may also include mechanisms to handle conflicts, network failures, and latency, ensuring reliable synchronization even under adverse conditions. The overall system enhances scalability and reliability in distributed computing environments.
8. The computing device of claim 1 wherein the memory contains additional computer-executable instructions executable by the processor to cause the computing device to: generate and transmit an instruction to dequeue a data item from the second copy of the distributed data structure on the another computing device.
A computing device is configured to manage distributed data structures across multiple computing devices in a network. The device includes a processor and memory storing computer-executable instructions. The instructions enable the device to maintain a first copy of a distributed data structure and communicate with another computing device that maintains a second copy of the same distributed data structure. The device can synchronize data between the copies, ensuring consistency across the network. Additionally, the device can generate and transmit an instruction to dequeue a data item from the second copy of the distributed data structure on the other computing device. This allows for coordinated access and modification of shared data in a distributed system, addressing challenges in maintaining data consistency and availability in environments where multiple devices interact with the same data structure. The system ensures efficient and reliable data management by enabling remote operations on distributed copies of the data structure.
9. A method performed in a computing facility having first and second computing devices individually having a processor, the method comprising: executing a software application at the first computing device to perform a modification to a first copy of state information associated with the software application and stored in the first computing device, wherein the first copy of state information includes a first copy of a distributed data structure and contains a changed parameter value produced by the executed software application as a data item in the distributed data structure having a corresponding pointer; and in response to the changed parameter value in the data item of the first copy of the state information at the first computing device, while continue to execute the software application at the first computing device, transmitting, from the first computing device to a second computing device interconnected to the first computing device via a computer network, data representing the changed parameter value and the pointer corresponding to the data item holding the changed parameter value, the second computing device storing a second copy of the same state information associated with the software application executing on the first computing device; and generating and transmitting, from the first computing device to the second computing device, an instruction to the second computing device to (i) perform the same modification to another data item in the second copy of the distributed data structure corresponding to the pointer as that performed to the first copy of the distributed data structure and (ii) locking an entry corresponding to the pointer in the second copy of the distributed data structure to prevent other operations from being performed on the second copy of the distributed data structure; and in response to and in accordance with the transmitted instruction, at the second computing device, performing the same modification to another parameter value in another data item in the second copy of the state information on the second computing device according to the pointer as that performed to the first copy of the state information on the first computing device while locking the entry corresponding to the pointer.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information for a software application. The problem addressed is ensuring consistency and preventing conflicts when modifications are made to shared state information across distributed systems. The invention provides a method for synchronizing changes to a distributed data structure stored in multiple computing devices while maintaining data integrity and preventing concurrent modifications. The method involves a first computing device executing a software application that modifies a local copy of state information, including a distributed data structure. When a parameter value in the data structure is changed, the first computing device transmits the changed value and a corresponding pointer to a second computing device, which stores a synchronized copy of the same state information. The first computing device also sends an instruction to the second computing device to apply the same modification to the corresponding data item in its local copy of the data structure, identified by the pointer. Additionally, the second computing device locks the entry corresponding to the pointer to prevent other operations from being performed on that data item until the modification is complete. This ensures that both computing devices maintain consistent state information while avoiding conflicts from concurrent modifications. The method allows the software application to continue executing on the first computing device while synchronization occurs in the background.
10. The method of claim 9 , further comprising: receiving, at the first computing device, a confirmation from the second computing device, the confirmation indicating that the modification is performed successfully on the second copy of the state information stored on the second computing device.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information. The problem addressed is ensuring reliable and consistent updates across distributed systems, particularly when modifications are made to shared state data. The invention provides a method for verifying that a modification to state information on one computing device is successfully applied to a corresponding copy on another computing device. The method involves a first computing device initiating a modification to its local copy of state information and then sending a request to a second computing device to apply the same modification to its copy. The second computing device processes the request and performs the modification. Upon successful completion, the second computing device sends a confirmation back to the first computing device, indicating that the modification was applied correctly. This confirmation step ensures that both devices maintain synchronized state information, reducing inconsistencies in distributed systems. The method may include additional steps such as error handling if the modification fails on the second device, ensuring robustness in the synchronization process. This approach is particularly useful in applications requiring high reliability, such as financial systems, distributed databases, or real-time collaborative environments.
11. The method of claim 9 , further comprising: receiving, at the first computing device, a confirmation as a conditional result from the second computing device, the confirmation indicating that the modification is performed successfully on the second copy of the state information stored on the second computing device.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information. The problem addressed is ensuring reliable and consistent updates across distributed systems, particularly when modifications to state information must be propagated and confirmed between devices to prevent data inconsistencies. The method involves a first computing device initiating a modification to state information stored on a second computing device. The first computing device sends a request to the second computing device to apply the modification to a second copy of the state information. The second computing device processes the request and performs the modification if conditions are met, such as validation checks or availability of resources. Upon successful execution, the second computing device sends a confirmation back to the first computing device, indicating that the modification was applied to the second copy of the state information. This confirmation serves as a conditional result, verifying that the update was successfully propagated and stored on the second computing device. The method ensures that the first computing device can rely on the confirmation to maintain consistency between the state information copies across the distributed system. This approach is particularly useful in scenarios requiring high reliability, such as financial transactions, distributed databases, or real-time collaborative systems.
12. The method of claim 9 , further comprising: generating and transmitting, at the first computing device, a commit instruction to the second computing device, the commit instruction indicating to the second computing device to persistently store the second copy of the state information with the modification on the second computing device.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information. The problem addressed is ensuring reliable and consistent updates to shared state data across distributed systems, particularly when one device modifies its local copy and needs to propagate those changes to another device while ensuring persistence. The method involves a first computing device that has modified its local copy of state information. The first device generates and transmits a commit instruction to a second computing device. This commit instruction directs the second device to persistently store its own copy of the state information, which includes the modifications made by the first device. The process ensures that changes are not only synchronized but also permanently recorded on the second device, preventing data loss or inconsistency. This is particularly useful in scenarios where distributed systems must maintain data integrity across multiple nodes, such as in cloud computing, blockchain, or database replication systems. The method may be part of a broader synchronization protocol that includes verifying the integrity of the modified state before committing it to persistent storage.
13. The method of claim 9 , further comprising: receiving, at the first computing device, a confirmation from the second computing device, the confirmation indicating that the modification is performed successfully on the second copy of the state information stored on the second computing device; and generating and transmitting, at the first computing device, a commit instruction to the second computing device based on the received confirmation, the commit instruction indicating to the second computing device to persistently store the second copy of the state information with the modification on the second computing device.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information. The problem addressed is ensuring reliable and consistent updates to state information across distributed systems, particularly when modifications are made to a primary copy on one device and need to be propagated and confirmed on a secondary device. The method involves a first computing device that modifies its local copy of state information and then transmits the modification to a second computing device. The second computing device applies the modification to its own copy of the state information and sends a confirmation back to the first computing device. Upon receiving this confirmation, the first computing device generates and transmits a commit instruction to the second computing device, instructing it to persistently store the modified state information. This ensures that the modification is only finalized after successful application and confirmation, maintaining data consistency across the distributed system. The method may also include additional steps such as detecting conflicts, resolving discrepancies, or rolling back changes if the modification fails on the second device. The approach improves reliability in distributed systems by enforcing a two-phase commit process, where changes are only made permanent after verification.
14. A method performed in a computing facility having a plurality of computing devices interconnected via a communications network, the method comprising: executing a software application at a computing device of the computing facility, thereby resulting in a change to a portion of a copy of state information associated with the software application and persistently stored at the computing device in a distributed data structure, the copy of the state information containing one or more parameter values produced or modified by the executed software application; and in response to the resulted change to the portion of the copy of the state information persistently stored at the computing device, automatically replicating, from the computing device to one or more other computing devices in the computing facility, the change to the portion of the copy of state information to the one or more other computing devices in the computing facility while continue to execute the software application at the computing device, the one or more other computing devices individually persistently storing a copy of the state information associated with the software application executing on the computing device, wherein automatically replicating includes: transmitting data representing the change and a pointer corresponding to the change in the distributed data structure to the one or more other computing devices; and along with the data, transmitting an instruction to lock an entry corresponding to the pointer in the distributed data structure of the individual copies of the state information at the one or more other computing devices while replicating the change to the individual copies of the statement information.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information for a software application. The problem addressed is ensuring consistency and availability of application state across a networked computing facility while minimizing disruption to ongoing operations. The method involves executing a software application on a computing device, which modifies its local copy of state information stored in a distributed data structure. When changes occur, the system automatically replicates those changes to other computing devices in the facility while continuing application execution. Each device maintains its own persistent copy of the state information. Replication involves transmitting the changed data, a pointer to the change location in the distributed data structure, and an instruction to lock the corresponding entry during replication. This locking mechanism prevents conflicts by ensuring the change is applied consistently across all copies. The approach enables real-time synchronization of application state without interrupting ongoing computations, improving fault tolerance and data consistency in distributed environments.
15. The method of claim 14 , further comprising: receiving, from the one or more other computing devices, one or more confirmation indicating a success in replicating the change to the copies of the state information stored individually on the one or more computing devices; and transmitting another instruction to the one or more other computing devices, the another instruction indicating to the one or more other computing devices to persistently store the copies of the state information with the change on the one or more other computing devices.
This invention relates to distributed computing systems where state information is replicated across multiple computing devices to ensure consistency and reliability. The problem addressed is maintaining synchronized state information across a network of devices, particularly when changes occur, to prevent data inconsistencies or failures. The method involves a primary computing device managing state information that is replicated on one or more other computing devices. When a change to the state information is made, the primary device transmits an instruction to the other devices to replicate the change. After receiving confirmation from the other devices that the change has been successfully replicated, the primary device sends another instruction directing the other devices to persistently store the updated state information. This ensures that all devices maintain an identical and consistent state, reducing the risk of data corruption or loss. The process includes verifying successful replication before committing changes, which enhances reliability in distributed systems. This approach is useful in applications requiring high availability and fault tolerance, such as databases, cloud computing, or distributed ledger systems. The method ensures that state changes are propagated and stored consistently across all participating devices.
16. The method of claim 14 wherein the copies of the state information include copies of one of a distributed dictionary, a distributed versioned dictionary, a distributed blocking data structure, a distributed data structure slim, a distributed stack, or a distributed bag.
This invention relates to distributed computing systems and addresses the challenge of efficiently managing and synchronizing state information across multiple nodes in a distributed environment. The method involves replicating state information across nodes to ensure consistency and availability, even in the presence of failures or network partitions. The state information includes copies of various distributed data structures, such as a distributed dictionary, a distributed versioned dictionary, a distributed blocking data structure, a distributed data structure slim, a distributed stack, or a distributed bag. These structures enable concurrent access and modification by multiple nodes while maintaining data integrity. The distributed dictionary allows key-value pair storage and retrieval, while the versioned dictionary tracks changes over time. The blocking data structure ensures thread-safe operations, and the slim variant optimizes performance. The distributed stack supports last-in-first-out operations, and the distributed bag handles unordered collections. The method ensures that updates to these structures are propagated reliably across the network, enabling fault tolerance and high availability in distributed systems. This approach is particularly useful in applications requiring scalable, consistent, and resilient data management, such as distributed databases, cloud computing, and real-time collaborative systems.
17. The method of claim 14 wherein automatically replicating the change is asynchronous to other processes performed by the computing device.
A system and method for managing data replication in a computing environment addresses the challenge of maintaining data consistency across distributed systems while minimizing performance overhead. The invention provides a mechanism for automatically replicating changes to data in a storage system, ensuring that updates are propagated to secondary storage locations without disrupting ongoing operations. The replication process is designed to operate asynchronously, meaning it does not block or delay other processes running on the computing device. This asynchronous approach allows the system to handle high volumes of data changes efficiently, reducing latency and improving overall system responsiveness. The method involves detecting a change to data in a primary storage location, then automatically replicating that change to one or more secondary storage locations without requiring manual intervention. The asynchronous nature of the replication ensures that the primary system remains available for other tasks, such as user requests or background processes, while replication occurs in the background. This solution is particularly useful in distributed computing environments, cloud storage systems, and databases where data consistency and availability are critical. The invention improves upon prior art by decoupling the replication process from the primary system's workload, thereby enhancing performance and reliability.
18. The method of claim 14 , further comprising: receiving, at the computing device, a confirmation from the one or more other computing devices, the confirmation indicating that the modification is performed successfully on the copy of the state information stored on the one or more other computing devices.
Digital device synchronization. Problem: Ensuring consistent state information across multiple computing devices after a modification. This invention describes a method for confirming successful state information modification on distributed devices. A computing device receives a confirmation message. This confirmation originates from one or more other computing devices. The confirmation specifically indicates that a modification has been successfully applied to a copy of state information residing on those other computing devices. This ensures that all participating devices have updated and synchronized state information, preventing data discrepancies.
19. The method of claim 14 , further comprising: receiving, at the computing device, a confirmation as a conditional result from the one or more other computing devices, the confirmation indicating that the modification is performed successfully on the second copy of the state information stored on the one or more other computing devices.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information. The problem addressed is ensuring reliable and consistent updates across distributed systems, particularly when modifications to state information must be validated and confirmed by other devices before being finalized. The method involves a computing device initiating a modification to its local copy of state information and then sending a request to one or more other computing devices to apply the same modification to their copies. The other devices process the request and, if successful, return a confirmation to the initiating device. The confirmation indicates that the modification has been successfully applied to the second copies of the state information stored on the other devices. This confirmation step ensures that all devices in the distributed system have consistently updated their state information before the modification is considered complete. The method may also include handling cases where confirmations are not received, such as due to network issues or device failures, to maintain system reliability. The approach is particularly useful in applications requiring high availability and data consistency, such as distributed databases, blockchain systems, or replicated state machines.
20. The method of claim 9 , further comprising: generating and transmitting, at the computing device, a commit instruction to the one or more other computing devices, the commit instruction indicating to the one or more other computing devices to persistently store the corresponding copy of the state information with the modification on the one or more other computing devices.
This invention relates to distributed computing systems where multiple computing devices maintain synchronized copies of state information. The problem addressed is ensuring consistent and reliable updates to shared state across distributed systems, particularly when modifications are made to the state information. The invention provides a method for coordinating state modifications among multiple computing devices to ensure that all devices persistently store the updated state information. The method involves a computing device receiving a modification to state information and then generating and transmitting a commit instruction to one or more other computing devices. The commit instruction directs the other computing devices to persistently store their corresponding copies of the state information, including the modification. This ensures that all devices in the distributed system maintain an up-to-date and consistent version of the state. The method may also include steps for validating the modification, such as verifying that the modification is valid or that the computing device has permission to make the modification. Additionally, the method may involve transmitting a notification to the other computing devices indicating that the modification has been made, allowing them to update their local copies accordingly. The invention improves reliability and consistency in distributed systems by ensuring that all devices commit the same state updates.
Unknown
February 11, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.