CN111277650A - Automatic micro-service identification method combining functional indexes and non-functional indexes - Google Patents

Automatic micro-service identification method combining functional indexes and non-functional indexes Download PDF

Info

Publication number
CN111277650A
CN111277650A CN202010066666.2A CN202010066666A CN111277650A CN 111277650 A CN111277650 A CN 111277650A CN 202010066666 A CN202010066666 A CN 202010066666A CN 111277650 A CN111277650 A CN 111277650A
Authority
CN
China
Prior art keywords
functional
istr
objects
class
micro
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CN202010066666.2A
Other languages
Chinese (zh)
Other versions
CN111277650B (en
Inventor
张煜堃
刘波
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Nanjing University of Aeronautics and Astronautics
Original Assignee
Nanjing University of Aeronautics and Astronautics
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Nanjing University of Aeronautics and Astronautics filed Critical Nanjing University of Aeronautics and Astronautics
Priority to CN202010066666.2A priority Critical patent/CN111277650B/en
Publication of CN111277650A publication Critical patent/CN111277650A/en
Application granted granted Critical
Publication of CN111277650B publication Critical patent/CN111277650B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L67/00—Network arrangements or protocols for supporting network services or applications
    • H04L67/01—Protocols
    • H04L67/02—Protocols based on web technology, e.g. hypertext transfer protocol [HTTP]
    • H04L67/025—Protocols based on web technology, e.g. hypertext transfer protocol [HTTP] for remote control or remote monitoring of applications
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
    • G06F11/302—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system component is a software system
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/3065—Monitoring arrangements determined by the means or processing involved in reporting the monitored data
    • G06F11/3068—Monitoring arrangements determined by the means or processing involved in reporting the monitored data where the reporting involves data format conversion
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3452—Performance evaluation by statistical analysis
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3466—Performance evaluation by tracing or monitoring
    • G06F11/3476—Data logging
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3466—Performance evaluation by tracing or monitoring
    • G06F11/3495—Performance evaluation by tracing or monitoring for systems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/12—Computing arrangements based on biological models using genetic models
    • G06N3/126—Evolutionary algorithms, e.g. genetic algorithms or genetic programming
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L67/00—Network arrangements or protocols for supporting network services or applications
    • H04L67/01—Protocols
    • H04L67/10—Protocols in which an application is distributed across nodes in the network
    • H04L67/1001—Protocols in which an application is distributed across nodes in the network for accessing one among a plurality of replicated servers
    • H04L67/1004—Server selection for load balancing
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2201/00—Indexing scheme relating to error detection, to error correction, and to monitoring
    • G06F2201/865—Monitoring of software

Abstract

The invention discloses an automatic micro-service identification method combining functional indexes and non-functional indexes, which can identify a proper and load-balanced micro-service candidate set from an executable package of a legacy system.

Description

Automatic micro-service identification method combining functional indexes and non-functional indexes
Technical Field
The invention discloses an automatic micro-service identification method combining functional indexes and non-functional indexes, and belongs to the technical field of micro-service identification.
Background
Software systems typically need to be constantly maintained and modified to accommodate changes in demand, one class of which is currently divided into monolithic systems, which typically implement all of the business logic of the system, including interfaces, data in one application and deployed in a single process. Such systems have the advantage of ease of development and deployment at small scale, but as systems evolve, are modified, are deployed, and are updated, the cost of the update rapidly rises to become overwhelming.
In response to such problems, there has been a growing academic and industrial focus on micro-service architectures derived from service-based architectures (SOAs), which describe a specific way to construct applications as a set of small, well-defined, highly cohesive, low-coupling, independently deployable, distributed and autonomous services (i.e., micro-services). Each microservice is intended to implement a single business function that has a relatively integrated domain model that includes data, logic, and behavior. It runs in its own process (e.g., a container like Tomcat), communicates with each other through lightweight mechanisms (e.g., RESTish protocol for HTTP, or lightweight message buses such as RabbitMQ), and updates and extends independently without affecting other services. The microservice-based application having the above features is more advantageous in maintainability, scalability and extensibility than a monolithic system.
While the trend of microservice-style architecture in the industry seems overwhelming, it is still not the primary form of software system. Monolithic systems, in which many companies have been operating for many years, still provide indispensable functionality in commerce, contributing significant value. While older systems continue to bring value to the owner, they do not bring the convenience, for example, making changes to a small portion of the system requires rebuilding and redeploying the entire whole. One currently available option is to redesign the entire application by extracting the microservice from an existing software artifact.
Methods for identifying microservices from monolithic legacy systems fall into two categories: one is a static identification method that relies on the structure of the code, warehouse information, database information, or other static information; another type is a dynamic identification method that requires the target legacy system to be started in order to obtain system-related dynamic information. The method is much less researched on the micro-service identification problem than a static method, and the existing dynamic method has larger difference.
The following is a typical working example representing a static approach:
the work of Mazlami [ Extraction of Microscopes from Monolithic software architecture ] takes the target legacy system's Git code repository as the input for the method, which covers the code file, version history, and code submitter information. This work will put the entire Git siloA library is abstracted as a triplet (C)M，HM，DM)，CMIs a collection of code files of the current version, HmIs a modification history, DMIs a sharer collection of developers. HMIs defined as an ordered sequence of events (h)1，h2，...hn) Each event h can in turn be represented as another triplet h (E, t, d), E being the modification, deletion, added set of files involved in this event, t being the event stamp, d being the contributor. Then each code file is used as a node in a graph, and weighted relationships among the nodes are calculated from three aspects of logic, semantics and contributors by analyzing the information of the triples. And finally, applying a graph partitioning algorithm on the graph to obtain a service identification result. Wherein when two classes are modified in the same commit, there is a logical relationship between the two classes; when the two classes are abstracted into texts, the similarity between the texts of the two classes is used as a semantic relation; when both classes are modified by the same engineer, the two are associated together in the perspective of the contributor.
The following are examples of dynamic methods:
the work of jin (Service Candidate Identification from the national Systems based Execution transactions) introduces the concept of "dynamic log reaction system traffic" into the field of microservice Identification. The work firstly obtains a system dynamic running log by using a monitoring tool, then a class set group meeting specific indexes is obtained by de-duplication and combination, and each class set in the class set group is regarded as a minimum unit which can not be split. And finally, calculating a micro-service candidate set in four target spaces of the associated cohesion and coupling degrees and the concept cohesion and coupling degrees.
The existing micro-service identification method has the following defects:
1. strong assumption of preconditions. Existing service identification methods, particularly static methods, have a big premise that code is available and that the document is assumed to be complete. In practical applications, however, imperfections or even deletions of documents are common;
2. absence of non-functional indicators. As an important factor influencing service division, performance distribution, no method exists at present for taking corresponding non-functional indexes as consideration bases.
3. The extreme results are unreliable. In fact, all micro service identification methods may generate an unintelligible service candidate set in a specific case, which is expressed by an extremely small or large number of service candidates, a chaotic call relation, and the like, and the unintelligible service candidate set is rarely adjusted and applied to the business field in a short time, which loses the important advantages (efficiency) of the automatic identification method.
Disclosure of Invention
The purpose of the invention is as follows: in view of the problems and deficiencies of the prior art, the present invention provides an automated micro-service identification method combining functional indicators and non-functional indicators, which is capable of identifying a suitable and load-balanced micro-service candidate set from an executable package of a legacy system.
The technical scheme is as follows: an automatic micro-service identification method combining functional indexes and non-functional indexes comprises the following steps:
step 1: performing functional and non-functional monitoring on a target system, and acquiring functional log data and non-functional log data of an execution process;
step 2: preprocessing functional log data and converting the functional log data into a data set { messageRecords } expressed by a messageRecords structure, wherein a message for providing a method call is recorded in the data set { messageRecords } expressed by the messageRecords structure; the messages are divided into three types of CREATE, UPDATE and READ respectively;
preprocessing the non-functional log data to obtain the CPU time and memory allocation of each class;
and step 3: scanning a data set { messageRecords } expressed by a messageRecord structure to obtain a group of run-time object sets { Objects };
and 4, step 4: traversing the runtime Objects in the runtime Object set { Objects } and dividing to obtain a control Object set { COs } and an attached Object set { SOs };
and 5: establishing a two-dimensional matrix of the relationship between the control object and the accessory object, and recording the two-dimensional matrix as an O-O matrix, wherein the O-O matrix is a two-dimensional array with the transverse direction as the control object and the column direction as the accessory object, and each unit R of the arrayijRecording control object COiAnd accessory object SOjThe number of CREATE, UPDATE and READ messages existing in the same time;
step 6: sorting classes appearing in the control object set { COs } and the accessory object set { SOs } to obtain a control class set { CCs } and an accessory class set { SCs }, creating a two-dimensional matrix of the relation between the control class set { CCs } and the accessory class set { SCs } according to an O-O matrix, and recording the two-dimensional matrix as a C-C matrix, wherein the C-C matrix is a two-dimensional matrix with the control class CC in the transverse direction and the accessory class SC in the column direction, and R'ijRecord CCiAnd SCjQuantized functional relationship Fct data and SC betweeniNon-functional relationship data of (a);
and 7: establishing a division evaluation function based on data provided by the C-C matrix, and searching an optimal solution in the division evaluation function by adopting a genetic algorithm to obtain a micro-service candidate set, wherein the division evaluation function comprises a function-related objective function, a CPU consumption-related objective function and a memory consumption objective function; (ii) a
And 8: and sorting and adjusting the obtained micro service candidate set.
Further, the non-functional log data in step 1 includes CPU performance log data and memory performance log data, where the CPU performance log data includes CPU time consumed by each method in each execution process of the target system, and the memory performance log data includes the number of objects created in the execution process of the target system and the size of an object memory.
Further, the MessageRecord structure is constrained to the following formula:
MessageRecord＝{<senderOID；senderClassSig>；
<receiverOID；receiverClassSig>；MethodSig}
in the formula, SenderOID and senderClassSig respectively represent the object unique ID and class signature of the message sending object, receiverOID and receiverClassSig respectively represent the unique ID and class signature of the message receiving object, and MethodSig is the sent message.
Further, in the step 4, the runtime Objects in the runtime Object set { Objects } are divided by the custom index to obtain a control Object set { COs } and an attached Object set { SOs }, where the runtime Objects meeting the custom index are control Objects, and the rest runtime Objects are attached Objects;
the self-defined indexes comprise:
index one: from the sender of the message;
index two: is the recipient of the CREATE message;
index three: singleton mode.
Further, the control object CO in the step 5iAnd accessory object SOjThe method for acquiring the number of CREATE, UPDATE and READ messages comprises the following steps:
s131: searching for CO controlled objects in the { MessageRecords }iThe object set created directly is denoted as { Level1Objects }, and represents the control object COiAs the sender of the message, Level1Object as the receiver of the message, the type of the message is CREATE, and the corresponding R is updatediiThe record in (1);
s132: searching in an object set { Objects }/({ COs } U { Level1Objects }), and marking an object directly created by the object in the { Level1Objects } as { Level2Objects }; update the corresponding RijThe record in (1);
s133: iteratively generate { Level 13Objects }, { Level4Objects }. and update the corresponding R, in accordance with S132ijUntil Objects/U (COs) is empty or a new set of Objects cannot be generated. Obtaining a control object COiThe number of CREATE operations between e { COs } and the set of attached objects { SOs };
with reference to the methods of S131 to S132, the control object CO is countediThe number of UPDATE messages between e { COs } and the set of attached objects { SOs };
reference toS131 to 132, method of counting CO as control objectiE { COs } and the attached set of objects { SOs }.
Further, in the step 6, CCiAnd SCjThe quantized functional relationship Fct data acquisition steps are as follows:
controlling object CO in O-O matrixiMerging data with accessory object set { SOs } to obtain control class CCiAnd accessory class SCjThe number of messages of three types of CREATE, UPDATE and READ is marked as kc, ku and kr;
calculating to obtain quantized functional relation Fct data according to the following formula;
Fct＝IStrc×(IFrec)kc+IStru×(IFreu)ku+IStrr×(IFrer)kr
wherein InvocStren ═ { ISTr ═c，IStru，IStrrTo evaluate the strength of different message types, IStrcCorresponding to the Strength constant, ISTr, of the CREATE messageuIntensity constant, IStr, corresponding to UPDATE messagerA strength constant corresponding to the READ message; InvocFreq ═ IFrec，IFreu，IFrerIs used to set the influence of different types of call frequencies on Fct, IFrecRepresenting frequency constants, IFre, of CREATE messagesuIndicating the frequency constant, IFre, of UPDATE messagesrRepresenting a READ message frequency constant;
the SCjThe non-functional relation data is CPU time and memory allocation obtained by preprocessing the corresponding non-functional log data in the step 2.
Further, the IStrcAt least higher than IStruOne order of magnitude, IStruAt least higher than IStrrOne order of magnitude, IStrc＞IStru＞IStrr。
Further, the division evaluation function includes a function-related objective function, a CPU consumption-related objective function, and a memory consumption objective function;
the function-dependent objective function aims at optimizing the overall functional evaluation of a service partition:
Figure BDA0002376164470000051
the CPU consumption related objective function aims at optimizing the CPU load of one service partition:
Figure BDA0002376164470000052
the memory consumption objective function aims at optimizing the memory load of one service partition:
Figure BDA0002376164470000053
where n denotes data of a service candidate in the division, FCT' (microservice)i) Candidate microservice for ith microserviceiThe sum of Fct data between all control classes CC and subordinate classes SC; CPU' (microprocessor)i) Candidate microservice for ith microserviceiThe sum of the CPU time of all the auxiliary classes SC; mem' (microservice)i) Candidate microservice for ith microserviceiThe sum of the memory allocations of all subordinate classes SC.
Further, in the step 7, an optimal solution is searched in the partition evaluation function by using a genetic algorithm based on the data provided by the C-C matrix to obtain a micro-service candidate set, and the specific operation steps are as follows:
designing an alternative operator, a unified exchange operator and a unified mutation operator on a frame of a non-dominated sorting genetic algorithm; the alternative algorithm is to select two from parents and preferentially reserve through congestion degree comparison operation, the unified exchange algorithm generates sub-individuals by randomly exchanging the segments of the parents, and the unified mutation algorithm generates the sub-individuals by randomly mutating the data in the individuals;
in each iteration, an alternative operator, a unified exchange operator and a unified mutation operator are sequentially used on the parent individuals to obtain new individuals to form filial generations; merging the parent and the formed child, and selecting an optimal individual set from the parent and the formed child as a new parent;
and when the iteration times are reached, outputting the current optimal pareto front, performing descending order arrangement on the obtained filial generation based on the functional objective function, and taking the optimal filial generation as the micro-service candidate set.
Further, the step 8 specifically operates as follows:
micro service candidate set is converted from optimal individual to textually expressed micro service candidate set from encoding form of genetic algorithmi}；
Setting an interface of each micro-service candidate according to a rule, wherein the rule comprises: the information of the control class automatically becomes an interface of a micro service candidate and the information which is directly requested to the accessory class without being forwarded by the control class in the function log data is raised to the interface of the micro service candidate;
converting the functional log data based on the Class into chain calling based on a micro-service candidate set;
and the user analyzes the micro-service candidate set and adjusts the micro-service candidate set by combining the micro-service candidate set with chain calling according to the analysis result.
Has the advantages that: the method can identify the micro-service candidate set which is suitable and has balanced load from the executable package of the legacy system, and has the following advantages:
1. the method only needs the executable program of the target system, does not need to rely on source codes, and realizes weak dependence on the precondition;
2. when the method is used for designing the division method based on the multi-target genetic algorithm, functional requirements and performance requirements are considered at the same time, and a proper micro-service candidate set with balanced load can be identified;
3. and in the whole process, the reliability and the understandability of the division result are improved by introducing a control class and an auxiliary class.
Drawings
FIG. 1 is a schematic flow diagram of the present invention;
FIG. 2 is a schematic diagram of the encoding of the present invention;
FIG. 3 is a flow chart of the genetic algorithm of the present invention.
Detailed Description
The technical solution of the present invention will be further explained with reference to the accompanying drawings and examples.
As shown in fig. 1, the method for identifying micro-services of the present invention comprises the following steps:
s000: performing function and non-function monitoring on an executable package of an application program, acquiring function logs and non-function log data of an execution process, preprocessing the function log data to convert the function log data into a data set expressed by a MessageRecord structure as function input of S100, and preprocessing the non-function log data to convert key value pairs recording consumed time and memory allocation of each class as non-function input of S100; the specific operation is as follows:
the method needs to combine various open source tools to realize non-intrusive function and non-function monitoring on an executable package (generally, a Java program is War package) of an application program, so as to obtain a function log and a performance log, and the specific flow is as follows:
s010: monitoring a target system noninvasively by using a Kieker tool which is an open source tool, recording an object sequence executed by the system each time in a mode of piling a pile into an executable file of the target system, and generating a function execution log;
s020: and acquiring a performance log of the execution process by using a JDK performance analysis function JVisualvm monitoring system. The performance logs include CPU performance logs and memory performance logs. The CPU performance log records the CPU time consumed by each method during each system execution. The memory performance log records the number of objects created during the execution of the system and the size of the object memory.
S030: designing a test case, and covering system functions as much as possible under the condition that a document is lost when the test case is monitored and executed;
the test case is designed in the following way:
actually using a monitored target system at the angle of a terminal user, recording main operation and service logic of the system, and forming a test case;
analyzing the object interaction in the sequence diagram converted from the execution log, and exploring the missed test cases while better understanding the system function;
s040: and converting the test case into a script which can be automatically executed by JMeter. JMeter is a Java-based testing tool developed by the Apache organization and can automatically interact with the system according to scripts.
S050: different users are simulated with the help of JMeter to execute at least 100 times on each test case.
Since the functional document of the target system may be missing, and the dynamic operation method needs to cover the system functions as much as possible, the purpose of S030 to S050 is to establish a complete system function description, and more complete functional log data and non-functional log data can be obtained compared with the random test.
The obtained logs cannot be directly analyzed, and need to be preprocessed and converted into operable data as input of the next step:
the function log generated by the Kieker takes Trace as a unit, and each Trace corresponds to one call of the system and is composed of a series of method calls in the system.
A typical Kieker Trace log consists of multiple lines of text, with each line of text being a record. Each method call is recorded as a pair of related records during the system execution process, a start record (of the type BeforeOperationEvent or BeforeContractorEvent) marks the start of the system method call, and an end record (of the type AfterOperationEvent or AfterCon-structorEvent) marks the end of the system method call. This is the same for records except that the record types are not consistent. Each record contains information as shown in the table:
Figure BDA0002376164470000071
the method needs to convert the function log record with Trace as a unit into data expressed by a MessageRecord structure. The specific structure of the MessageRecord may be constrained to the following formula:
MessageRecord＝{<senderOID；senderClassSig>；
<receiverOID；receiverClassSig>；MethodSig}
the MessageRecord can effectively provide information such as a caller, a callee, a calling method and the like of a method call.
The functional log is converted into a data set expressed by the MessageRecord structure and this data set is used as functional input for the next step.
The non-functional logs are two types, one type is a CPU performance log file expressed by XML, the execution time consumption of each called method in Trace is recorded, and the CPU time consumed independently in the execution process of each method of one type is accumulated to be used as the CPU time of the type; the other is a memory performance log. Because the current Jvivialvm technology is limited, the function of directly exporting the CPU performance file cannot be provided, the method manually records the average recommended Size of each class through the Jvivialvm UI interface, and then multiplies the average recommended Size by the number of instantiations of the class recorded in the function log to obtain the memory allocation of the class.
Finally, distributing the key value pairs to be recorded for the CPU time and the memory consumed by each class, wherein the recording format is as follows: class name: (CPU time, memory allocation) as a non-functional input for the next step.
S100: scanning a data set expressed by a MessageRecord structure to obtain a group of runtime object sets, traversing objects in the object sets, and dividing to obtain a control object set and an auxiliary object set; establishing a two-dimensional matrix of the relationship between the control object and the attached object, recording the two-dimensional matrix as an O-O matrix, establishing a two-dimensional matrix of the relationship of the obtained class according to the O-O matrix, recording the two-dimensional matrix as a C-C matrix, and associating the two-dimensional matrix with corresponding performance information; the specific operation is as follows:
first, the data set expressed by the MessageRecord structure is scanned to obtain a set of runtime Objects { Objects }, each runtime Object having a unique Object ID in addition to a class name.
A Controller mode (Controller board) defined in the reference document, "Interactive transformations from object-oriented modules to component-based modules", wherein a Control Object (CO) is a portal responsible for processing external input events, a class corresponding to the CO is usually an interface class that is a candidate for a micro service, and all external messages are forwarded to the inside of the service through the interface class. In the subsequent partitioning algorithm, the reliability of the partitioning result can be effectively improved by partitioning based on the Class with the characteristic. The control object is usually a permanent object, meaning that it exists before the business logic is executed, and is not destroyed during the execution of the system.
The following three indexes are defined to detect the Objects in the run-time Object set { Objects } one by one, and the Objects meeting the indexes are control Objects.
Index one: the control object must come from the sender (sender) of the message;
index two: any one control object will be the recipient of the CREATE message;
index three: each control object must be singleton mode;
after the traversal is completed, a set of control objects is obtained, which is defined as { COs }. The dependent object (subordineteobject) is defined as an object that does not belong to the control object, then the set of dependent Objects { SOs } should be the difference of { COs } versus { Objects }, i.e., { Objects }/{ COs }.
From the sender, recipient and message (method signature) information of the data set record expressed by the MessageRecord structure, a two-dimensional matrix of the relationships between control objects and dependent objects is created, denoted as an O-O matrix, according to the following steps.
S110: according to the method name format and the keywords, the messages in the MessageRecord are divided into three types, namely CREATE, UPDATE and READ. For example, a method name < init > () is written as a CREATE type, a method name beginning with Get, Read, List, etc. is a Read class, and a method name beginning with Write, Change, Update, etc. is an Update class.
S120: creating a two-dimensional array with the control object in the horizontal direction and the auxiliary object in the column direction, wherein each unit R of the arrayijRecording COiAnd SOjThe number of three messages CREATE, UPDATE, READ that exist in between.
S130: according to the following steps, counting CO in sequenceiThe number of CREATE operations between e { COs } and the set of attached objects { SOs }.
S131: search for the CO in the { MessageRecords }iThe object set created directly is denoted as { LevellObjects }, i.e. COiAs the sender of the message, Level1Object as the receiver of the message, method (message) type is CREATE, and corresponding R is updatedijThe record in (1);
s132: searching in an object set { Objects }/({ COs } U { Level1Objects }), and marking an object directly created by the object in the { Level1Objects } as { Level2Objects };
s133: iteratively generate { Level3Objects }, { Level4Objects }. until { Objects }/({ COs } U { Level Objects }) is empty or a new set of Objects cannot be generated, in accordance with S132.
S140: with reference to the methods of S131 to 132, statistics of COiThe number of UPDATE messages between e { COs } and the set of attached objects { SOs };
s150: according to the method of S131 to 132, counting COiE { COs } and the attached set of objects { SOs }.
And creating a class relation two-dimensional matrix through the O-O matrix, recording the class relation two-dimensional matrix as a C-C matrix, and associating the C-C matrix with corresponding performance information, wherein the C-C matrix is used as the input of S200.
The creating step of the relation two-dimensional matrix of the class comprises the following steps: in an object-oriented language, a class can instantiate multiple objects. Therefore, classes appearing in the control object set and the accessory object set are respectively sorted to obtain a control class set { CCs } and an accessory class set { SCs }
Creating a crossbarWith the column direction being a two-dimensional matrix, R ', of control class CC and of satellite class SC'ijRecord CCiAnd SCjQuantized functional relationship Fct data and SC betweenjNon-functional relationship data of (a); (ii) a
Merging CO in O-O matrixi(type is CCiObject of (c) and { SOs } (type SC)jSet of objects) to obtain a CCiAnd SCjThe quantity of the messages of three types of CREATE, UPDATE and READ is recorded as kc, ku and kr, and the quantized functional relationship Fct data is calculated by the following formula;
Fct＝IStrc×(IFrec)kc+IStru×(IFreu)ku+IStrr×(IFrer)kr
wherein InvocStren ═ { ISTr ═c，IStru，IStrrAnd InvocFreq ═ IFrec，IFreu，IFrerAre two predetermined sets of constants.
InvocStren constant set to evaluate the strength of different message types, where ISTrcA strength constant corresponding to the CREATE message; IStruIntensity constant, IStr, corresponding to UPDATE messagerCorresponding to the strength constant of the READ message. When specifically set, IStrcIs at least higher than ISTruOne order of magnitude, IStruIs at least higher than ISTrrAn order of magnitude, for example, may be set to 100,10, 1, respectively.
InvocFreq constant set is used to set the effect of different types of call frequencies on Fct, where IFreCFrequency constant, IFre, corresponding to CREATE messageuCorresponding UPDATE message frequency constant, IFrerCorresponding to the READ message frequency constant. This constant set ensures that when the value is large enough, the number of calls can be the dominant factor in the formula. For example, in experiments, ISTrc，IStru，IStrrIs set to a value slightly greater than 1.0, and IStrc＞IStru＞IStrrThis means that a weaker message type (e.g., READ) can be more strongly distinguished than a stronger type (e.g., UPDATE) when the number of message types reaches a certain levelA high weight.
SCiThe non-functional relationship data is CPU time and memory allocation obtained by preprocessing non-functional log data.
S200: performing micro-service identification based on a multi-target genetic algorithm; the specific operation is as follows:
through the steps, the method can obtain a class set of the target system containing all the control classes { CCs } and the affiliated classes { SCs } and a C-C matrix. A microservice candidate may be defined as<CCi，{SCs}>Wherein i ∈ [1, | { CSs } ] does not smoke]. Further, a partition of the class set for the target system can be expressed as a microservices candidate setiAnd f, parts of the micro service candidates which are not overlapped with each other are formed.
In order to find a proper micro-service partition set, the method searches an optimal solution in the following three indexes based on a multi-objective genetic algorithm, wherein the optimal solution comprises the following steps:
Figure BDA0002376164470000101
Figure BDA0002376164470000102
Figure BDA0002376164470000103
the function-related objective (FO) is aimed at optimizing the overall function evaluation of a service partition, where n denotes data of service candidates in the partition. FCT' (microservice)i) To be in microserviceiThe larger the value of FO, the more the sum of Fct data between all control classes CC and subordinate classes SC means that the goal of high cohesion, low coupling is met.
The CPU consumes a relevant objective (CO) with the aim of optimizing the CPU load of a service partition, a lower CO value means that the service partition has a better CPU load balance, CPU' (microprocessor)i) As the ith microservice candidatemicroserviceiThe sum of the CPU times of all subordinate classes SC.
The memory consumption target (MO) aims at optimizing the memory load of a service partition, a lower MO value means that the service partition has better memory load balance, and Mem' (microservicei) is a candidate microservicece in the ith microserviceeiThe sum of the memory allocations of all subordinate classes SC.
The method realizes a multi-objective algorithm based on a non-dominated sorting genetic algorithm (NSGA II) to search a feasible solution. In this algorithm, a service partition is computed as an individual, whose encoding uses integer encoding. Given n control classes, m subordinate classes, an individual may be encoded as an array of m-length integers, the values in the array having a range of values [1, n]. The subscript is i, the value of the array element is x, and the ith auxiliary class belongs to the microservice taking the xth control class as the interface class. For example, for the code [2, 2, 5, 2 ] in fig. 2.]In other words, the 1 st, 2 nd, and 4 th subordinate classes and the 2 nd control class may constitute a service candidate microservice2。
We designed the corresponding alternative operator, unified crossover operator, unified mutation operator on the algorithm framework of NSGA II (see fig. 3) to generate subgroups. The alternative algorithm is to choose two from the parents, and the preference is preserved through the congestion degree comparison operation, the unified mutation algorithm generates the sub-individuals by randomly exchanging the segments of the parents, and the unified mutation algorithm generates the sub-individuals by randomly mutating the data in the individuals (the range is still between 1 and n).
In each iteration, an alternative operator, a unified exchange operator and a unified mutation operator are sequentially used on the parent individuals to obtain new individuals to form filial generations; merging the parent and the formed offspring, and selecting an optimal individual set as a new parent; (ii) a When a specific iteration number is reached, the algorithm stops, the current optimal pareto frontier is output, descending order arrangement is carried out on the basis of a functional objective function, and the optimal pareto frontier is taken as the input of the next step. The iteration times are specified by engineers, after a plurality of tests, 200 populations are found, and a proper result can be obtained after 100 iterations.
S300: the method comprises the following specific operations of sorting and adjusting the micro service candidate set:
inputting the micro service candidate set { micro services of the optimal individual converted into the textual expression from the coding form of the genetic algorithmi}；
Setting an interface of each micro service candidate according to a rule, wherein the rule comprises the following steps: the method of the control class automatically becomes an interface of a micro service candidate and the method of directly requesting to an accessory class without control class forwarding in the Trace is increased to the interface of the micro service candidate;
converting the Trace based on the Class into chain calling based on a micro-service candidate set;
the user analyzes the micro-service candidate set and the chain call to adjust the micro-service candidate set.
Example (b):
in this embodiment, three comparative experiments are implemented in the Production SSM of the open source project to verify the effectiveness of the method of the present invention. The Production SSM is an open-source ERP system, a typical single three-layer architecture legacy system, and the documents are missing, and only the user function profile and the deployment documents are available.
Experiment one: similar functionality is identified as microservice candidates from the perspective of the end user by actually using the deployed program with the participation of an experienced engineer. And obtaining the Class involved in each service candidate through a Debug means. Where there may be overlap, further discussion is needed as to whether the overlapping portions are candidates for new microservice or are already in existence. The specific structure is shown in fig. 1, where corresponding explanations are added according to the provided functions, and a Class is assigned as the control Class for comparison with the results of experiments two and three. The classes in the control class and attached class set are abbreviated, and the specific class names can refer to table 4.
TABLE 1 results of the experiments
Figure BDA0002376164470000121
Figure BDA0002376164470000131
Experiment two: applying the method on the Production SSM results as shown in Table 2, each row representing a microservice candidate with a control class and attached class set indicated, as well as the CPU and memory consumption ratios. The results of the table were not adjusted by the engineer in order to actually react the results.
Experiment three: in the method division stage, only the formula max FO is applied to calculate a single-target genetic algorithm. The results obtained are shown in table 2.
The results of the comparison are further shown in table 3, where similarity refers to the similarity between the identified service candidate set and the reference result (experiment one). The percentage of the subordinate classes having the same position as that of the reference result (the same control class) is regarded as the similarity. In experiment two and experiment three, the method at least guarantees 84.65% similarity. It can be said that the partitioning results of this method are mostly reliable. Further, it was found that the shift in experimental results is from C27，C85，C146And C29，C86. In the reference results, the first three classes C27，C85，C146Of the Mircoervice responsible for authorisation functions27The latter two being Mircoervice responsible for file upload28. Experiments two and three automatically identified these five classes as control classes, and from a business perspective, the manual partitioning was superior to the strategy of experiments two and three. But the results of two and three can be corrected in a shorter time by subsequent analysis. In the work record in experiment one, roughly 40 man-hours (one week) were used for debugging, analysis and decomposition. At the same time, only 8 hours are probably used to adjust the results of the other two experiments. It can thus be concluded that the method of the invention is efficient and has advantages in terms of time and efficiency over manual methods.
TABLE 2 experiment two and experiment three
Figure BDA0002376164470000132
Figure BDA0002376164470000141
In addition, table 3 shows a 4.4% reduction in the similarity for lab two relative to experiment three. Meanwhile, the performance load of experiment two is better than that of experiment three, no matter the CPU load or the memory load. The results of two experiments show the class (C) used for file upload29，C86) Relatively much memory and CPU resources are consumed. This approach, which considers both functionality and non-functionality, is new to achieve a better balance of performance by relocating them. This indicates the impact of non-functionality on the micro-service candidate set, which provides the micro-service developers a useful choice if they need to consider load issues in development and operation.
TABLE 3 comparison of results from experiment two and experiment three
Strategy Similarity CPU Balance Memory Balance
Exp II 84.65％ 0.0015 0.0008
Exp III 89.05％ 0.0020 0.0009
TABLE 4 class of Production SSM
Figure BDA0002376164470000142
Figure BDA0002376164470000151
Figure BDA0002376164470000161

