US20130174129A1

Movatterモバイル変換

Info

Publication number: US20130174129A1
Application number: US13/339,528
Authority: US
Inventors: Birgit Grammel; Stefan Kastenholz
Original assignee: SAP SE
Current assignee: SAP SE
Priority date: 2011-12-29
Filing date: 2011-12-29
Publication date: 2013-07-04
Also published as: US8713541B2

Abstract

Implementations of the present disclosure include methods, systems, and computer-readable storage mediums for identifying matching elements between a source model and a target model comprising receiving a source model and a target model, the source model and the target model each being stored in computer-readable memory; processing the source model and the target model to generate a plurality of similarity values, each similarity value being associated with an element of the source model and an element of the target model; generating a similarity value construct based on the plurality of similarity values and elements of the source model and the target model; and identifying matching elements between the source model and the target model based on the similarity value construct.

Description

BACKGROUND

Model-driven software development (MDSD) is the automatic (or semi-automatic) generation of software systems from models across multiple stages. This process can entail the step-wise refinement of models, where the last development stage results in the generation of executable source code. This last development step falls into the category of model-to-text transformations and is not limited to source code generation. Generally the output is string-based and any form of text can be possible. The model transformations preceding the last development step are referred to as model-to-model transformations.

A model transformation can be executed through a transformation engine, which understands and processes a transformation program, being an instance of a corresponding transformation language. A transformation program defines how an output (e.g. source code of a particular programming language) is constructed depending on model data used as input. To understand which output elements were generated by which rule in the transformation program on the basis of which model input elements, traceability data is employed between the generated output, the transformation program, and the input models.

Traceability is the degree to which a relationship can be established between two or more products of the development process, in particular, products having a predecessor-successor or master-subordinate relationship to one another. For example, the degree to which the requirements and design of a given software component match. Traceability data in MDSD can be understood as the runtime footprint of model transformation execution. Trace links provide this kind of information by associating input and output elements with respect to the execution of a certain transformation rules.

SUMMARY

Implementations of the present disclosure include computer-implemented methods including the actions of identifying matching elements between a source model and a target model. The method comprises receiving a source model and a target model, the source model and the target model each being stored in computer-readable memory; processing the source model and the target model to generate a plurality of similarity values, each similarity value being associated with an element of the source model and an element of the target model; generating a similarity value construct based on the plurality of similarity values and elements of the source model and the target model; and identifying matching elements between the source model and the target model based on the similarity value construct.

The present disclosure also provides a computer-readable storage medium coupled to one or more processors and having instructions stored thereon which, when executed by the one or more processors, cause the one or more processors to perform operations in accordance with implementations of the methods provided herein.

The present disclosure further provides a system for implementing the methods provided herein. The system includes one or more processors, and a computer-readable storage medium coupled to the one or more processors having instructions stored thereon which, when executed by the one or more processors, cause the one or more processors to perform operations in accordance with implementations of the methods provided herein.

It is appreciated that methods in accordance with the present disclosure can include any combination of the aspects and features described herein. That is, methods in accordance with the present disclosure are not limited to the combinations of aspects and features specifically described herein, but also include any combination of the aspects and features provided.

The details of one or more implementations of the present disclosure are set forth in the accompanying drawings and the description below. Other features and advantages of the present disclosure will be apparent from the description and drawings, and from the claims.

DESCRIPTION OF DRAWINGS

FIG. 1 is a block diagram of a traceability model matching system.

FIG. 2 show instances of a source model and a target model according to respective meta-models.

FIG. 3 shows an example of a model matching process utilizing the attribute similarity values and the connection similarity values.

FIG. 4 shows an example of a meta-model mapping.

FIG. 5 shows an example of a model matching process utilizing the instance-of similarity measures and the meta-model mapping.

FIG. 6 is a flowchart of an example process that can be executed in accordance with implementations of the present disclosure.

