Microservice Partitioning Using Processing Time and Memory Profiles
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional methods for partitioning monolithic applications into microservices often fail to consider resource consumption, leading to inefficient and costly partitioning that does not account for processing time and memory usage, resulting in suboptimal performance and scalability.
Innovation Solution
A method that captures resource consumption data, including processing time and estimated memory allocation, to guide the partitioning process using a clustering algorithm, prioritizing objects with high processing time or memory usage to form efficient microservice partitions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional partitioning methods are used without considering resource consumption, then the partitioning process is simpler and faster, but the resulting microservices have suboptimal performance and scalability
Solution Approach 1:
The system performs preliminary resource consumption analysis by executing use cases and capturing processing time and memory allocation data before partitioning. This advance measurement allows the clustering algorithm to make informed decisions about grouping objects, ensuring optimal performance without adding complexity to the actual partitioning execution phase
Solution Approach 2:
The patent replaces manual or simple automated partitioning approaches with an intelligent system that uses clustering algorithms based on resource consumption metrics. This substitution transforms the partitioning process from a heuristic or arbitrary process into a data-driven optimization process that automatically considers performance factors
2Productivity
If objects are grouped without considering processing time and memory usage, then the partitioning is easier to implement, but the microservices incur higher operational costs and inefficient resource utilization
Solution Approach 1:
The system changes the partitioning criterion from simple structural or functional groupings to groupings based on resource consumption parameters (processing time and memory allocation). By using these parameters as the basis for clustering, the system achieves efficient resource utilization while the automated nature of the process maintains ease of implementation
Solution Approach 2:
The system enables the partitioning process to self-optimize by automatically capturing resource consumption data and using it to drive the clustering algorithm. This self-service approach eliminates the need for manual intervention to achieve optimal resource utilization, maintaining ease of operation while improving productivity
3Reliability
If resource consumption data is captured and analyzed, then optimal microservice partitions can be formed, but the data collection and processing overhead increases
Solution Approach 1:
Resource consumption data is captured during the use case execution phase before the actual partitioning decision is made. This preliminary data collection allows the system to have all necessary information ready when the clustering algorithm runs, minimizing the time added to the partitioning process while ensuring high partitioning quality
Solution Approach 2:
The system introduces an intermediary analysis layer that processes resource consumption data and translates it into clustering inputs. This intermediary layer abstracts the complexity of data collection and processing, allowing the partitioning system to benefit from detailed resource analysis without incurring proportional overhead in the main execution path
Data Source
AI summary
Application partitioning includes executing uses cases on an application, which executes methods of objects of the application, capturing resource consumption data associated with the execution of the use cases, the resource consumption data including processing time consumption to execute the methods and estimated memory allocated for executing the methods, generating a similarity comparison that provides comparisons between the objects based on the processing time consumption and the estimated memory allocated, grouping the objects into a set of microservice partitions.


