RPC Side Channels for Concurrent State Updates
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In interactive applications like multiplayer games, existing tools for remote procedure calls (RPCs) typically return only a single result or value, making it inefficient for client devices to receive frequent updates about the application state, as they need to make periodic calls to get updates, and do not provide a flexible way to handle additional information.
Innovation Solution
A method that wraps the return result and side channel data object into a single return result data object, allowing for the efficient exchange and processing of updates, including non-responsive information, using a side channel class to instantiate a side channel data object with updates for the interactive system, which can be processed out-of-band by a generic handler.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If RPC frameworks return only a single result or value, then the return type is simple and easy to handle, but client devices cannot efficiently receive multiple updates about the application state
Solution Approach 1:
The return value is segmented into multiple distinct components: a primary return result and multiple side channel data objects. Each side channel data object contains specific types of updates (e.g., game state updates, player information, environment changes). This segmentation allows the system to return multiple types of information in a single RPC response while maintaining clear organization and type safety for each component.
Solution Approach 2:
The side channel data objects are nested within the main return result data structure. The return value contains a primary result field and multiple side channel fields, each potentially containing complex nested structures. This nesting approach allows multiple levels of data to be returned efficiently while maintaining a hierarchical organization that facilitates selective processing of different data types.
2Loss of information
If client devices make periodic calls to receive updates, then all updates can be received, but the approach is inefficient and increases network traffic
Solution Approach 1:
The server performs preliminary action by proactively generating and including all relevant updates in the side channel data objects within each RPC response. Instead of waiting for client requests, the server prepares comprehensive update packages that contain all changes that occurred since the last interaction, including game state changes, player actions, and environment updates. This eliminates the need for separate periodic status check calls.
Solution Approach 2:
The side channel mechanism enables continuous information flow from server to client within the existing RPC interaction pattern. Each RPC call naturally carries forward all accumulated updates, maintaining a continuous stream of application state information without requiring interruptive periodic polling. This creates a seamless update mechanism that operates continuously as part of the normal application flow.
3Loss of information
If multiple values are returned in response to multiple requests, then all information can be conveyed, but the invoker must explicitly handle all returned data without flexibility
Solution Approach 1:
The side channel data object structure serves multiple functions simultaneously: it carries game state updates, player information, environment changes, and other application-specific data all within a single unified structure. The generic handler can process different types of side channel data using the same interface, while allowing specific modules to extract only the data types they need. This multi-functionality provides both completeness of information and flexibility in handling.
Solution Approach 2:
The side channel data objects act as intermediaries between the server's comprehensive data generation and the client's selective data processing. Rather than requiring the invoker to directly handle all returned data, the structured side channels provide an intermediary layer that organizes information by type and enables generic processing. Modules can interact with the side channels at their own level of abstraction, extracting only relevant information while leaving other data to be processed by specialized handlers.
4Reliability
If exceptions are returned in typical RPC style, then errors can be communicated, but updates cannot be provided alongside error information
Solution Approach 1:
The return structure is segmented into independent error handling and update provision components. The primary return result can contain error information (exception codes, error messages) while side channel data objects simultaneously contain application state updates. This segmentation allows error communication and update provision to occur in parallel without interfering with each other, enabling the system to maintain reliability for error reporting while preserving completeness of information delivery.
Solution Approach 2:
Error information and update information are merged into a single comprehensive RPC response structure. Rather than separating error handling from data return, the system combines both types of information in one response package. The primary result field can carry error codes while side channel fields carry updates, allowing the client to process both error conditions and state changes in a unified handling routine.
Data Source
AI summary
Systems and methods for exchanging information in a distributed computing system implementing an interactive application, such as a location-based parallel reality game, are provided. In particular, the subject matter of the present disclosure provides an alternative approach for providing and processing return results from a remote procedure call (RPC) by which remote computing systems (e.g. a game server and a remote client) send requests and responses to one another. Rather than providing a single return result in response to a single request as in typical remote procedure calls, information about updates to the state of the interactive application, such as updates to game status, can be returned via side channels which are handled generically while passing the main return result of the invoked service directly back to the caller.