FIG. 7 is a schematic illustration of example computer systems that can be used to execute implementations of the present disclosure.

Like reference symbols in the various drawings indicate like elements.

DETAILED DESCRIPTION

Implementations of the present disclosure are generally directed to generation of trace links in model driven software. In some implementations, a source model can be transformed to a target model. The source model and the target model can each be mapped to graphs that can include elements such as graph nodes (e.g., entities) and data nodes (e.g., attributes). The source model and the target model are input to a traceability model matching system that creates a mapping between the elements of the source model and the target model. This mapping is construed to extract trace links between the source model and the target model. The trace links facilitate determining which target model elements were formed from which source model elements.

To determine (e.g., extract) the trace links between the source and target models, the traceability model matching system receives the source and target models. In some implementations, the source and target models are imported into a common data model. In this manner, the source model and the target model have a common basis for matching algorithms, detailed further below. The traceability model matching system processes the source and the target models to generate similarity values between the elements of the source model and the target model. In some examples, the matching algorithms are applied to the source model and the target model to identify model elements that refer to the same conceptual entity. The traceability model matching system generates a similarity value construct based on the similarity values. In some implementations, each matching algorithm provides similarity values for all source and target model element combinations and generates a respective similarity value matrix. The matrices (e.g., one matrix for each matching algorithm) are arranged in a similarity value construct (e.g., a similarity value cube (SVC)). The SVC is configured to derive a mapping (or matches) between the source elements and the target elements. The traceability model matching system identifies matching elements between the source model and the target model based on the similarity value construct. In some examples, the mapping is analyzed and trace links are extracted between the source model and the target model.

FIG. 1 is a block diagram of a traceabilitymodel matching system100. The traceabilitymodel matching system100 includes amodel import module102, amodel matching module104, aconfiguration module106, and a tracelink extraction module108.

Themodel import module102 receives asource model110 and atarget model112. In some examples, thesource model110 and thetarget model112 are each transformed to a common data model. In some implementations, the common data model is an internal data model to thesystem100. For example, thesource model110 and thetarget model112 can be provided in different model languages. Consequently, thesource model110 and thetarget model112 are transformed into a similar format (e.g., a format of the common data model). In some implementations, thesystem100 includes animport module102 for eachsource model110 anddata model112, dependent upon the language of thesource model110 and thedata model112. Furthermore, as mentioned above, the matching algorithms can be operable on the common data model. Consequently, thesource model110 and thetarget model112 are transformed into the common data model such that the matching algorithms can be applied to thesource model110 and thetarget model112. In some implementations, the common data model includes a graph structure. In some examples, the graph structure can facilitate uniform and adequate expression of thesource model110 and thetarget model112 and expression of thesource model110 and thetarget model112 in relation to corresponding meta-models. In some examples, the graph structure can include type attributed graphs. In some implementations, thesystem100 can employ individual matching algorithms for eachsource model110 andtarget model112. In some implementations, thesource model110 and/or thetarget model112 can be abstractions of text, e.g., software language text.

Themodel matching module104 process thesource model110 and thetarget model112 to generate similarity values between elements of thesource model110 and thetarget model112. To that end, model matching is employed to find a mapping between thesource model110 and thetarget model112 based on a given similarity measure. For each source-target element combination, a similarity value is determined according to a predefined similarity measure. The resulting similarities are analyzed and matches are derived between the source-target element combinations. In some examples, different similarity measures derive differing similarity values between each source-target element combination. For example, each source element is compared with each target element employing the matching algorithms, and for each comparison, similarity values can be determined. Based on the similarity values between each source-target element combination, it is determined whether the source-target element combinations are matched. To that end, and in some implementations, the matching algorithms can include an attribute similarity measure (ATTRIBUTES), a connection similarity measure (CONNECTIONS), and an instance-of similarity measure (INSTANCEOF). In some examples, the similarity values can be between 0 and 1, where, the higher the similarity value, the higher the similarity between the source-target element combinations.

