Source Code Compilation Into Service Modules for Parallel Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software development approaches often prioritize performance, scalability, or agility at the expense of others, leading to challenges in parallelization, data dependencies, and inefficient execution of imperative code.
Innovation Solution
Convert imperative source code into functional service modules by identifying data dependencies and immutability points, allowing for execution in a different order than specified, and scheduling tasks at runtime to optimize performance, scalability, and agility.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If imperative source code is executed in the specified order to maintain data dependency correctness, then reliability is improved, but productivity deteriorates due to inability to parallelize execution
Solution Approach 1:
The patent segments the imperative source code into multiple service modules based on identified immutability points. Each service module represents an independent unit of execution that can be scheduled separately. This segmentation enables parallel execution of independent modules while maintaining the correctness of data dependencies through the scheduler, thus resolving the contradiction between reliability and productivity.
Solution Approach 2:
The patent introduces a dynamic scheduler that determines the execution order of service modules at runtime based on data dependency analysis. Instead of rigidly following the original sequential order, the scheduler dynamically adjusts execution sequences to enable parallelization where safe, while preserving correctness where dependencies exist. This dynamic approach resolves the contradiction by adapting execution strategies to specific code characteristics.
2Productivity
If code is converted to service modules to enable parallelization and scalability, then productivity is improved, but device complexity worsens due to additional scheduling and dependency management infrastructure
Solution Approach 1:
The patent performs preliminary analysis of data dependencies and identification of immutability points during the code conversion phase, before runtime execution. This preliminary action creates a dependency graph and identifies safe parallelization boundaries in advance, reducing the complexity of runtime scheduling decisions. The scheduler only needs to execute pre-analyzed service modules according to established dependencies, rather than performing complex real-time analysis, thus resolving the contradiction between productivity and device complexity.
3Adaptability or versatility
If immutable data is identified to enable functional conversion, then agility is improved through flexible deployment, but measurement precision worsens due to difficulty in detecting immutability points
Solution Approach 1:
The patent employs feedback mechanisms where the system monitors runtime behavior to validate and refine immutability point identification. By observing actual execution patterns and data flow, the system can confirm whether identified immutability points are correct and adjust the dependency graph accordingly. This feedback loop improves measurement precision of immutability detection while maintaining the agility benefits of functional conversion, resolving the contradiction between adaptability and measurement precision.
Data Source
AI summary
This document relates to compilation of source code into services. One example method involves receiving input source code, identifying data dependencies in the input source code, and identifying immutability points in the input source code based at least on the data dependencies. The example method also involves converting at least some of the input source code occurring after the immutability points to one or more service modules.