Off-the-shelf Software Component Reuse in Cloud Computing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional cloud computing systems waste resources due to the replication of software components across virtual machines, limiting the scalability and efficiency of distributed computing environments, as they do not allow off-the-shelf software to be distributed across nodes without special rebuilds or versions, and fail to enable balanced component deployment across nodes.
Innovation Solution
A distributed data processing method that allows off-the-shelf software to execute across multiple nodes using a thunk layer for inter-process communication and remote procedure calls, eliminating the need for hardware virtualization by redirecting calls between components and managing shared virtual memory, thereby conserving resources and enabling scalable distributed computing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If hardware virtualization is used to emulate off-the-shelf platforms on heterogeneous hardware, then system compatibility is improved, but resource waste occurs due to replication of software components across virtual machines
Solution Approach 1:
The patent merges software component instances across multiple virtual machines by implementing a shared memory mechanism. Instead of each VM having separate copies of software components, the system allows VMs to share common code segments and data structures in a unified address space, thereby reducing resource duplication while maintaining compatibility.
Solution Approach 2:
The patent creates universal software components that can be accessed by multiple virtual machines simultaneously. The shared memory structure enables a single software component to serve multiple VMs, making the system more efficient by eliminating the need for separate instances of the same software in each VM.
2Reliability
If each virtual machine has its own services and device drivers, then system reliability is improved, but resource efficiency deteriorates due to duplicative component deployments
Solution Approach 1:
The patent combines identical software components (services, device drivers, shared libraries) into a single shared memory space that multiple VMs can access. This merging maintains the functional independence and reliability of each VM while dramatically improving resource efficiency by eliminating duplicative deployments.
Solution Approach 2:
Instead of physical copying of software components to each VM, the patent implements virtual copying through memory mapping. VMs can access shared components through virtual address translations that map to the physical shared memory location, providing the illusion of local copies while actually sharing the same physical resources.
3Productivity
If conventional distributed operating system techniques are used, then distributed computing capability is improved, but off-the-shelf software cannot be distributed across nodes without special rebuilds
Solution Approach 1:
The patent introduces a thunk layer as an intermediary between conventional off-the-shelf software and the distributed computing environment. This thunk layer handles the complexity of cross-node communication and memory management, allowing standard software to be distributed across nodes without modification while maintaining the ability to invoke routines on remote computers.
Solution Approach 2:
The patent segments the software execution model into local and remote components. The thunk layer divides software routines into segments that can execute locally or be invoked remotely, enabling off-the-shelf software to be distributed across nodes without requiring special rebuilds or versions.
Data Source
AI summary
A computer-implemented distributed data processing method for a software application that includes no code that targets a distributed data processing system, the method comprising: executing a software application that has been designed with a single-node operation to operate in a distributed fashion by automatically arranging for components of the software application to execute across a plurality of nodes.