Object Worker State Management in Distributed Cloud Networks

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing distributed database systems face challenges with global synchronization being slow as the number of nodes grows, and eventual consistency being difficult to implement correctly and error-prone.

Innovation Solution

A distributed cloud computing network that uses object workers, each with a single instantiation of code controlling access to an object, which can be automatically migrated to be close to accessing clients, ensuring efficient state management and object storage.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If a monolithic database model with global synchronization is used, then data consistency is maintained, but synchronization speed decreases as the number of nodes grows

Engineering Contradiction:
Improvedata consistencyVSAvoidsynchronization speed
Core Design Contradiction:
ReliabilityVSSpeed

Solution Approach 1:

The patent segments the monolithic database into multiple independent object stores distributed across different compute servers. Each object store is independently managed by object workers, eliminating the need for global synchronization while maintaining data consistency within each object's lifecycle through single-instance code control.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent introduces object workers as intermediary components that mediate between client requests and object stores. These object workers manage object lifecycle, handle requests locally, and coordinate with other workers through a standardized interface, reducing direct synchronization requirements between compute servers.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Reliability

If eventual consistency through merging changes is used, then high availability is achieved, but implementation complexity increases and errors become more common

Engineering Contradiction:
ImproveavailabilityVSAvoidimplementation complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The patent implements self-service through object workers that automatically manage their own lifecycle, request routing, and object state. Each object worker independently handles its assigned objects without requiring complex coordination protocols, simplifying implementation while maintaining high availability through automatic failover and load balancing.

Inventive Principle:
Principle #25Self-service

3Reliability

If object workers are distributed across multiple compute servers, then system availability increases, but access latency increases due to remote object storage

Engineering Contradiction:
Improvesystem availabilityVSAvoidaccess latency
Core Design Contradiction:
ReliabilityVSLoss of time

Solution Approach 1:

The patent applies local quality by allowing each compute server to cache frequently accessed objects locally in its object store, while still maintaining the distributed architecture. This enables fast local access for hot objects while preserving system availability through the distributed object worker network that can serve requests from any node.

Inventive Principle:
Principle #3Local quality

Data Source

PatentUS12284247B2State management and object storage in a distributed cloud computing network
Publication Date: 2025.04.22 CLOUDFLARE INC
  • US12284247B2 patent drawing
  • US12284247B2 patent drawing
  • US12284247B2 patent drawing

AI summary

A first compute server of a distributed cloud computing network receives a request from a first client device for an object to be handled by an object worker that includes a single instantiation of a piece of code that solely controls reading and writing access to the first object. A determination is made that the object worker is instantiated for the object and is currently running in the first compute server, and the piece of code processes the first request. The first compute server receives a message to be processed by the first object worker from a second compute server. The message includes a second request for the object from a second client device connected to the second compute server. The piece of code processes the message and transmits a reply to the second compute server.