In some implementations, the connection similarity measure includes propagating the similarity value of child source-target graph node combinations to parent source-target graph node combinations. In other words, the source-target parent graph node combinations inherent the similarity values of its child source-target graph node combinations. For example, two parent graph nodes from thesource model110 and thetarget model112 that have similar children graph nodes will likely refer to the same entity. For each parent source-target graph node combination, the child graph nodes of the source parent graph node and the child graph nodes of the target parent graph node are determined. The combination similarity measure is determined for each source-target child graph node combination of each source-target parent graph node combination and placed in a connection similarity matrix. The combination similarity matrix is reduced to a single combination value dependent upon the selection strategy applied to the connection similarity matrix. This single connection similarity value is the connection similarity value between two given parent source-target graph nodes.

Example algorithms that can be used in implementations of the present disclosure include algorithms A-D, provided below.


Require: compare : D_s¹× D_s²→ similiarityValues
Ensure: dataNode_source∈ D_s¹⊂ V_D¹
Ensure: dataNode_target∈ D_s²⊂ V_D²

	1: function COMPUTESIMILIARITY (dataNode_source,dataNode_target)
	2: returncompare (dataNode_source,dataNode_target)
	3: end function

	Ensure: s_i∈ V_G¹
	Ensure: t_j∈ V_G²

4: function MATCHATTRIBUTES (s_i, t_j)

	5:	Nodes_source^ATT← {target_NA¹(e) \| e ∈ E_NA¹and source_NA¹(e) = s_i}
	6:	Nodes_target^ATT← {target_NA²(e) \| e ∈ E_NA²and source_NA²(e) = t_j}
	7:	for all s_i_k∈ Nodes_scurce^ATT, k = {1,..., \|V_D¹\|} do

8:

for all t_j_l∈ Nodes_target^ATT, l = {1,..., | V_D²|} do

9:

SIM_Max(k)Max(l)^ATT

sim_i_k_j_l←

computeSimiliarity(s_i_k, t_j_l)

10:

end for

	11:	end for
	12:	return computeSetSimiliarity(SIM_Max(k)Max(l)^ATT)

	13: end function
	14: function MATCHCONNECTEDNODES (s_i, t_j)

	15:	Nodes_source^Con← {target_G¹(e) \| e ∈ E_G¹and source_G²(e) = s_i}
	16:	Nodes_target^CON← {target_G²(e) \| e ∈ E_G²and source_G²(e) = t_j}
	17:	for all s_i_p∈ Nodes_source^CON, p = {1,..., \| V_G¹\| − 1} do

18:

for all t_j_q∈ Nodes_target^CON, q = {1,..., | V_G²| − 1} do

19:

SIM_Max(p)Max(q)^CON

sim_i_p_j_q←

match Attributes (s_i_p, t_j_q)

20:

end for

	21:	end for
	22:	return computeSetSimiliarity(SIM_Max(p)Max(q)^CON)

23: end function

	End

Algorithm A: determining an attribute similarity value and a connection similarity value


	Require: AG¹= (G¹, D¹) and AG²= (G², D¹)
	Require: G¹= (V_G¹, V_D¹, E_G¹, E_NA¹, E_EA¹, (source_j¹, target_j¹)_j∈_{{G, NA, EA}})
	Require: G²= (V_G², V_D², E_G², E_NA², E_EA², (source_j², target_j²)j∈_{{G, NA, EA}})
	Require: D¹= (S_D¹, OP_D¹) and D²= (S_D²OP_D²)
	Require: similarityValues = {r\|r ∈ and 0 ≦ r ≦ 1} ∪ {UNKNOWN}
	Ensure: similarityMeasure ∈ {ATTRIBUTES, CONNECTIONS}

1: procedure MATCHGRAPHS (AG¹, AG², similarityMeasure)

2:

for all S_i∈ V_G¹, i = {1,..., | V_G¹) do