Claims (10)

1. An automatic micro-service identification method combining functional indexes and non-functional indexes is characterized in that: the method comprises the following steps:
step 1: performing functional and non-functional monitoring on a target system, and acquiring functional log data and non-functional log data of an execution process;
step 2: preprocessing functional log data and converting the functional log data into a data set { messageRecords } expressed by a messageRecords structure, wherein a message for providing a method call is recorded in the data set { messageRecords } expressed by the messageRecords structure; the messages are divided into three types of CREATE, UPDATE and READ respectively;
preprocessing the non-functional log data to obtain the CPU time and memory allocation of each class;
and step 3: scanning a data set { messageRecords } expressed by a messageRecord structure to obtain a group of run-time object sets { Objects };
and 4, step 4: traversing the runtime Objects in the runtime Object set { Objects } and dividing to obtain a control Object set { COs } and an attached Object set { SOs };
and 5: establishing a two-dimensional matrix of the relationship between the control object and the auxiliary object, and recording the two-dimensional matrix as an O-O matrix, wherein the O-O matrix is a two-dimensional matrix which is used for transversely serving as the control object and is used for column-wise serving as the auxiliary objectSet, each unit R of the arrayijRecording control object COiAnd accessory object SOjThe number of CREATE, UPDATE and READ messages existing in the same time;
step 6: sorting classes appearing in the control object set { COs } and the accessory object set { SOs } to obtain a control class set { CCs } and an accessory class set { SCs }, creating a two-dimensional matrix of the relation between the control class set { CCs } and the accessory class set { SCs } according to an O-O matrix, and recording the two-dimensional matrix as a C-C matrix, wherein the C-C matrix is a two-dimensional matrix with the control class CC in the transverse direction and the accessory class SC in the column direction, and R'ijRecord CCiAnd SCjQuantized functional relationship Fct data and SC betweenjNon-functional relationship data of (a);
and 7: constructing a partition evaluation function based on data provided by the C-C matrix, and searching an optimal solution in the partition evaluation function by adopting a genetic algorithm to obtain a micro-service candidate set; the division evaluation function comprises a function-related objective function, a CPU consumption-related objective function and a memory consumption objective function;
and 8: and sorting and adjusting the obtained micro service candidate set.
2. The method of claim 1, wherein the method comprises the steps of: the non-functional log data in step 1 includes CPU performance log data and memory performance log data, the CPU performance log data includes CPU time consumed by each method in each execution process of the target system, and the memory performance log data includes the number of objects created in the execution process of the target system and the size of an object memory.
3. The method of claim 1, wherein the method comprises the steps of: the MessageRecord structure is constrained to the following formula:
MessageRecord＝{<senderOID；senderClassSig>；
<reCeiverOID；receiverClassSig>；MethodSig}
in the formula, SenderOID and senderClassSig respectively represent the object unique ID and class signature of the message sending object, receiverOID and receiverClassSig respectively represent the unique ID and class signature of the message receiving object, and MethodSig is the sent message.
4. The method of claim 1, wherein the method comprises the steps of: in the step 4, dividing the runtime Objects in the runtime Object set { Objects } by the custom index to obtain a control Object set { COs } and an attached Object set { SOs }, where the runtime Objects meeting the custom index are control Objects, and the rest runtime Objects are attached Objects;
the self-defined indexes comprise:
index one: from the sender of the message;
index two: is the recipient of the CREATE message;
index three: singleton mode.
5. The method of claim 1, wherein the method comprises the steps of: the control object CO in the step 5iAnd accessory object SOjThe method for acquiring the number of CREATE, UPDATE and READ messages comprises the following steps:
s131: searching for CO controlled objects in the { MessageRecords }iThe object set created directly is denoted as { Level1Objects }, and represents the control object COiAs the sender of the message, Level1Object as the receiver of the message, the type of the message is CREATE, and the corresponding R is updatedijThe record in (1);
s132: searching in an object set { Objects }/({ COs } U { Level1Objects }), and marking an object directly created by the object in the { Level1Objects } as { Level2Objects }; update the corresponding RijThe record in (1);
s133: iteratively generate { Level3Objects }, { Level4Objects }. and update the corresponding R, in accordance with S132ijChinese character' ZhongRecord until { Objects }/({ COs } U { Level1Objects }) is empty or a new set of Objects cannot be generated. Obtaining a control object COiThe number of CREATE operations between e { COs } and the set of attached objects { SOs };
with reference to the methods of S131 to S132, the control object CO is countediThe number of UPDATE messages between e { COs } and the set of attached objects { SOs };
with reference to the methods of S131 to S132, the control object CO is countediE { COs } and the attached set of objects { SOs }.
6. The method of claim 1, wherein the method comprises the steps of: in said step 6, CCiAnd SCjThe quantized functional relationship Fct data acquisition steps are as follows:
controlling object CO in O-O matrixiMerging data with accessory object set { SOs } to obtain control class CCiAnd accessory class SCjThe number of messages of three types of CREATE, UPDATE and READ is marked as kc, ku and kr;
calculating to obtain quantized functional relation Fct data according to the following formula;
Fct＝IStrc×(IFrec)kc+IStru×(IFreu)ku+IStrr×(IFrer)kr
wherein InvocStren ═ { ISTr ═c，IStru，IStrrTo evaluate the strength of different message types, IStrcCorresponding to the Strength constant, ISTr, of the CREATE messageuIntensity constant, IStr, corresponding to UPDATE messagerA strength constant corresponding to the READ message; InvocFreq ═ IFrec，IFreu，IFrerIs used to set the influence of different types of call frequencies on Fct, IFrecRepresenting frequency constants, IFre, of CREATE messagesuIndicating the frequency constant, IFre, of UPDATE messagesrRepresenting a READ message frequency constant;
the SCjThe non-functional relation data of (a) is the corresponding non-workAnd (4) CPU time and memory allocation obtained by preprocessing log data in the step (2).
7. The method of claim 6, wherein the method comprises the steps of: the IStrcAt least higher than IStruOne order of magnitude, IStruAt least higher than IStrrOne order of magnitude, IStrc>IStru>IStrr。
8. The method of claim 1, wherein the method comprises the steps of:
the function-dependent objective function aims at optimizing the overall functional evaluation of a service partition:
Figure FDA0002376164460000031
the CPU consumption related objective function aims at optimizing the CPU load of one service partition:
Figure FDA0002376164460000032
the memory consumption objective function aims at optimizing the memory load of one service partition:
Figure FDA0002376164460000033
where n denotes data of a service candidate in the division, FCT' (microservice)i) Candidate microservice for ith microserviceiThe sum of Fct data between all control classes CC and subordinate classes SC; CPU' (microprocessor)i) Candidate microservice for ith microserviceiThe sum of the CPU time of all the auxiliary classes SC; mem' (microservice)i) Candidate microservice for ith microserviceiMemory of all subordinate classes SC inThe sum of the allocations.
9. The method of claim 8, wherein the method comprises the steps of: in the step 7, an optimal solution is searched in the partition evaluation function by adopting a genetic algorithm based on the data provided by the C-C matrix to obtain a micro-service candidate set, and the specific operation steps are as follows:
designing an alternative operator, a unified exchange operator and a unified mutation operator on a frame of a non-dominated sorting genetic algorithm; the alternative algorithm is to select two from parents and preferentially reserve through congestion degree comparison operation, the unified exchange algorithm generates sub-individuals by randomly exchanging the segments of the parents, and the unified mutation algorithm generates the sub-individuals by randomly mutating the data in the individuals;
in each iteration, an alternative operator, a unified exchange operator and a unified mutation operator are sequentially used on the parent individuals to obtain new individuals to form filial generations; merging the parent and the formed child, and selecting an optimal individual set from the parent and the formed child as a new parent;
and when the iteration times are reached, outputting the current optimal pareto front, performing descending order arrangement on the obtained filial generation based on the functional objective function, and taking the optimal filial generation as the micro-service candidate set.
10. The method of claim 1, wherein the method comprises the steps of: the step 8 specifically operates as follows:
micro service candidate set is converted from optimal individual to textually expressed micro service candidate set from encoding form of genetic algorithmi}；
Setting an interface of each micro-service candidate according to a rule, wherein the rule comprises: the information of the control class automatically becomes an interface of a micro service candidate and the information which is directly requested to the accessory class without being forwarded by the control class in the function log data is raised to the interface of the micro service candidate;
converting the functional log data based on the Class into chain calling based on a micro-service candidate set;
and the user analyzes the micro-service candidate set and adjusts the micro-service candidate set by combining the micro-service candidate set with chain calling according to the analysis result.
CN202010066666.2A 2020-01-20 2020-01-20 Automatic micro-service identification method combining functional indexes and non-functional indexes Active CN111277650B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202010066666.2A CN111277650B (en) 2020-01-20 2020-01-20 Automatic micro-service identification method combining functional indexes and non-functional indexes

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202010066666.2A CN111277650B (en) 2020-01-20 2020-01-20 Automatic micro-service identification method combining functional indexes and non-functional indexes

