RPC Data Processing via Wrapper Function Shared Libraries
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current parallel distributed processing systems face challenges such as increased development burden due to the need for programmers to learn Interface Description Languages (IDL) for Remote Procedure Call (RPC) systems, limited language options, slower processing speeds with Java bytecodes, and the requirement for separate client and server-side program descriptions.
Innovation Solution
A data processing technique that allows functions with various arguments and return values to be executed on another computer device using a client-server system with a user function symbol name acquiring unit, a wrapper function pointer acquiring unit, and a communicating unit, which compiles user programs and wrapper functions as a shared library, enabling execution without the need for IDL descriptions and supporting languages like C or C++ for native code compilation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If IDL is used for RPC system, then communication between servers can be implemented, but the development burden increases and programmers need to learn a different language
Solution Approach 1:
The patent uses a code generator as an intermediary that automatically translates high-level function definitions into RPC-compatible code. This mediator handles the complexity of IDL-like descriptions, allowing programmers to work with familiar languages while the generator produces the necessary communication protocols and interface definitions.
Solution Approach 2:
The system enables self-service by allowing the RPC framework to automatically generate and manage interface descriptions from function definitions. The code generator creates all necessary IDL-equivalent structures, stub files, and communication handlers without requiring manual IDL writing, making the system configure itself based on programmer-provided function signatures.
2Reliability
If IDL is used for RPC system, then procedure calls can be made between servers, but programmers need to change IDL and guarantee consistency when function signatures change
Solution Approach 1:
The code generator performs preliminary actions by automatically updating all RPC interface definitions, stub files, and communication structures whenever a function signature changes. This preemptive regeneration ensures consistency across the entire distributed system without requiring manual synchronization or verification of multiple IDL files.
Solution Approach 2:
The system implements feedback mechanisms where the code generator monitors function definition changes and automatically triggers regeneration of RPC interfaces. This closed-loop approach ensures that any modification to function signatures is immediately reflected in the distributed communication layer, maintaining consistency through automated detection and correction.
3Ease of manufacture
If Java bytecodes are used for RPC, then no IDL description is needed, but the processing speed becomes slower
Solution Approach 1:
The patent changes the fundamental parameter of code representation by generating and compiling native code instead of using interpreted bytecodes. The code generator produces optimized machine code or compiled binaries that execute directly on the target platform, eliminating the performance overhead of bytecode interpretation while maintaining the ease of high-level language programming.
4Reliability
If separate client and server-side programs are described, then RPC functionality can be achieved, but the development burden increases
Solution Approach 1:
The patent merges the client and server program descriptions into a unified function definition that the code generator processes. Instead of requiring separate IDL files and program descriptions for each side, the system combines all RPC-related definitions into a single high-level interface that automatically generates both client and server stubs, reducing duplication and simplifying development.
Data Source
AI summary
A client (300) acquires a user function symbol name, acquires a pointer to a wrapper function, which is defined as a template function and internally executes the user function by designating the types of argument and return value of the user function as a template argument, and acquires a wrapper function symbol name of the wrapper function using the pointer to the wrapper function. A server (310) acquires, from the client, the user function symbol name, data corresponding to the arguments of the user function, the wrapper function symbol name, and a shared library user program in which the user program and the wrapper function are compiled as a shared library. The server executes the wrapper function within the shared library user program, which is specified by the pointer to the wrapper function, using the user function symbol name and the data corresponding to the arguments of the user function as arguments.