3:

for all t_j∈ V_G²,j = {1,..., V_G²|} do

4:

SIM_|V_G¹_||V_G²_|

sim_ij←

matchNodes(s_i, t_j, similarityMeasure)

5:

end for

	6:	end for
	7:	matches ← retrieveMatches SIM_\|V_G¹_\|\|V_G²_\|

8: end procedure

	Ensure: s_i∈ V_G¹
	Ensure: t_j∈ V_G²

9: function MATCHNODES (s_i, t_j, similarityMeasure)

10:

if similiarityMeasure = ATTRIBUTES then

11:

return matchAttributes (s_t, t_j)

12:

else if similiarityMeasure = CONNECTIONS then

13:

return matchConnectedNodes (s_i, t_j)

	14:	end if
	15:	return UNKNOWN

16: end function

	end

Algorithm B: mapping between the source model and the target model


	Ensure: s_i∈ V_G¹and Node_source^ATT^—^Type∈ V_G¹
	Ensure: tj ∈ V_G²and Node_target^ATT^—^Type∈ V_G²
	Ensure: typeSimilarityMeasure ∈ similarityMeasure \
	{INSTANCEOF}
	1: function MATCHNODETYPES (s_i, t_j)

	2:	Nodes_source^ATG^—^Type← t¹(s_i)
	3:	Nodes_target^ATG^—^Type← t²(t_j)
	4:	return matchNodes (Node_source^ATT^—^Type,

Node_target^ATT^—^Type,

typeSimilarityMeasure)

	5: end function
	end

Algorithm C: determining the instance-of similarity value


Require: AG¹= (G¹, D¹) and AG²= (G², D²)
Require: G¹= (V_G¹, V_D¹, E_G¹, E_NA¹, E_EA¹, (source_j¹, targetj¹)_j∈_{{G, NA, EA}})
Require: G²= (F_G², F_D², E_G², E_NA², E_EA², (source_j², target_j²)_j∈_{{G, NA, EA}})
Require: ATG¹= (TG¹, Z¹) with Z¹as final algebra of D¹
Require: ATG²= (TG², Z²) with Z²as final algebra of D²
Require: TG¹= (G¹, Z¹) and TG²= (G², Z²)
Require: G¹= (V_G¹, V_D¹, E_G¹, E_NA¹, E_EA¹, (Source_j¹, Target_j¹}_j∈_{{G,NA, EA}})
Require: G²= (V_G², V_D², E_G², E_NA², E_EA², (Source_j², Target_j²)_j∈_{{G, NA, EA}})
Require: TAG¹= (AG¹,t¹) over ATG¹with t¹: AG¹→ ATG¹
Require: TAG²= (AG²,t²} over ATG²with t²: AG²→ ATG²
Require: similarityValues = {r\|r ∈ R and r ≧ 0 and r ≦ 1} ∪ {UNKNOWN}
Ensure: similarityMeasure ∈ {ATTRIBUTES, CONNECTIONS, INSTANCEOF}

1: procedure MATCHTYPEDGRAPHS (TAG¹, TAG², similarityMeasure)

2:

matchGraphs (AG¹, AG², similarityMeasure)

3: end procedure

