Multi-Instance Software Shadow System for Resource Redundancy Reduction
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Highly scalable multi-instance software systems in modern web-enabled technologies face challenges in managing executable files, including sharing, redundancy, speed of execution, and storage requirements, leading to resource overhead and high marginal costs in traditional deployment methods.
Innovation Solution
A system and method that allows multiple instances of computer software to share significant portions of software metadata and code, using a multi-instance share-what-is-possible system, which intercepts file access calls and reroutes them to a single actual file on disk, enabling customization while reducing resource allocation and costs.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If multiple copies of software code are deployed for each application instance, then customization and logical isolation are enabled, but storage requirements and resource overhead increase significantly
Solution Approach 1:
The patent merges multiple application instances by allowing them to share a common codebase stored as a single file on disk. Multiple virtual instances are created through file access interception and rerouting, where each instance can access the same physical code file but with instance-specific customizations applied through overlay mechanisms. This combining approach eliminates redundant code storage while maintaining instance independence.
Solution Approach 2:
The patent creates virtual copies of the software instance through file access interception rather than physical duplication. When an application instance requests to access code, the system intercepts the file access call and reroutes it to share the common codebase, creating a virtual copy effect without duplicating the actual code files. This allows multiple instances to exist with minimal storage overhead.
2Adaptability or versatility
If multiple copies of software code are deployed for each application instance, then instance independence and customization are achieved, but hardware resource utilization decreases
Solution Approach 1:
The system merges the code execution layer across multiple instances by implementing a shared codebase that is intercepted and rerouted to a single physical file. This merging eliminates redundant code loading into memory and reduces CPU cycles spent on duplicate operations, thereby improving hardware resource utilization while maintaining instance independence through virtualization mechanisms.
Solution Approach 2:
The common codebase serves multiple functions simultaneously by being shared across numerous application instances. A single code file on disk serves as the execution source for multiple virtual instances, each capable of independent operation and customization. This multi-functionality approach maximizes hardware resource utilization by having one code artifact serve many purposes.
3Ease of operation
If traditional file system management is used for multi-instance applications, then simplicity is maintained, but execution speed and redundancy management suffer
Solution Approach 1:
The patent introduces a file access interception and rerouting mechanism as an intermediary layer between the application instances and the physical file system. This intermediary component captures file access calls from multiple instances and redirects them to the shared codebase, enabling efficient code sharing without requiring complex file system changes. The intermediary handles the complexity of redundancy management while maintaining a simple underlying file system structure.
Data Source
AI summary
A system and method are provided that allows, by adding a loadable module to the language runtime engine and overriding some of the core engine's operating system access functionality, the system to create a customizable copy of the installed application without creating complete copies of the actual files (scripts, executables, binaries, etc.) and without redundancies in content storage.