Profile-Guided Mobile App Partitioning for Runtime Microservices
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing technologies face challenges in efficiently decomposing mobile applications into microservices for distributed execution, particularly in dynamic environments where resource allocation and performance optimization are critical.
Innovation Solution
A method and system that allows for the decomposition of mobile applications into microservices at runtime, utilizing profile information to determine optimal local and remote execution, enabling dynamic partitioning and clustering of application components.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If applications are decomposed into microservices for distributed execution, then resource utilization and adaptability are improved, but system complexity and deployment difficulty increase
Solution Approach 1:
The patent segments monolithic applications into independent microservices at runtime based on profile information and execution context. Each microservice can be independently deployed, scaled, and executed on different devices, transforming a single complex application into multiple manageable units that improve adaptability while reducing overall system complexity through modularization
Solution Approach 2:
The patent implements dynamic decomposition where the application structure is not fixed but adapts at runtime based on available resources, user context, and execution requirements. The system dynamically determines which microservices to create, how to partition them between local and remote execution, and adjusts the decomposition strategy based on profile information, enabling the system to adapt to changing conditions without manual reconfiguration
2Productivity
If runtime decomposition is implemented, then execution efficiency and resource optimization are improved, but processing overhead and implementation complexity increase
Solution Approach 1:
The patent performs preliminary profiling of application executions before actual decomposition occurs. By collecting profile information about application behavior, resource usage patterns, and execution characteristics in advance, the system prepares the necessary data structures and analysis results that guide the runtime decomposition process, reducing the computational overhead during actual execution
Solution Approach 2:
The patent introduces intermediary components including a profiling system that collects execution data, an analysis module that processes profile information, and a decomposition engine that generates microservice partitions. These intermediary layers abstract the complexity of runtime decomposition, managing the transition from monolithic application to distributed microservices while optimizing execution efficiency through informed decision-making
3Measurement precision
If profile information is collected and analyzed, then decomposition accuracy and performance optimization are improved, but data collection overhead and processing time increase
Solution Approach 1:
The patent applies partial profiling by selectively collecting profile information only for the portions of the application that are candidates for microservice decomposition. Rather than profiling the entire application monolith, the system focuses on identifying execution boundaries and service boundaries where decomposition would provide benefit, reducing data collection overhead while maintaining sufficient accuracy for effective decomposition decisions
Data Source
AI summary
Methods, apparatus and systems are disclosed. In one embodiment, a method implemented by an end user device to decompose an application at runtime includes collecting profile information regarding local executions of the application on the end user device and determining, by the end user device using the collected profile information, one or more microservice patterns to decompose a whole or a part of the application into at runtime. The method further includes partitioning, by the end user device at runtime, the application into: (1) a locally executed portion of the application to be executed by the end user device and (2) the determined microservice patterns to be locally executed by the end user device or remotely executed by an external entity in communication with the end user device.