Grid Application Proxy Distribution for Non-Distributed Software
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Grid computing applications face performance limitations due to the inability to efficiently distribute and execute performance-critical components across a network without modifying existing application code, leading to suboptimal resource utilization and efficiency.
Innovation Solution
The method involves identifying isolatable components within a non-distributed software application, replacing them with proxies, and distributing these components across a grid network, allowing for independent execution on separate compute resources, with communication between proxies and stubs ensuring seamless operation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If non-distributed software application components are distributed across grid network compute resources, then performance and resource utilization are improved, but application complexity and deployment difficulty increase
Solution Approach 1:
The patent segments a non-distributed software application into isolatable components that can be independently distributed across multiple compute resources in a grid network. The byte code analyzer identifies components suitable for separation, allowing the application to be executed across distributed resources while maintaining functional integrity.
Solution Approach 2:
The patent introduces proxies as intermediary elements that facilitate communication between the main application execution environment and distributed component execution environments. These proxies enable seamless interaction without requiring modifications to the original application code, resolving the complexity issue while maintaining distribution benefits.
2Adaptability or versatility
If existing application code is modified to enable distribution, then component distribution capability is improved, but application maintenance and compatibility become more difficult
Solution Approach 1:
The patent uses proxies as intermediaries that are introduced into the application without modifying the original source code. These proxies act as adapters that enable distributed execution while preserving the original application's integrity, making maintenance and compatibility management straightforward.
Solution Approach 2:
The patent creates copies of isolatable components and their corresponding proxies, allowing the original application to remain unchanged while distributed versions execute on remote compute resources. This copying approach enables distribution capability without affecting the original codebase.
3Productivity
If isolatable components are distributed to separate compute resources, then resource utilization is improved, but network dependency and execution reliability may deteriorate
Solution Approach 1:
The patent implements error handling and fallback mechanisms that are prepared in advance. When network issues or execution failures occur on distributed compute resources, the system has pre-configured contingency plans to handle these scenarios, maintaining reliability despite network dependencies.
4Speed
If critical components are executed on optimized remote resources, then execution speed is improved, but network latency and connection requirements increase
Solution Approach 1:
The patent performs preliminary actions by distributing components and establishing proxy connections before the actual execution of the application. This preparation work is done in advance, so that when the application runs, the distributed components are already in position and ready for immediate execution, minimizing runtime network latency.
Data Source
AI summary
A method includes identifying a component within a non-distributed grid-enabled software application that can be isolated and independently executed during an execution of the software application on a first compute resource within a grid network, replacing the isolatable component in the software application with a proxy, and executing the software application on the first compute resource with the isolated component executing on a second compute resource.