Publications (2)

Publication Number Publication Date
CN111277650A true CN111277650A (en) 2020-06-12
CN111277650B CN111277650B (en) 2021-07-09

Family

ID=71001138

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202010066666.2A Active CN111277650B (en) 2020-01-20 2020-01-20 Automatic micro-service identification method combining functional indexes and non-functional indexes

Country Status (1)

Country Link
CN (1) CN111277650B (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112671706A (en) * 2020-11-25 2021-04-16 四川新网银行股份有限公司 Network access control system based on micro-service architecture

Citations (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN106850782A (en) * 2017-01-17 2017-06-13 泰康保险集团股份有限公司 For the method and system of log processing
CN107133024A (en) * 2016-02-29 2017-09-05 北京广联达正源兴邦科技有限公司 Business management system based on OSGI frameworks
CN107872334A (en) * 2016-09-23 2018-04-03 中兴通讯股份有限公司 The method and device that gray scale upgrades in a kind of micro services architecture system
US20180225182A1 (en) * 2017-02-09 2018-08-09 Red Hat, Inc. Fault isolation and identification in versioned microservices
CN109921927A (en) * 2019-02-20 2019-06-21 苏州人之众信息技术有限公司 Real-time calling D-chain trace method based on micro services
US20190220305A1 (en) * 2018-01-16 2019-07-18 Jpmorgan Chase Bank, N.A. Automation as a service
US20190238598A1 (en) * 2018-01-29 2019-08-01 Oracle International Corporation Dynamic client registration for an identity cloud service
CN110134528A (en) * 2019-04-15 2019-08-16 平安普惠企业管理有限公司 Interface message storage call method, device and the terminal device of micro services frame
CN110266815A (en) * 2019-07-10 2019-09-20 西安纸贵互联网科技有限公司 Micro services network system based on block chain
CN110427275A (en) * 2019-07-11 2019-11-08 复旦大学 Micro services latent fault and fault rootstock prediction technique based on trace logs study

Patent Citations (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN107133024A (en) * 2016-02-29 2017-09-05 北京广联达正源兴邦科技有限公司 Business management system based on OSGI frameworks
CN107872334A (en) * 2016-09-23 2018-04-03 中兴通讯股份有限公司 The method and device that gray scale upgrades in a kind of micro services architecture system
CN106850782A (en) * 2017-01-17 2017-06-13 泰康保险集团股份有限公司 For the method and system of log processing
US20180225182A1 (en) * 2017-02-09 2018-08-09 Red Hat, Inc. Fault isolation and identification in versioned microservices
US20190220305A1 (en) * 2018-01-16 2019-07-18 Jpmorgan Chase Bank, N.A. Automation as a service
US20190238598A1 (en) * 2018-01-29 2019-08-01 Oracle International Corporation Dynamic client registration for an identity cloud service
CN109921927A (en) * 2019-02-20 2019-06-21 苏州人之众信息技术有限公司 Real-time calling D-chain trace method based on micro services
CN110134528A (en) * 2019-04-15 2019-08-16 平安普惠企业管理有限公司 Interface message storage call method, device and the terminal device of micro services frame
CN110266815A (en) * 2019-07-10 2019-09-20 西安纸贵互联网科技有限公司 Micro services network system based on block chain
CN110427275A (en) * 2019-07-11 2019-11-08 复旦大学 Micro services latent fault and fault rootstock prediction technique based on trace logs study

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112671706A (en) * 2020-11-25 2021-04-16 四川新网银行股份有限公司 Network access control system based on micro-service architecture

Also Published As

Publication number Publication date
CN111277650B (en) 2021-07-09

Similar Documents

Publication Publication Date Title
Tilley et al. A survey of formal concept analysis support for software engineering activities
Schmid et al. A comparison of decision modeling approaches in product lines
Fluri et al. Classifying change types for qualifying change couplings
Laguna et al. A systematic mapping study on software product line evolution: From legacy system reengineering to product line refactoring
Tisi et al. On the use of higher-order model transformations
CN101887365B (en) Method and system for constructing executable code for component-based applications
CN108845940B (en) Enterprise-level information system automatic function testing method and system
Kim et al. Identifying and summarizing systematic code changes via rule inference
Kamimura et al. Extracting candidates of microservices from monolithic application code
CN107135663A (en) Impact analysis
Halkidi et al. Data mining in software engineering
CN101174212A (en) Collaborative derivation of an interface and partial implementation of
CN108763091B (en) Method, device and system for regression testing
CN101866315B (en) Test method and system of software development tool
Holtmann et al. Cutting through the jungle: Disambiguating model-based traceability terminology
Zahid et al. Evolution in software architecture recovery techniques—A survey
Samimi-Dehkordi et al. Leveraging product line engineering for the development of domain-specific metamodeling languages
CN111277650B (en) Automatic micro-service identification method combining functional indexes and non-functional indexes
Greenan Method-level code clone detection on transformed abstract syntax trees using sequence matching algorithms
Jaskolka et al. Repository mining for changes in Simulink models
Romanov et al. Representing programs with dependency and function call graphs for learning hierarchical embeddings
CN114691491A (en) Use case template generation method, system and medium for smart screen
Bhatia et al. Towards a change taxonomy for machine learning systems
Jatain et al. Reengineering techniques for object oriented legacy systems
Sodhi et al. An Insight on Software Features Supporting Software Transplantation: A Systematic Review

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant