Batch Logic Translator for Service Invocation Aggregation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The current network communication and service invocation scenarios in computer servers result in delays and resource inefficiencies due to the serial processing of service invocations, which are costly in terms of time and resources, especially when clients heavily utilize services in a serial manner.
Innovation Solution
The solution involves translating service invocations from non-batch capable languages into batch-capable languages, allowing for the processing of multiple invocations as a batch, reducing the overhead of serialization, deserialization, network transport, and connection management by using techniques like automated translation during compilation or through runtime intermediaries like local proxies.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If service invocations are processed serially one by one, then each invocation can be handled independently and simply, but the overall processing time and resource consumption increase significantly
Solution Approach 1:
The patent combines multiple service invocations into a single batch request that is translated and executed together. The batch logic generator aggregates multiple individual invocations and translates them into a unified batch operation, allowing the server to process multiple invocations simultaneously rather than sequentially, thereby reducing total processing time while maintaining operational simplicity through automated translation.
Solution Approach 2:
The patent introduces a batch logic generator and translator as an intermediary component between the client and server. This intermediary automatically translates multiple service invocations from the client's programming language into batch-capable language syntax, enabling batch processing without requiring changes to the client's existing codebase. The intermediary handles the complexity of translation and batching automatically.
2Productivity
If multiple service invocations are processed as a batch, then the overhead of serialization, deserialization, network transport, and connection management is reduced, but the system must support translation between different programming languages
Solution Approach 1:
The patent implements a universal batch logic generator that can accept service invocations written in multiple different programming languages and translate them into a common batch-capable internal representation. This multi-functional translator handles various programming languages (e.g., C++, Java, Python) and converts them into a unified batch processing format, enabling the system to maintain high processing efficiency while supporting language diversity through a single universal translation layer.
3Ease of manufacture
If each service invocation is handled as an individual request, then the client code remains simple and unchanged, but the server must manage multiple separate connections and transactions
Solution Approach 1:
The batch logic generator acts as an intermediary that sits between the simple client code and the server's connection management layer. It automatically collects multiple invocations from the client, translates them into batch format, and presents them as a single unified request to the server. This shields the server from the complexity of managing multiple individual connections and transactions, while the client continues to write simple, unchanged code in its preferred programming language.
Data Source
AI summary
The utilization of data services (such as web services) may involve the invocation of services, which may reduce performance and overburden the server. In some scenarios, the invocation may be specified in a language that does not support batch invocation, but it may not be feasible to re-code the invocations in a language that supports batching. Instead, the service invocations may be automatically translated into a batch logic specified in a batch-capable language and sent to the service as a batch. For example, a local proxy may receive a language-integrated query having two or more service invocations, compile the query into an expression tree including the two or more invocations, and send the expression tree to the service host to achieve the batch processing of the service invocations.