Ensure (s_i, t_j) ∈ (V_G¹× V_G²∪ (V_G¹× V_G²)

4: function MATCHNODES ((s_i, t_j), similarity Measure)

5:

if similiarityMeasure = ATTRIBUTES then

6:

return matchAttributes (s_i, t_j)

7:

else if similiarityMeasure = CONNECTIONS then

8:

return matchConnectedNodes (s_i, t_j)

9:

else if similiarityMeasure = INSTANCEOF then

10:

return matchNodeTypes (s_i, t_j)

	11:	end if
	12:	return UNKNOWN

13: end function

end

Algorithm D: mapping between the source model and the target model

G indicates a graph, AG indicates an attributed graph, D_Sindicates a data sort (a set of data nodes of the same sort, that is, with labels of the same language, e.g. String), D indicates an algebraic signature, where S_Dindicates the set S of sorts for D, and OP_Dindicates a family of n-ary operations on S_D, Z indicates the final algebra of D, ATG indicates an attributed typed graph, V indicates a set of graph nodes (V_Ggraph nodes, V_Ddata nodes), E indicates a set of graph edges (E_Gusual graph edges and special edges E_NAand E_EAused for node resp. edge attribution), and TAG indicates a typed attributed graph. Also, italicized passages indicate reference to the meta-model. Example algorithm A provides for determining an attribute similarity value and a connection similarity value.

The attribute similarity value and the connection similarity value can be employed to match thesource model110 and thetarget model112 and provide a mapping between the source and the target graph nodes. Example algorithm B provides for mapping between thesource model110 and thetarget model112. Algorithm B utilizes the matchAttributes and the matchConnectedNodes functions provided in Algorithm A.

Example algorithm C provides for determining the instance-of similarity value. Algorithm C employs the matchNodes function provided in Algorithm B.

The instance-of similarity value can be employed to match thesource model110 and thetarget model112 and provide a mapping between the source and the target graph nodes. Example algorithm D provides for mapping between thesource model110 and thetarget model112. Algorithm D employs the matchGraphs function defined in Algorithm B and the matchNodeTypes function defined in Algorithm C.

In some implementations, additional matching algorithms can also be in employed by themodel matching module104 in conjunction with the above-mentioned matching algorithms. For example, a graph edit distance (GED) algorithm and/or a pattern matcher algorithm can be employed. The GED algorithm determines a similarity of two given source-target element combinations based on a connection of the source-target element combination in a common subgraph. The pattern matcher algorithm determines a similarity of two given source-target element combinations based on a recurring pattern in the source and the target model.

Theconfiguration module106 generates a similarity value construct based on the similarity measures. Specifically, each matching algorithm provides similarity values between elements of thesource model110 and thetarget model112, with the similarity values placed in a respective similarity value matrix. The similarity value matrices are arranged into a similarity value construct, or a similarity value cube (SVC). To provide a mapping (or matching) between source-target element combinations from the SVC, the SVC is configured to form an aggregation matrix by either determining the average of the similarity values or by selecting all similarity values exceeding a threshold. Further, the selection of how the SVC is configured can affect the quality of matching results.

The tracelink extraction module108 matches elements between thesource model110 and thetarget model112 based on the similarity value construct. Specifically, the tracelink extraction module108 analyzes the mapping and extracts tracelinks114 between thesource model110 and thetarget model112. For example, atrace link114 can be extracted between thesource model110 and thetarget model112 when the similarity value, as provided in the SVC, between a source-target element combination is above a threshold.

FIG. 2 show instances of asource model202 and atarget model206 according to respective meta-models. Specifically, thesource model202 is an instance of the source meta-model204 and thetarget model206 is an instance of the target meta-model208. Thesource model202 and thetarget model206 can be imported to thesystem100 by themodel import module102. Thesource model202 and thetarget model206 can be analogous to thesource model110 and thetarget model112, respectively, mentioned above with respect toFIG. 1.

The source meta-model204 includes anentity graph node210 that has a childfeature graph node212. Theentity graph node210 and thefeature graph node212 both contain astring data node214. Further, thesource model202 includes anentity graph node216 that contains adata node218 of “person.” Theentity graph node216 has child nodes offeature1 graph node220 andfeature2 graph node222.Feature1 graph node220 contains adata node224 of “name” andfeature2 graph node222 contains adata node226 of “age.”

The target meta-model208 includes aclass graph node250 that has a childfield graph node252 and a childmethod graph node254. Theclass graph node250, the childfield graph node252, and the childmethod graph node254 contain astring data node256. Further, thetarget model206 includes aclass graph node258 that contains adata node260 of “person.” Theclass graph node258 has child nodes offield1 graph node262,field2 graph node264,method1 graph node266, andmethod2 graph node268.Field1 graph node262 contains adata node270 of “name;”field2 graph node264 contains adata node272 of “age;”method1 graph node266 contains adata node274 of “getName;” andmethod2 graph node268 contains adata node276 of “getAge.”

FIG. 3 shows an example of a model matching process utilizing the attribute similarity values and the connection similarity values. Specifically,FIG. 3 includes mappings between thesource model202 and thetarget model206. To that end, employing Algorithms A and B, the product of the set of all source graph nodes (e.g.,entity graph node216,feature1 graph node220, and feature2 graph node222) and the set of all target graph nodes (e.g.,class graph node258,field1 graph node262,field2 graph node264,method1 graph node266, and method2 graph node268) is determined, providing a similarity matrix (for each of the attribute similarity values and of the connection similarity values) of fifteen cells for each source-target graph node combination. The similarity values can be based on the attribute similarity values and/or the connection similarity values.

To that end, when the similarity values are based on the attribute similarity values, the data nodes of each source-target graph node combination are retrieved, and the attribute similarity values are determined. The attribute similarity values are dependent on the specific algorithm employed, (e.g., the computeSimiliarity function of Algorithm A). In some examples, the similarity values are determined such that, for given data sorts D_S²=D_S¹=String, with v ε D_S¹and w ε D_S², the function compare: D_S¹×D_S²→similarityValues can be defined as:

compare (v, w) = {\begin{matrix} 1, & if v = w \\ 0, 5, & if v \subseteq w \\ 0, & if v \neq w \end{matrix}

Continuing the example, for the source-target graph node combination ofentity graph node216 andclass graph node258, the

data nodes

218 and260 are retrieved. Since the labels (i.e., strings) of

data nodes

218 and260 are identical (e.g., contain the attribute “person”), a similarity value of 1 (or any value between 0 and 1) is assigned to the source-target graph node combination ofentity graph node216 andclass graph node258. Analogously, for the source-target graph node combination offeature1 graph node220 andclass graph node258, a similarity value of 0 is determined, since thedata node224 and thedata node260 are not identical (thedata node224 contains the attribute “name” and thedata node260 contains the attribute “person”). Similarly, the above compare function can be applied to each of the remaining source-target graph node combination of thesource model202 and thetarget model206, as shown by Table 1.

TABLE 1

Example similarity values of graph nodes.

	class	field1	field2	method1	method2

entity	1	0	0	0	0
feature1	0	1	0	0.5	0
feature2	0	0	1	0	0.5

The resulting mapping of the source-target graph node combinations is depicted inFIG. 3. Specifically,line302 includes a value of 1 and represents the similarity value betweenentity graph node216 andclass graph node258;line304 includes a value of 1 and represents the similarity value betweenfeature1 graph node220 andfield1 graph node262;line306 includes a value of 1 and represents the similarity value betweenfeature2 graph node222 andfield2 graph node264;line308 includes a value of 0.5 and represents the similarity value betweenfeature1 graph node220 andmethod1 graph node266; andline310 includes a value of 0.5 and represents the similarity value betweenfeature2 graph node222 andmethod2 graph node268.

To that end, when the similarity values are based on the connection similarity measure, the children graph nodes of each source-target graph node combination are retrieved, and the similarity values are determined. For example, thefeature1 graph node220 andfeature2 graph node222 are retrieved for theentity graph node216 andfield1 graph node262,field2 graph node264,method1 graph node266, andmethod2 graph node268 are retrieved for theclass graph node258. To that end, for each child source-target graph node combination, a similarity value is determined based on the similarity values of Table 1, resulting in a similarity value matrix. In some implementations, the similarity value matrix is reduced to a singularly value by taking the average of all values from corresponding child source-target graph node combinations. Continuing the example, a similarity value of 0.75 (average of lines304-310) is determined and propagated to the parent source-target graph node combination ofentity graph node216 andclass graph node258, denoted byline312.

FIG. 4 shows an example of a meta-model mapping. Specifically,FIG. 4 includes mappings between the source meta-model204 and the target meta-model208. Specifically, theentity graph node210 of the source meta-model204 is mapped to theclass graph node250 of the target meta-model208. Further, thefeature graph node212 of the source meta-model204 is mapped to thefield graph node252 and themethod graph node254 of the target meta-model208.

FIG. 5 shows an example of a model matching process utilizing the instance-of similarity measures and the meta-model mapping ofFIG. 4. Specifically,FIG. 5 includes mappings between thesource model202 and thetarget model206. To that end, employing Algorithms C and D, the product of the set of all source graph nodes (e.g.,entity graph node216,feature1 graph node220, and feature2 graph node222) and the set of all target graph nodes (e.g.,class graph node258,field1 graph node262,field2 graph node264,method1 graph node266, and method2 graph node268) is determined, providing an instance-of similarity matrix of fifteen cells for each source-target graph node combination.

For each source-target graph node combination, a similarity value is determined between the nodes of the source meta-model204 and the target meta-model208. For example, theentity graph node210 of the source meta-model204 corresponds to theentity graph node216 of thesource model202. Further, since a mapping exists between theentity graph node210 of the source meta-model204 and theclass graph node250 of the target meta-model208, the similarly value of 1 (or any value between 0 and 1) is propagated to the corresponding source-target graph node combination of theentity graph node216 of thesource model202 and theclass graph node258 of thetarget model208. Similarly, the similarity of theentity graph node216 of thesource model202 and thefield graph node262 of thetarget model206 can be determined. However, since theentity graph node210 of the source meta-model204 and thefield graph node252 of the target meta-model208 do not match, the similarity of the source-target graph node combination of theentity graph node216 and thefield graph node262 is 0. Similarly, the above can be applied to the remaining source-target graph node combinations of thesource model202 and thetarget model206 and propagated to the corresponding source-target graph node combinations of thesource model202 and thetarget model208, as shown by Table 2.

TABLE 2

Example similarity values of AG nodes.

	class	field1	field2	method1	method2

entity	1	0	0	0	0
feature1	0	1	1	1	1
feature2	0	1	1	1	1

FIG. 6 is a flowchart of anexample process600 that can be executed in accordance with implementations of the present disclosure. Theexample process600 can be executed using one or more computing devices.

The source model and the target model are received (602). For example, themodel import module102 receives the source model110 (or the source model202) and the target model112 (or the target model206). In some implementations, thesource model110 and thetarget model112 data can be retrieved from computer-readable memory. The source model and the target model are imported (604). For example, themodel import module102 imports source model110 (or the source model202) and the target model112 (or the target model206) into a common data model of thesystem100. Similarity values between the source model and the target model are determined (606). For example, themodel matching module104 generates similarity values between the source model110 (or the source model202) and the target model112 (or the target model206). The similarity values can include, among others, the attribute similarity values, the connections similarity values, and the instance-of similarity values. Further, each matching algorithm of themodel matching module104 provides similarity values for all source-target model node combinations and generates a respective similarity value matrix. The SVC is constructed (608). For example, theconfiguration module106 constructs the SVC based on the similarity values between the source model110 (or the source model202) and the target model112 (or the target model206). To provide a mapping (or matching) between source-target node combinations from the SVC, the SVC is configured to form an aggregation matrix by either determining the average of the similarity values or by selecting all similarity values exceeding a threshold. Match(es) between elements of the source model and the target model are identified (610). For example, the tracelink extraction module108 identifies matches between nodes of the source model110 (or the source model202) and the target model112 (or the target model206) based on the SVC. Trace links are extracted between the source model and the target model (612). For example, the tracelink extraction module108 analyzes the match(es) between elements of the source model110 (or the source model202) and the target model112 (or the target model206), and extracts trace links based on these match(es).

Referring now toFIG. 7, a schematic diagram of an example computing system800 is provided. Thesystem700 can be used for the operations described in association with the implementations described herein. For example, thesystem700 may be included in any or all of the server components discussed herein. Thesystem700 includes aprocessor710, amemory720, astorage device730, and an input/output device740. Each of the

components

710,720,730, and740 are interconnected using asystem bus750. Theprocessor710 is capable of processing instructions for execution within thesystem700. In one implementation, theprocessor710 is a single-threaded processor. In another implementation, theprocessor710 is a multi-threaded processor. Theprocessor710 is capable of processing instructions stored in thememory720 or on thestorage device730 to display graphical information for a user interface on the input/output device740.

Thememory720 stores information within thesystem700. In one implementation, thememory720 is a computer-readable medium. In one implementation, thememory720 is a volatile memory unit. In another implementation, thememory720 is a non-volatile memory unit. Thestorage device730 is capable of providing mass storage for thesystem700. In one implementation, thestorage device730 is a computer-readable medium. In various different implementations, thestorage device730 may be a floppy disk device, a hard disk device, an optical disk device, or a tape device. The input/output device740 provides input/output operations for thesystem700. In one implementation, the input/output device740 includes a keyboard and/or pointing device. In another implementation, the input/output device740 includes a display unit for displaying graphical user interfaces.

The features described can be implemented in digital electronic circuitry, or in computer hardware, firmware, software, or in combinations of them. The apparatus can be implemented in a computer program product tangibly embodied in an information carrier, e.g., in a machine-readable storage device, for execution by a programmable processor; and method steps can be performed by a programmable processor executing a program of instructions to perform functions of the described implementations by operating on input data and generating output. The described features can be implemented advantageously in one or more computer programs that are executable on a programmable system including at least one programmable processor coupled to receive data and instructions from, and to transmit data and instructions to, a data storage system, at least one input device, and at least one output device. A computer program is a set of instructions that can be used, directly or indirectly, in a computer to perform a certain activity or bring about a certain result. A computer program can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment.

Suitable processors for the execution of a program of instructions include, by way of example, both general and special purpose microprocessors, and the sole processor or one of multiple processors of any kind of computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for executing instructions and one or more memories for storing instructions and data. Generally, a computer will also include, or be operatively coupled to communicate with, one or more mass storage devices for storing data files; such devices include magnetic disks, such as internal hard disks and removable disks; magneto-optical disks; and optical disks. Storage devices suitable for tangibly embodying computer program instructions and data include all forms of non-volatile memory, including by way of example semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices; magnetic disks such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in, ASICs (application-specific integrated circuits).

To provide for interaction with a user, the features can be implemented on a computer having a display device such as a CRT (cathode ray tube) or LCD (liquid crystal display) monitor for displaying information to the user and a keyboard and a pointing device such as a mouse or a trackball by which the user can provide input to the computer.

The features can be implemented in a computer system that includes a back-end component, such as a data server, or that includes a middleware component, such as an application server or an Internet server, or that includes a front-end component, such as a client computer having a graphical user interface or an Internet browser, or any combination of them. The components of the system can be connected by any form or medium of digital data communication such as a communication network. Examples of communication networks include, e.g., a LAN, a WAN, and the computers and networks forming the Internet.

The computer system can include clients and servers. A client and server are generally remote from each other and typically interact through a network, such as the described one. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other.

In addition, the logic flows depicted in the figures do not require the particular order shown, or sequential order, to achieve desirable results. In addition, other steps may be provided, or steps may be eliminated, from the described flows, and other components may be added to, or removed from, the described systems. Accordingly, other implementations are within the scope of the following claims.

A number of implementations of the present disclosure have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope of the present disclosure. Accordingly, other implementations are within the scope of the following claims.