Domestic system migration adaptation method and device based on multi-dimensional dependency graph

Abstract

The invention discloses a localized system migration adaptation method and device based on a multi-dimensional dependency graph. The method comprises the following steps: firstly, collecting cross-level dependency clues of a to-be-migrated system, and generating a dependency event sequence; then constructing a dependency graph based on the event sequence, and extracting a graph primitive used for describing an event association structure from the graph; generating an adaptive mapping tensor by using the map primitive to quantify the interface difference, instruction path offset and time sequence tolerance interval of each technical component in different localized target environments, and forming adaptive resistance distribution representing migration difficulty; on this basis, inferring the adaptation trend and possible blocking position of the system dependency chain, and obtaining a key dependency chain set which needs to be emphatically processed; and generating a structured migration rule according to the set and converting the structured migration rule into an executable migration instruction sequence, thereby realizing high efficiency and controllability of system migration. According to the method, the accuracy and the automation degree of localization migration are remarkably improved through the synergistic effect of the multi-dimensional dependency map and the tensorization adaptation analysis.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and in particular to a method and apparatus for migration and adaptation of domestically produced systems based on multidimensional dependency graphs. Background Technology

[0002] As information systems become increasingly complex, business systems are typically composed of multiple layers of technical elements, including operating system interfaces, chip instruction sets, database access mechanisms, and middleware collaboration processes. When migrating existing technologies to domestic versions, methods such as log analysis, interface call tracing, and compatibility script detection are commonly used to identify system technical dependencies. Preliminary assessments of the compatibility between various components are then made based on static relationship tables or manual experience. Much of the migration work relies on manually identifying dependencies, analyzing component differences, and developing a migration plan through item-by-item verification.

[0003] However, when faced with complex dependencies across levels, components, and logical paths, existing technologies typically only identify explicit dependencies, failing to fully cover implicit coupling relationships and potential conflict events. This leads to problems such as missing dependency chains, inaccurate compatibility assessments, and difficulties in automatically generating migration rules during the migration process. Furthermore, existing methods generally lack a unified data structure to represent the differences in component behavior under different target environments, making it difficult to quantify and assess migration difficulty, and resulting in a lack of specificity and predictability in the design of migration steps.

[0004] In view of the above situation, it is necessary to propose a new method that can systematically express multidimensional dependencies, quantify migration difficulty, and support automated migration generation, so as to improve the accuracy and controllability of migration of domestically produced systems. Summary of the Invention

[0005] This application provides a method and apparatus for migrating and adapting domestically produced systems based on multidimensional dependency graphs, so as to improve the accuracy and controllability of migrating domestically produced systems.

[0006] This application provides a method for migration and adaptation of domestically developed systems based on multidimensional dependency graphs, including: Collect cross-level technical dependency clues from the business systems to be migrated, and generate a dependency event sequence based on the triggering order and resource association; A multidimensional dependency graph with explicit dependency dimension, implicit coupling dimension and potential conflict dimension is constructed based on the dependent event sequence, and graph primitives are formed from the multidimensional dependency graph to characterize the event association mode. The adaptation mapping tensor is generated using graph primitives to describe the interface differences, instruction path offsets, and timing tolerance ranges of various technical components under different domestic production target environments, and a migration adaptation resistance distribution is formed accordingly. Based on the distribution of migration adaptation resistance, the adaptation trend and potential bottlenecks of each dependency chain of the business system to be migrated are inferred, forming a set of key dependency chains to be calibrated; The system migration is then completed based on the set of key dependency chains, structured localization migration rules are generated, structured localization migration rules are converted into an executable migration instruction sequence, and system migration is completed based on the migration instruction sequence.

[0007] This application provides a domestically developed system migration and adaptation device based on a multidimensional dependency graph, comprising: The collection unit is used to collect cross-level technical dependency clues of the business system to be migrated, and generate a dependency event sequence based on the triggering order and resource association relationship. The building unit is used to construct a multidimensional dependency graph with explicit dependency dimension, implicit coupling dimension and potential conflict dimension based on the sequence of dependent events, and the multidimensional dependency graph forms a graph primitive used to characterize the way events are associated. The generation unit is used to generate an adaptation mapping tensor using graph primitives to describe the interface differences, instruction path offsets, and timing tolerance ranges of various technical components under different domestic production target environments, and to form a migration adaptation resistance distribution accordingly. The forming unit is used to infer the adaptation trend and potential bottlenecks of each dependency chain of the business system to be migrated based on the migration adaptation resistance distribution, and form a set of key dependency chains to be calibrated. The migration unit is used to generate structured localization migration rules based on the set of key dependency chains, convert the structured localization migration rules into an executable migration instruction sequence, and complete the system migration according to the migration instruction sequence.

[0008] The beneficial effects of this application mainly include: (1) By collecting dependency clues of multi-level technical elements such as operating system, chip instruction set, database and middleware, and organizing them in the form of event sequence, the system can obtain complete dependency structure information including explicit dependencies, implicit coupling and potential conflicts before migration, which significantly reduces the risk of failure due to dependency omission during migration. (2) This application expresses component behavior differences, instruction path offset and timing characteristics in a unified tensor structure to form a computable migration adaptation resistance distribution, which transforms the migration difficulty from experience judgment to quantifiable technical indicators, thereby enabling accurate positioning of migration risks. (3) Based on the migration adaptation resistance distribution, the trend and bottleneck of the dependency chain are inferred, and a set of key dependency chains to be calibrated can be automatically formed, so that migration planning no longer relies on manual experience judgment, effectively improving the pertinence and controllability of the migration scheme. (4) By transforming the set of key dependency chains into structured localization migration rules and further generating executable instruction sequences, the migration process can complete interface replacement, instruction reconstruction and timing adjustment in an automated manner, significantly reducing the amount of manual intervention and improving the overall efficiency and consistency of migration. Attached Figure Description

[0009] Figure 1 This is a flowchart of a domestic system migration and adaptation method based on a multidimensional dependency graph provided in the first embodiment of this application.

[0010] Figure 2 This is a schematic diagram of a domestically produced system migration and adaptation device based on a multidimensional dependency graph, provided in the second embodiment of this application. Detailed Implementation

[0011] Many specific details are set forth in the following description to provide a full understanding of this application. However, this application can be implemented in many other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of this application; therefore, this application is not limited to the specific embodiments disclosed below.

[0012] The first embodiment of this application provides a method for migration and adaptation of domestically developed systems based on multidimensional dependency graphs. Please refer to... Figure 1 This figure is a flowchart of the first embodiment of this application. The following is in conjunction with... Figure 1 The first embodiment of this application provides a detailed description of a domestic system migration and adaptation method based on a multidimensional dependency graph.

[0013] Step S101: Collect cross-level technical dependency clues of the business system to be migrated, and generate a dependency event sequence based on the triggering order and resource association relationship.

[0014] When performing dependency analysis on a business system to be migrated, the first step is to comprehensively collect cross-layer technical dependency clues generated during the system's actual operation. "Cross-layer" means that the operational behavior of a business system is typically not determined by a single software component, but rather by the collaborative efforts of the operating system layer, chip instruction execution layer, database access layer, middleware runtime layer, and business logic layer. Therefore, it is necessary to obtain the true dependencies of the system at runtime from multiple technical dimensions. To ensure the reconfigurability of the collected content, all dependency clues need to be organized according to their chronological order and the relationships between system resources, thus forming a dependency event sequence that facilitates subsequent processing.

[0015] Dependency clues refer to runtime data that reflects usage relationships, calling relationships, or resource contention relationships between components. Examples include system call logs, thread scheduling records, execution traces of database queries, timestamps from message queues, network connection establishment and closure behavior, file system read / write events, and key instruction information triggered during chip instruction set execution. This information collectively constitutes the actual behavioral picture of a business system at runtime. Those skilled in the art can obtain these dependency clues through instrumentation techniques, system monitoring interfaces, database audit logs, and performance analysis tools for the JVM or other runtime environments. For example, in Linux systems, system call behavior can be captured using tools like strace or perf; in databases, each query statement and its execution time can be captured through audit logs; and in middleware, message sending and receiving times can be recorded through message queue monitoring interfaces.

[0016] After collecting these dependency clues, a dependency event sequence needs to be generated based on the triggering order and resource association. The triggering order refers to the chronological order in which each dependent action occurs. If system call A of a certain thread occurs before system call B, then A should be positioned before B in the event sequence. This step typically requires sorting based on the timestamps of the events. For example, if the recorded time information is as follows: event E1 occurs at 10:01:02.123, and event E2 occurs at 10:01:02.145, then E1 should be placed before E2. The higher the precision of the timestamps, the more accurate the event sequence recovery. If timestamps are duplicated or indistinguishable, additional information such as thread ID and call stack depth can be used to assist in sorting to avoid misidentification of subsequent dependency structures due to ambiguous event order.

[0017] In this context, resources refer to entities accessed or consumed during the operation of a business system, such as CPU cores, memory blocks, database connections, file handles, network ports, and message queue channels. Resource relationships describe whether two events are logically connected due to sharing a resource. For example, a database query event and a database lock wait event may have a resource contention relationship, and this relationship must be reflected in the dependency sequence. To determine this relationship, those skilled in the art typically match them based on unique resource identifiers (such as file descriptors, database connection IDs, message queue channel numbers, etc.). For example, assuming that events X and Y both access the same file descriptor FD=18, then events X and Y can be considered to have a resource relationship. During sequence generation, such events need to be marked as related to reflect implicit coupling or potential conflicts in subsequent analysis.

[0018] After organizing the trigger order and resource relationships, all collected events need to be recombined into a dependency event sequence based on the sorting results and resource relationships. This sequence is not just a simple list, but an ordered set containing the relationship structure between events, enabling subsequent steps to recover the system's dependency network based on the sequence. For example, a simplified event sequence might be: Event A: Thread T1 calls a database query (Resource: Connection ID=3) Event B: Thread T2 performs a file write (Resource: File Descriptor=18) Event C: Thread T1 waits for a database lock (Resource: Connection ID=3) Based on the above sequence, it can be inferred that events A and C belong to the same resource link, while event B belongs to another independent link due to different resources.

[0019] Through the aforementioned steps of data collection, sorting, and correlation analysis, the resulting dependency event sequences accurately reflect the triggering and resource relationships between various components during the operation of the business system. This lays a clear and structurally sound data foundation for the subsequent construction of a multidimensional dependency graph. When reading these event sequences, the temporal characteristics and resource identifiers can be used to accurately understand the logical process of system operation, thereby facilitating the next step of graph construction.

[0020] Furthermore, the process of collecting cross-level technical dependency clues from the business systems to be migrated, and generating a dependency event sequence based on the triggering order and resource association, includes: Before the business system runs, inject a unique hierarchical identifier into the operating system call entry point, database access entry point, middleware message entry point, and processor instruction trigger point, so that the dependency clues of each level can be clearly distinguished in subsequent processing, forming an initial dependency record with hierarchical attributes. During the operation of the business system, the initial dependency records with hierarchical attributes are sorted according to the timestamp when the records are generated, and the time difference between adjacent records is calculated as the event trigger interval. The trigger interval is then appended to the corresponding record to obtain a sorted dependency sequence containing trigger order information. Based on the sorted dependency sequence, the dependency records that access the same resource identifier are clustered, and the resource occupation time overlap between events in each cluster is calculated. The overlap is divided by the duration of the shorter occupation time to obtain the resource association ratio. The resource association ratio is appended to each event in the cluster to form an event clustering sequence with resource association ratio. Based on the event clustering sequence with resource association ratio, each event is combined and encoded according to its hierarchical identifier, trigger interval and resource association ratio to generate an event code that can uniquely reflect the triggering characteristics and resource association of the event in different levels. Using the event code as the key, the events are written into the dependent event sequence in order of occurrence, so that the dependent event sequence simultaneously contains cross-level triggering attributes, sorting triggering information and resource association relationship.

[0021] Before collecting cross-level technical dependency clues from the business system to be migrated, it is necessary to inject identifiers into the key entry points of the system operation to distinguish technical events at different levels in subsequent analysis. Here, "level" refers to the multiple technical layers upon which the business system relies during execution, including the operating system layer that carries basic functions, the database layer responsible for data access, the middleware layer that handles business processes and message exchange, and the processor instruction layer that executes instruction sequences and algorithm logic. A level identifier is a unique number that clearly indicates the technical level to which an event belongs. For example, L1 can represent the operating system call entry point, L2 the database access entry point, L3 the middleware message entry point, and L4 the processor instruction trigger point. To ensure accurate identification of dependent events, identifiers for different levels must not be duplicated. Before the business system runs, these identifiers are injected into the corresponding entry points so that whenever a business execution triggers an entry point, the system automatically generates an initial dependency record with level attributes. Such a record includes at least the timestamp of the event occurrence, the corresponding level identifier, and the source code location or resource number of the event. This approach makes it easy to distinguish dependency events from different sources during system runtime, thus providing a structured foundation for the entire dependency collection process.

[0022] During the operation of a business system, each identified dependent event generates a record based on its occurrence time. Therefore, all initial dependent records need to be sorted by timestamp to reconstruct the true trigger sequence during system runtime. Timestamps are typically measured in milliseconds or microseconds, accurately recording the relative order of events. For the sorted dependent records, the time difference between adjacent events needs to be calculated; this time difference is called the event trigger interval. The event trigger interval reflects the natural interval between two events; a smaller trigger interval usually indicates some causal or coherent relationship between the events. To calculate the trigger interval, simply subtract the timestamp of the preceding event from the timestamp of the following event to obtain a positive value. For example, if the timestamp of event A is 100.205 milliseconds and the timestamp of event B is 100.320 milliseconds, then the event trigger interval is 100.320 - 100.205 = 0.115 milliseconds. This trigger interval is then appended to the record of event B, making it part of the record. After sorting and interval appending, the dependent record sequence not only reflects the events themselves, but also the temporal relationships between events, thus forming a sorted dependent sequence containing triggering order information.

[0023] With the ranking dependency sequence established, it is necessary to further identify events that access the same resource and group them into the same cluster. Resource identifiers are used to represent the specific resource object accessed by the event, such as database connection number, file descriptor, network socket number, or cache block number. When two or more events access the same resource identifier, these events can be grouped into the same cluster. After clustering, it is necessary to calculate the resource usage time overlap between each pair of events within the cluster. The resource usage time overlap is the length of the overlapping interval between the usage time of the same resource by two events. For example, if event C uses the resource for a time interval from 10ms to 18ms, and event D uses the resource for a time interval from 15ms to 20ms, then the overlap between them is 15ms to 18ms, with an overlap of 3ms. This overlap is then divided by the shorter usage time of the two events to obtain the resource association ratio. If event C lasts for 8ms and event D lasts for 5ms, then the shorter duration is 5ms, and the resource association ratio is calculated as 3 ÷ 5 = 0.6. The larger this ratio, the stronger the concurrent dependency of the events on the resources. This calculated resource association ratio is appended to the records of the relevant events, giving the events not only hierarchical identifiers and trigger intervals, but also quantified relationships between resources, thus forming an event cluster sequence with resource association ratios.

[0024] After obtaining the event clustering sequence with resource association ratios, each event needs to be combined and encoded according to its hierarchical identifier, trigger interval, and resource association ratio to generate an event code that uniquely reflects the triggering characteristics and resource association of the event at different levels. Combined encoding is a method of integrating multiple feature values ​​into a unique identifier. Its encoded content includes at least the hierarchical number, the quantified value of the trigger interval, and the resource association ratio. For example, a string code can be generated in the format "hierarchical identifier - trigger interval value - resource association ratio," such as L2-0.115-0.6, indicating that the event belongs to the database layer, the trigger interval is 0.115 milliseconds, and its resource association ratio with a certain event is 0.6. This combined encoding method ensures that each event has a unique and stable feature description throughout the entire sequence, preventing confusion in subsequent dependency analysis, graph construction, and association extraction.

[0025] After completing the combined encoding, the event codes are used as keys and written into the dependent event sequence one by one according to the order of event occurrence. This sequence simultaneously contains cross-level triggering attributes, ordering triggering information, and resource association relationships. This means that each event in the sequence carries hierarchical attributes, contextual timing information, and resource access coupling degree, forming a complete, multi-dimensional event data structure. When reading this sequence, those skilled in the art can directly determine the technical level, triggering logic, and resource dependencies of the events based on the information fields, thus providing an unambiguous and high-precision data foundation for subsequent multi-dimensional dependency graph construction.

[0026] Through the above steps, the cross-level operation behavior of complex business systems can be accurately converted into a structured, serialized, and quantifiable sequence of dependency events, so that subsequent dependency analysis and adaptation migration can be based on reliable and comprehensive technical information.

[0027] Step S102: Construct a multidimensional dependency graph with explicit dependency dimension, implicit coupling dimension and potential conflict dimension based on the dependent event sequence, and form graph primitives from the multidimensional dependency graph to characterize the event association mode.

[0028] After obtaining the sequence of dependent events, a multidimensional dependency graph that fully reflects the internal operational logic of the business system needs to be constructed based on this sequence. To ensure the graph accurately represents the system's technical dependencies, this step divides the dependencies into three dimensions: explicit dependency dimension, implicit coupling dimension, and potential conflict dimension. These dimensions work together to form a structurally constrained graph representation. A multidimensional dependency graph is structured graphical data consisting of dependent events as nodes and various types of relationships between events as edges. Each dimension describes a different type of event relationship, enabling the reconstruction of the system's internal operational relationships through the graph.

[0029] To ensure the accuracy of the graph, the meaning of explicit dependency must first be clarified. Explicit dependency refers to a call, access, or triggering relationship that is directly reflected in the event sequence. For example, a database query event necessarily depends on a database connection establishment event, and a file write event necessarily depends on a file open event. Therefore, when constructing the graph, these inherent sequential relationships can be established as directed edges between nodes. For example, when the timestamp of event E1 is earlier than that of event E2, and their resource identifiers are the same, the explicit dependency of E1→E2 can be determined. For events sharing resources, those skilled in the art can make accurate judgments based on the resource identifiers.

[0030] Implicit coupling dimensions describe events that, while not directly interacting through calls or accesses, exhibit correlation in their behavior due to internal system mechanisms. For example, two threads may not communicate directly but are associated due to competing for the same lock resource; or two database queries, though belonging to different business logics, may be coupled in performance due to shared cache. In such cases, the existence of implicit coupling can be inferred from resource usage patterns, thread scheduling order, and shared data access patterns in the event sequence. Assuming events X and Y belong to different threads but are highly close in time and simultaneously access the same shared cache region, undirected edges representing implicit coupling can be added to the graph and labeled as coupling relationships. To make implicit coupling quantifiable, the coupling strength between events can be calculated, for example, by calculating the ratio of the number of times two events access the same type of resource. For instance, if event X accesses cache block C for the first time, and event Y immediately follows by accessing the same cache block C, the coupling strength can be set to 1; if event X accesses cache block C twice, while event Y accesses it only once, the coupling strength can be set to 1 / 2. There are no fixed restrictions on the calculation method; it is only necessary to ensure that it can be repeated.

[0031] The potential conflict dimension is used to express dangerous relationships within a system that may arise from timing disruptions, resource contention, priority conflicts, etc. A potential conflict may not necessarily cause an error in the current event sequence, but it could lead to problems due to differences in system behavior when migrated to different domestic environments. For example, if two threads write to the same file almost simultaneously, although the operating system's scheduling mechanism protects write consistency in the original system, the write order may be uncertain in the target environment due to different scheduling policies. To identify potential conflicts, it is necessary to analyze the time distance between events, resource sharing methods, and operation types. For example, if events A and B are both write operations accessing the same resource, and their time interval is less than the system's set safety threshold T, a potential conflict relationship can be identified between A and B, and a specially marked edge can be added to the graph. The threshold T can be set according to the system's scheduling cycle. For example, in a system with a scheduling cycle of 1 millisecond, T can be set to 0.5 milliseconds; when the time difference between two write operations is less than 0.5 milliseconds, it can be considered a potential conflict.

[0032] After constructing a graph containing the aforementioned various relationships, it is necessary to generate graph primitives from the graph. A graph primitive is a basic structural unit used to characterize the relationship between events. It can be a directed edge consisting of two events, a triangular structure consisting of three events, or a chain structure consisting of multiple events, as long as it corresponds to the dependency, coupling, or conflict relationships between events. These structures are usually obtained by traversing the graph nodes and edges. For example, if events E1, E2, and E3 form a link E1→E2→E3, this link can be used as a graph primitive for subsequent adaptation analysis. For a three-event loop structure formed by implicit coupling, such as E4 and E5 coupled, E5 and E6 coupled, and E6 and E4 coupled, the triangular structure can be used as a primitive, and its coupling strength characteristics can be recorded. If it is necessary to further calculate the coupling degree of this structure, the average value of the three coupled edges can be taken as the coupling strength of the loop. For example, if the coupling strengths of the three sides are 0.8, 0.6, and 0.7 respectively, then the coupling strength of the triangular structure can be (0.8+0.6+0.7) / 3=0.7.

[0033] Through the above process, the resulting multidimensional dependency graph and the graph primitives formed therefrom can fully describe the system's call relationships, performance coupling relationships, and potential conflict relationships, laying an accurate and verifiable structural foundation for the subsequent generation of adaptation mapping tensors, thus enabling sufficient dependency structure information to be obtained before localization migration.

[0034] Furthermore, the construction of a multidimensional dependency graph with explicit dependency dimension, implicit coupling dimension, and potential conflict dimension based on the dependent event sequence, and the formation of graph primitives from the multidimensional dependency graph to characterize the event association mode, includes: Each event in the dependent event sequence is split into a hierarchy field, a trigger interval field, and a resource association ratio field according to its event code. Event adjacency pairs are established according to the order of event occurrence. Each adjacency pair is regarded as an initial event association unit, so that each association unit carries the trigger order information required by the explicit dependency. For each initial event association unit, an implicit coupling strength value is generated based on the resource association ratio between the events. The implicit coupling strength value is obtained by mapping the resource association ratio to a fixed interval and linearly combining it with the trigger interval, so that the implicit coupling strength can simultaneously reflect the competitive relationship and temporal proximity of the two events on resources, thereby forming a weighted association unit with implicit coupling strength. A potential conflict tendency index is constructed for the weighted association unit based on the minimum time interval between events. The potential conflict tendency index is generated by multiplying the implicit coupling strength value by the inverse of the triggering interval as the base. This allows the conflict tendency index to reveal whether there is competitive triggering behavior between events and form a conflict identification unit for the potential conflict dimension. After obtaining conflict identification units with explicit dependency fields, implicit coupling strength fields, and potential conflict tendency indices, each unit is mapped to a directed graph edge between graph nodes, so that the graph edge contains three types of weight fields and uses event encoding as node identifier. A multidimensional dependency graph is constructed using all graph edges. The minimum closable path, the longest uninterrupted association chain, and the locally connected structure with the most significant resource competition are searched in the multidimensional dependency graph, and the searched structures are extracted as graph primitives to characterize the event association mode.

[0035] When constructing a multidimensional dependency graph with explicit dependency, implicit coupling, and potential conflict dimensions using a sequence of dependent events, the first step is to decompose the event code carried by each event. The event code typically consists of three parts: a hierarchy field, a trigger interval field, and a resource association ratio field. These fields have already been encapsulated in a fixed format in the preceding steps. For example, the code "L2-0.115-0.6" indicates that the event originates from the database layer, the trigger interval is 0.115 milliseconds, and the resource association ratio is 0.6. By decomposing the code, we can obtain the event's affiliation at different technical levels, its temporal relationship with the preceding event, and its coupling strength in resource usage. Pairing the decomposed events according to their occurrence time forms event adjacency pairs. Event adjacency pairs reflect the most basic explicit triggering relationship between two consecutive events; therefore, each adjacency pair naturally carries the information required for explicit dependency analysis, such as sequence, hierarchy differences, and trigger intervals. In this way, a sequence of dependent events can be initially converted into initial event association units with explicit dependency characteristics.

[0036] After obtaining the initial event association units, it is necessary to further analyze the resource dependencies between the events to generate implicit coupling strength values. Implicit coupling refers to the implicit mutual influence between two events that, although logically have no direct calling relationship, have competition, overlap, or synchronization requirements in resource access. To quantify this implicit relationship, the resource association ratio is first mapped to a fixed interval, for example, linearly mapped to the interval [0,1], so that the resource dependencies between different events can be compared on the same scale. Then, the mapped ratio is linearly combined with the trigger interval between events to form the implicit coupling strength. The linear combination can be in the form of α×ratio + β×(1 / trigger interval), where α and β are adjustable coefficients used to balance the impact of resource competition and temporal proximity on implicit coupling. For example, when the resource association ratio is 0.6 and the trigger interval is 0.1 milliseconds, we get 1 / trigger interval = 10. Assuming α = 0.5 and β = 0.2, the implicit coupling strength is 0.5 × 0.6 + 0.2 × 10 = 0.3 + 2 = 2.3. The greater the strength, the more likely there is an implicit coupling relationship between the two events. By appending this result to the event association unit, we can obtain a weighted association unit that includes both explicit dependency features and implicit coupling features.

[0037] After generating the weighted association units, a potential conflict tendency index needs to be constructed to reveal whether competitive triggering behavior may occur between events. Potential conflict refers to the risk of conflict caused by multiple events competing for the same resource or triggering within a very short period. To quantify this risk, the reciprocal of the trigger interval can be used as the base value, as the closer the triggers are, the higher the probability of conflict. Multiplying the reciprocal base value by the implicit coupling strength yields the potential conflict tendency index. For example, when the trigger interval is 0.1 milliseconds and the implicit coupling strength is 2.3, the conflict tendency index is (1 / 0.1) × 2.3 = 10 × 2.3 = 23. The larger the index value, the stronger the potential conflict trend between the two events. This index will serve as the core data of the potential conflict dimension and will be appended to the association units, thus forming a conflict identification unit that includes an explicit dependency field, an implicit coupling strength field, and the potential conflict tendency index.

[0038] After obtaining the conflict identifier units, they need to be mapped to directed graph edges in a graph structure. Each edge in the graph represents not only the temporal relationship between events but also carries three types of fields: explicit dependency weights, implicit coupling weights, and potential conflict weights. Event encoding serves as a unique identifier for graph nodes, distinguishing different nodes and enabling accurate description of the relationships between them. By mapping all conflict identifier units, a complete multidimensional dependency graph can be constructed, where each graph edge contains the aforementioned three-dimensional weight information. The structure of this graph not only reflects the sequential relationship between events but also reveals their resource competition and potential conflicts, thus forming a multidimensional representation integrating explicit dependencies, implicit couplings, and potential conflicts.

[0039] After constructing the multidimensional dependency graph, several structural features can be searched within the graph to extract graph primitives. Graph primitives are basic structural units that reflect the correlation patterns of specific events. The minimum closable path represents the basic cyclic relationships formed in the event dependency chain; the longest uninterrupted association chain reflects the largest range of continuous dependency patterns between events; and the most significant locally connected structure based on resource competition is used to capture dense interactions between events based on resource conflicts. By searching and extracting these structures, several graph primitives can be obtained, each reflecting a typical correlation pattern between dependent events. These primitives will serve as an important foundation for subsequent construction of the adaptation mapping tensor and analysis of migration resistance distribution.

[0040] To more clearly illustrate how to search for the minimum closable path, the longest uninterrupted association chain, and the locally connected structure with the most significant resource competition in a multidimensional dependency graph, a specific event sequence example can be used to explain this process. Assume that five event nodes E1, E2, E3, E4, and E5 have been obtained in the preceding steps. Each node carries an explicit dependency field, an implicit coupling strength field, and a potential conflict tendency index, and the edge relationships in the graph are established according to the order of event occurrence as shown below: E1 → E2E2 → E3E3 → E4E4 → E2E3 → E5 Each graph edge has three types of weight fields: explicit dependency weight (reflecting the stability of the triggering order), implicit coupling weight (reflecting the degree of resource contention), and potential conflict weight (reflecting the scheduling or concurrency risk). The weights are generated along with the node pairs in the actual calculation.

[0041] Finding the minimum closable path involves identifying the shortest path in the graph that forms a loop. In the example graph above, starting from E2, the path E2 → E3 → E4 → E2 constitutes a closed loop, and there is no shorter closed loop. Therefore, this path can be identified as the minimum closable path. This closed loop reflects the circular dependencies that may form during the execution of events, such as resource initialization, lock acquisition, or repeated triggering behavior. Since each edge in the path carries implicit coupling and potential conflict characteristics, the closed loop not only illustrates logical cycles but also reveals potential migration risks caused by resource contention or time constraints.

[0042] When finding the longest uninterrupted dependency chain, a path must be selected in the graph that is continuous in explicit dependencies and without breaks. In the example, E1 → E2 → E3 → E5 constitutes the longest uninterrupted dependency chain because all edges along its path maintain explicit dependency continuity, and there are no breaks due to excessively low conflict exponents or zero implicit coupling strength. Such dependency chains typically reflect the critical paths of the system, such as main business processes, database transaction chains, or middleware message pipelines, and logical consistency must be prioritized during migration.

[0043] For locally connected structures with the most significant resource competition, it is necessary to statistically analyze the implicit coupling weights and potential conflict weights of the local regions in the graph. Significant resource competition typically refers to situations where several events have highly overlapping accesses to the same resource, short trigger intervals, and a high tendency to conflict, leading to performance bottlenecks or compatibility failures during migration. In the example, the implicit coupling strengths of E2 → E3 and E3 → E4 are 2.8 and 3.1, respectively, and their potential conflict indices are 22 and 27, both significantly higher than other graph edges (e.g., the implicit coupling strength of E3 → E5 is only 0.4, and the conflict tendency index is 3). Comparison shows that E2, E3, and E4 form a locally connected structure with the most significant resource competition because the overlap in resource access within this structure is extremely high, resulting in the most intense competition, and the three event chains constitute a high-risk, densely populated region in the graph. This structure is extracted by calculating the average implicit coupling strength and average conflict tendency index of all graph edges within the local subgraph, and selecting concentrated regions exceeding a set threshold as locally significant resource competition structures. In this example, the subgraph with nodes E2, E3, and E4 has an average implicit coupling strength and an average conflict tendency index that both reach the high-risk range defined by the system. Therefore, this subgraph can be extracted as a graph primitive to characterize the way events are associated.

[0044] As the examples above demonstrate, the minimum closable path reflects logical loop relationships, the longest uninterrupted chain of associations reflects continuous dependencies, and the locally connected structure with the most significant resource competition reflects high-density resource conflict relationships. These three primitives together constitute the core pattern of event association and will be used in subsequent steps to generate adaptation mapping tensors, further supporting difference analysis and risk assessment during the localization migration process.

[0045] Step S103: Use graph primitives to generate an adaptation mapping tensor to describe the interface differences, instruction path offsets and timing tolerance ranges of various technical components under different domestic production target environments, and form a migration adaptation resistance distribution accordingly.

[0046] After constructing the multidimensional dependency graph and its primitives, an adaptation mapping tensor needs to be generated based on these primitives. This tensor is used to accurately describe the interface differences, instruction path offsets, and timing tolerance ranges of various technical components under different domestic production target environments within a unified data structure, and further, to form a migration adaptation resistance distribution. To facilitate implementation by those skilled in the art, the meaning and construction method of the adaptation mapping tensor need to be clearly defined first. The adaptation mapping tensor can be understood as a multidimensional array structure, where each dimension corresponds to a classification perspective. For example, one dimension distinguishes different primitives, another distinguishes different target domestic production environments, and yet another distinguishes different types of adaptation attributes, such as interface differences, instruction path offsets, and timing tolerance ranges. Through such a multidimensional array, a specific numerical unit can be used to represent "the degree of quantification of a primitive in a target environment and a certain adaptation attribute," thereby transforming the originally scattered structural information into a computable and comparable numerical description.

[0047] When generating adaptation mapping tensors using graph primitives, it's necessary to first identify the technical elements contained within the graph primitives. Graph primitives are typically local structures composed of several dependent events and their interrelationships, such as a chain structure representing a single database call, a triangular structure representing a middleware message passing loop, or a star structure representing thread lock contention. In this step, at least the following information needs to be extracted from each graph primitive: the identifiers of the participating technical components, the type of association between components, and the direction of the association. Technical components can be interfaces provided by the operating system, instruction classes supported by the processor architecture, specific implementations of the database engine, message middleware channels, etc. Those skilled in the art can consider each graph primitive as a "minimum migration analysis unit," and subsequent adaptation evaluations will revolve around these units.

[0048] Interface differences refer to inconsistencies in function names, parameter types, number of parameters, return value meanings, and exception handling behavior between the system interfaces relied upon when implementing the same business logic in different domestic target environments. For example, a commercial database might be used in the original environment, providing a query interface that accepts a specific SQL dialect. However, in a domestic database environment, interfaces with the same name or similar functions may not support that dialect or require additional parameter configuration to achieve the same functionality. To quantify interface differences, a simple hierarchical standard can be defined, such as a range from 0 to 1. A value of 0 indicates completely consistent interfaces, requiring no adaptation; a value of 1 indicates completely incompatible interfaces, requiring a complete rewrite of the relevant logic; and values ​​in between indicate partial differences, necessitating parameter conversion or call encapsulation. For example, if the original interface and the target interface only have a simple type conversion in the return value data type, such as changing from a 32-bit integer to a 64-bit integer, and it does not change the business logic, then the interface difference value can be set to 0.2; if the SQL extended syntax used by the original interface is not supported at all in the new environment and the query statement needs to be rewritten, then the interface difference value can be set to 0.8 or higher.

[0049] Instruction path offset describes the degree of difference in the path traversed by the same business operation at the instruction level under different chip instruction sets or different underlying execution environments. For example, the original environment uses a processor based on a certain internationally common instruction set, while the domestic environment uses a domestic instruction set architecture. Although both can perform the same encryption and decryption operations from a business perspective, the specific instruction sequences may differ in length, hardware acceleration units they rely on, and so on. When quantifying instruction path offset, one can first count the number of instructions required to complete the same function in the original and target environments, or measure the execution time cost of the corresponding instruction sequences, and then normalize the difference to a range of 0 to 1. For example, if an encryption operation requires an average of 100 instructions in the original environment and 120 instructions in the target environment, the offset ratio can be defined as (120-100) / 100=0.2. This offset ratio can then be directly used as the instruction path offset value, or mapped to discrete levels such as 0.0, 0.3, and 0.6 according to pre-defined grading rules.

[0050] Timing tolerance range describes the sensitivity of a graph primitive to time variations during execution. Specifically, it represents the range of execution latency fluctuations that the component combination corresponding to this primitive can tolerate under different target environments. If, in the original environment, the time interval between two events remains within a very small range, and exceeding this range would trigger timeouts, deadlocks, or transaction rollbacks, then the timing tolerance range of this primitive can be considered narrow. Conversely, if the system can tolerate larger time fluctuations without affecting business correctness, then its timing tolerance range is considered wide. In actual calculations, the distribution of time intervals between key events in a graph primitive can be statistically analyzed based on historical operational data, such as calculating the average interval and the maximum allowable interval. Then, the degree of tolerance stress can be represented by the ratio of the actual possible time fluctuation to the maximum allowable interval. If the maximum allowable interval is 200 milliseconds, and the predicted time fluctuation in the target environment may reach 150 milliseconds due to different scheduling strategies, then the ratio of fluctuation to the upper limit is 150 / 200 = 0.75, which can be considered a timing stress indicator approaching a critical state.

[0051] After quantizing the above three dimensions, these quantization results need to be filled into the corresponding positions of the adaptation mapping tensor. For example, the first dimension of the tensor can be defined as representing the graph primitive number, the second dimension as representing the target domestic environment number, and the third dimension as representing the adaptation attribute type. The attribute type can be represented by index 0 to indicate interface difference, index 1 to indicate instruction path offset, and index 2 to indicate timing tolerance stress. In this way, when a person skilled in the art accesses a specific position, such as accessing the tensor unit of the i-th graph primitive in the j-th target environment for the attribute type of interface difference, a value between 0 and 1 can be obtained, clearly indicating the degree of difference at that location. For a specific example, if the value at position (2,1,0) in the tensor is 0.8, it can be interpreted as the second graph primitive having a large degree of interface difference in the first domestic target environment, requiring heavy adaptation work; if the value at position (2,1,2) is 0.1, it indicates that the timing tolerance of the primitive in this target environment is relatively relaxed, and time fluctuations have little impact on it.

[0052] After obtaining the specific values ​​at each position in the tensor, a migration adaptation resistance distribution needs to be formed based on this. The migration adaptation resistance distribution can be understood as a quantitative description of the "overall migration difficulty" of each graph primitive in various target environments. For ease of implementation, a migration resistance value can be defined for each graph primitive. This resistance value can be a combination of three attribute values—interface difference, instruction path offset, and timing tolerance stress—with certain weights. The weights can be flexibly determined by the project implementer based on their actual priorities. For example, in safety-critical systems where timing issues are more important, a higher weight can be given to timing stress; in systems with extremely high performance requirements, the weight of instruction path offset can be increased. To illustrate with a simple calculation example, when the interface difference is 0.6, the instruction path offset is 0.2, and the timing tolerance stress is 0.5, with weights of 0.5, 0.2, and 0.3 respectively, the migration resistance value can be calculated by weighted summation: 0.6 × 0.5 + 0.2 × 0.2 + 0.5 × 0.3, resulting in 0.3 + 0.04 + 0.15, totaling 0.49. This clearly shows the migration resistance magnitude of the map primitive in the corresponding target environment, and these resistance values ​​can be sorted or statistically analyzed among all primitives to form the overall migration adaptation resistance distribution.

[0053] Through the above steps, the adaptation mapping tensor not only fully records the differences in the characteristics of each graph primitive in different domestic production target environments, but also transforms these differences into intuitive migration difficulty indicators through the migration adaptation resistance distribution, so that subsequent adaptation trend analysis and bottleneck identification of dependency chains have a clear numerical basis.

[0054] Furthermore, the method of generating an adaptation mapping tensor using graph primitives to describe the interface differences, instruction path offsets, and timing tolerance ranges of various technical components under different domestic production target environments, and thereby forming a migration adaptation resistance distribution, includes: The event nodes in each graph primitive are grouped according to the hierarchy field, implicit coupling strength field and potential conflict tendency index field carried by the node to generate component association feature vectors. The component-associated feature vectors are compared item by item with the interface specifications, instruction execution paths and timing requirements of the corresponding domestic target environment. The interface difference, instruction path offset and timing tolerance offset values ​​are quantified and combined into component difference triples. Based on the association order of events in the graph primitives, all component difference triples are arranged in a multidimensional structure according to component index, difference type and weight type to form an adaptation mapping tensor; The migration cost is calculated based on the interface difference, instruction path offset, and timing tolerance offset of each element in the adaptation mapping tensor. The migration cost is then combined with the potential conflict tendency index of the corresponding graph primitive to generate migration adaptation resistance units. All migration adaptation resistance units are then aggregated to form a migration adaptation resistance distribution.

[0055] Before generating the adaptation mapping tensor using graph primitives, the event nodes constituting the graph primitives need to be organized. Each event node comes from the multidimensional dependency graph constructed in the previous steps and carries a hierarchy field, an implicit coupling strength field, and a potential conflict tendency index field. The hierarchy field indicates which technical layer of the business system the event occurs at, such as the operating system layer, database layer, or middleware layer. The implicit coupling strength field reflects the degree of potential coupling between events due to resource contention or access overlap. The potential conflict tendency index field describes the potential conflict risk caused by two events triggering too close together or resource access conflicts. When grouping this type of event, event nodes belonging to the same technical component can be grouped together, so that each group reflects the behavioral characteristics of a component during operation. For each group of nodes, the implicit coupling strength of the nodes within the group can be averaged, and the potential conflict tendency index can be averaged or weighted averaged to generate a component association feature vector that can characterize the resource contention characteristics and conflict risks of the component in the original environment.

[0056] After obtaining the component-associated feature vector, it is necessary to compare this vector with the interface specifications, instruction execution paths, and timing requirements in the corresponding domestic target environment item by item. To achieve quantifiable comparison, clear calculation methods need to be established for "interface difference," "instruction path offset," and "timing tolerance offset." Interface difference can be calculated by statistically analyzing the difference in the number of interface parameters, the number of parameter type mismatches, and the number of call format changes for the same component in the original environment and the domestic target environment. For example, the difference in the number of parameters, the number of type mismatches, and the number of format differences can be added proportionally. Assuming a component's original interface has three parameters, the target environment interface has five parameters, and one parameter type is incompatible, the interface difference can be calculated as 2 + 1 = 3. Instruction path offset measures whether the number of instructions executed by the component, the branch structure, or the execution path has changed in the target environment, and can be calculated by the difference in execution path length. For example, if the original execution path length is 20 instruction nodes and the target environment is 26 nodes, the instruction path offset is 6. The timing tolerance offset measures the maximum allowable execution time deviation of a component in the target environment. For example, if the original system reserves a 30-millisecond buffer for a component, while the domestic environment only allows 20 milliseconds, then the timing tolerance offset is 30 - 20 = 10 milliseconds. Combining the interface difference, instruction path offset, and timing tolerance offset forms a component difference triple. Each item can directly participate in subsequent calculations.

[0057] After obtaining the component difference triples, all triples belonging to the same graph primitive need to be arranged according to the association order between event nodes in the graph primitive. After the arrangement is completed, these triples are used as dimensions to construct a multi-dimensional arrangement structure, using component index, difference type (interface difference, path offset, temporal offset), and weight type (explicit dependency weight, implicit coupling weight, potential conflict weight). This structure can be understood as a tensor, where each tensor cell represents the quantified result of a component being affected by a certain weight type on a certain difference item. For example, when the component index is 2, the difference type is "path offset", and the weight type is "implicit coupling", the value recorded in this tensor cell is the degree of migration impact of the component on the path offset item due to implicit coupling. Thus, the adaptation mapping tensor can structurally combine component-level differences with dependencies, resource coupling relationships, and conflict relationships in the graph primitive.

[0058] After the adaptation mapping tensor is constructed, the migration cost value needs to be calculated for each element in the tensor to represent the migration cost of that component in a specific difference. The migration cost value can be obtained by weighting and summing the interface difference degree, instruction path offset degree, and timing tolerance offset value according to preset coefficients. For example, assuming the weight coefficients are 0.4, 0.4, and 0.2 respectively, the interface difference degree is 3, the path offset degree is 6, and the timing offset is 10, then the migration cost value can be calculated as 3×0.4 + 6×0.4 + 10×0.2 = 1.2 + 2.4 + 2 = 5.6. In order for the migration cost value to reflect the impact of the event conflict risk within the graph primitive, the migration cost value needs to be multiplied by the maximum potential conflict tendency index corresponding to that graph primitive. For example, if the maximum potential conflict tendency index of a graph primitive is 23, then the migration adaptation resistance value is 5.6 × 23 = 128.8. Add this resistance value as a migration adaptation resistance unit to the resistance distribution, and repeat the above process to obtain the migration adaptation resistance distribution composed of all components and event association patterns.

[0059] The resulting migration adaptation resistance distribution reflects the ease or difficulty, technical bottlenecks, and potential risks associated with the localization migration of different components. Those skilled in the art can use this resistance distribution to determine migration priorities, adjust migration strategies, or mitigate risks.

[0060] Step S104: Based on the migration adaptation resistance distribution, infer the adaptation trend and potential bottlenecks of each dependency chain of the business system to be migrated, and form a set of key dependency chains to be calibrated.

[0061] After obtaining the migration adaptation resistance distribution, it is necessary to infer the adaptation trends and potential bottlenecks of each dependency chain in the business system based on this distribution, thereby forming a set of key dependency chains to be calibrated. The core of this step lies in how to elevate the migration resistance value obtained for a single graph primitive in the previous step to an overall adaptability judgment for a larger range of dependency chains. Therefore, it is first necessary to clarify the definition of a dependency chain. A dependency chain can be understood as a chain-like structure formed by multiple graph primitives with dependencies connected in the order of execution. Its internal nodes represent different graph primitives, and edges represent the dependency order, resource sharing relationship, or logical continuity between primitives. Each dependency chain represents a complete business execution process in the system, such as a transaction processing chain, a file read operation chain, or a network request processing chain.

[0062] To infer the adaptation trend of dependency chains, it is necessary to comprehensively analyze the migration resistance values ​​of each graph primitive in the chain. Those skilled in the art can view a dependency chain as a structure composed of multiple resistance values ​​linked together, where the migration resistance value of each primitive reflects the degree of adaptation difficulty that primitive may encounter in the target domestic environment. In practical calculations, the overall adaptation trend of the dependency chain can be defined as a certain aggregated value of the migration resistance values ​​of all primitives in the chain. The aggregation method can be summation, averaging, taking the maximum value, or weighted combination based on the importance of the links. The choice of method depends on the sensitivity of the system under different operating scenarios. For example, in systems with high reliability requirements, the primitive with the highest resistance in the chain often determines the adaptation difficulty of the entire chain; in this case, taking the maximum value can be chosen. In performance-driven systems, all primitives affect the overall performance, so averaging or weighted averaging can be used to make the resistance analysis more reflective of the overall performance.

[0063] Let's take an example to illustrate the implementation process of the aggregation calculation method. Suppose a dependency chain consists of three graph primitives with migration resistance values ​​of 0.4, 0.6, and 0.8, respectively. If we use an averaging method, the overall adaptation trend value is (0.4 + 0.6 + 0.8) / 3 = 0.6; if we use the maximum value method, the adaptation trend value is 0.8; if we use a weighted method, for example, with weights of 0.2, 0.3, and 0.5 for the first, second, and third primitives respectively, the weighted result can be calculated as 0.4 × 0.2 + 0.6 × 0.3 + 0.8 × 0.5, resulting in 0.08 + 0.18 + 0.40 = 0.66. In different system migration scenarios, those skilled in the art can choose the most suitable aggregation method according to actual requirements, as long as the method is explicit and repeatable.

[0064] In addition to the migration resistance value itself, it is also necessary to analyze potential bottlenecks in the dependency chain. A bottleneck refers to a node that is most likely to cause migration failure, performance degradation, or unpredictable behavior during the chain's execution. The criteria for identifying a bottleneck include both primitives with high migration resistance and those occupying critical structural positions within the chain. For example, if a primitive has relatively low migration resistance in the chain, but it is located at a critical branch point in the business process, any adaptation error could lead to the failure of the entire chain; therefore, it can still be identified as a potential bottleneck. Those skilled in the art can identify these critical structures by analyzing the connections between graph primitives. For example, if a primitive is a common preceding node for multiple subsequent primitives, the stability of that primitive has a significant impact on the entire chain and should be given a higher bottleneck identification weight.

[0065] To quantify the strength of a bottleneck, a bottleneck index can be calculated for each graph primitive. The bottleneck index consists of two parts: one from the migration resistance value, and the other from the importance of the link topology. For example, the bottleneck index can be set as migration resistance value × node importance coefficient. The node importance coefficient can be determined based on factors such as the number of branches a primitive participates in in the chain and the criticality of the path; for example, primitives participating in multiple branch paths can be assigned a higher coefficient. If a primitive has a migration resistance value of 0.7 and a node importance coefficient of 1.5, then the bottleneck index can be set as 0.7 × 1.5 = 1.05. By calculating the bottleneck indices of all primitives in the entire dependency chain, the node with the highest bottleneck index can be identified as the focus of attention.

[0066] After inferring the adaptation trend and potential bottlenecks of each dependency chain, the analysis results of all chains need to be combined to form a set of critical dependency chains to be calibrated. The criteria for forming this set can be based on the adaptation trend value or bottleneck index exceeding a certain set threshold. For example, an adaptation trend threshold T1 can be set; when the adaptation trend value of a chain is greater than T1, it indicates that the chain has a high adaptation difficulty and needs to be added to the critical chain set. Similarly, a bottleneck index threshold T2 can be set; when the bottleneck index of a certain element in a chain exceeds T2, even if the resistance of other parts of the chain is low, it should still be added to the critical chain set. For example, if T1 = 0.7, and the adaptation trend value of a certain chain is 0.8, then that chain should be included in the critical dependency chain set; similarly, if T2 = 1.0, and the bottleneck index of a certain node in a certain chain is 1.05, then that chain should also be added to the set.

[0067] In practical applications, the size of the critical dependency chain set directly affects the scope of subsequent migration rule generation. Therefore, the chains in the set can be further sorted according to their adaptation difficulty, prioritizing the chains with the highest adaptation difficulty. For example, if five chains have adaptation trend values ​​of 0.9, 0.8, 0.75, 0.6, and 0.5 respectively, the first three chains can be prioritized for inclusion in the critical set, while the last two chains can be designated as non-critical chains. When further simplification of analysis is needed, even chains ranking in the top percentages of resistance can be selected as critical chains to prioritize the most risky links when migration resources are limited.

[0068] Through the above analysis process, this step can accurately identify the dependency chains that have the greatest impact on the migration success rate, and make a clear judgment on the adaptation trend and potential bottlenecks of each chain through quantitative methods.

[0069] Furthermore, based on the migration adaptation resistance distribution, the adaptation trends and potential bottlenecks of each dependency chain of the business system to be migrated are inferred to form a set of key dependency chains to be calibrated, including: Each migration adaptation resistance unit in the migration adaptation resistance distribution is clustered according to its associated graph primitives. The average, maximum and growth gradient of the migration adaptation resistance values ​​within each cluster are calculated, and the dependency chain resistance feature vector is generated accordingly. Based on the maximum resistance value and growth gradient in the resistance feature vector of each dependency chain, the migration adaptation resistance distribution is mapped to the dependency chain index space. By analyzing the continuous rising segment of the resistance value in the mapping space, the adaptation trend rising interval is identified, and the dependency chain segment in the interval is generated as the dependency chain adaptation trend segment. The bottleneck contribution ratio is calculated for all migration adaptation resistance units contained in the dependency chain adaptation trend segment. The bottleneck contribution ratio is the migration adaptation resistance value of the specified unit divided by the maximum migration adaptation resistance value in the segment. Bottleneck events are located by the migration adaptation resistance units whose bottleneck contribution ratio exceeds a preset threshold, forming a bottleneck event sequence. The bottleneck event sequence is merged into several consecutive dependency chain segments according to the order of event occurrence, and cross-compared with the dependency chain adaptation trend segments. The dependency chain segments that simultaneously satisfy the conditions of a significant increase in adaptation trend and an outstanding bottleneck contribution ratio are marked as key dependency chain segments, and finally a set of key dependency chains to be calibrated is formed.

[0070] In the process of inferring the adaptation trends and potential bottlenecks of each dependency chain of the business system to be migrated based on the migration adaptation resistance distribution, it is necessary to first clarify what a migration adaptation resistance unit is. A migration adaptation resistance unit is a set of quantitative data obtained by combining interface difference degree, instruction path offset degree, timing tolerance offset value and potential conflict tendency index in the previous steps. Each unit corresponds to a graph primitive in the multidimensional dependency graph. Therefore, it not only reflects the adaptation difficulty of a certain event association structure in the target localization environment, but also includes potential conflict information caused by resource competition, timing sensitivity and implicit coupling.

[0071] To identify the adaptation trends of different dependency chains from the distribution of migration adaptation resistance, each migration adaptation resistance unit needs to be clustered according to its associated graph primitives. The graph primitives referred to here are the basic structural units extracted in the previous step by finding the minimum closable path, the longest uninterrupted dependency chain, and locally connected structures with significant resource competition in the multidimensional dependency graph. The purpose of clustering migration adaptation resistance units according to graph primitives is to enable a unified analysis of the migration performance of dependency structures belonging to the same type of event, thereby revealing the overall difficulty characteristics of the same type of structure during migration. Within each cluster, the average, maximum, and growth gradient of the migration adaptation resistance value need to be calculated. The average value reflects the average adaptation difficulty of this type of structure, the maximum value reflects possible extreme adaptation conditions, and the growth gradient describes the upward or downward trend of migration adaptation resistance during dependency chain evolution. The growth gradient can be calculated using the simplest difference method, such as taking the difference between the resistance values ​​of two adjacent migration adaptation resistance units, or by using the slope of a fitted straight line; the specific method depends on the implementation scenario. For those skilled in the art without experience, the following example can be used: If the resistance values ​​within a cluster, ordered by dependency chain, are 3, 4, and 6 respectively, then the growth gradient can be calculated as (6 - 3) / 3 = 1, meaning the resistance shows a significant upward trend throughout the dependency process. The average value is (3 + 4 + 6) / 3 = 4.33, and the maximum value is 6. These three values ​​combined form the dependency chain resistance eigenvector, used to reflect the overall behavior of the dependency chain segments corresponding to this type of structure.

[0072] After obtaining the dependency chain resistance feature vector, the migration adaptation resistance distribution needs to be mapped to the dependency chain index space. The dependency chain index space is designed to allow those skilled in the art to directly observe the resistance change trend based on the index position of the dependency chain segments; essentially, it is a spatial structure that arranges resistance values ​​according to the event sequence position. The mapping method can be defined as a discrete function point sequence with the event order in the dependency chain as the horizontal axis and the migration adaptation resistance value as the vertical axis. By observing the changes in the mapped resistance values, intervals where resistance values ​​continuously increase can be identified, and these intervals are marked as the adaptation trend rising interval. For a simple example, if the mapped resistance values ​​are in the dependency chain index order of 2, 3, 5, 7, 4, then there is a continuous increase from index 0 to index 3, and a decrease from index 3 to index 4. Therefore, index 0 to 3 constitutes the adaptation trend rising interval. Extracting the dependency chain segments within this interval constitutes the dependency chain adaptation trend segment, which is used for subsequent bottleneck identification.

[0073] Based on identifying adaptation trend segments, it is necessary to further determine whether there are bottleneck events causing significant migration obstacles. To quantify the bottleneck level, a bottleneck contribution ratio needs to be calculated for each migration adaptation resistance unit within the dependency chain adaptation trend segment. The bottleneck contribution ratio is defined as the migration adaptation resistance value of a specified unit divided by the maximum migration adaptation resistance value in that segment. This ratio reflects the relative obstacle level of the event within the entire segment. For example, if the resistance values ​​in a segment are 3, 4, and 8, the bottleneck contribution ratios are 3 / 8 = 0.375, 4 / 8 = 0.5, and 8 / 8 = 1, respectively. If the preset threshold is 0.7, then only events with a resistance value of 8 constitute bottleneck events. Following the same logic, all migration adaptation resistance units with a bottleneck contribution ratio exceeding the preset threshold are identified as bottleneck events, forming a bottleneck event sequence. The bottleneck event sequence is arranged according to the order of events in the dependency chain to maintain the integrity of the dependency relationship.

[0074] After obtaining the bottleneck event sequence, the sequence needs to be merged according to the order of event occurrence to form one or more consecutive dependency chain segments. These consecutive dependency chain segments need to be cross-compared with previously identified dependency chain adaptation trend segments. The purpose of cross-comparison is to confirm whether a dependency chain segment has a rapid increase in resistance in the trend, while also containing events with a prominent bottleneck contribution ratio. If both conditions are met, it means that the dependency chain segment is both likely to evolve into a high-resistance segment in the migration and contains bottleneck factors that seriously affect the migration adaptation, and is therefore marked as a critical dependency chain segment.

[0075] In this way, all critical dependency chain segments are merged into a single critical dependency chain set. This set will serve as the basis for subsequent steps in building structured localization migration rules, as it indicates the technology-related paths in the business system that most require adjustment, restructuring, or replacement.

[0076] Step S105: Generate structured localization migration rules based on the set of key dependency chains, convert the structured localization migration rules into an executable migration instruction sequence, and complete the system migration according to the migration instruction sequence.

[0077] After forming the set of critical dependency chains to be calibrated, structured domestic migration rules that can directly guide the actual migration operation need to be generated around these critical dependency chains. These migration rules are then further refined and expanded into executable migration instruction sequences, and finally, the migration execution process completes the system migration item by item according to the instructions. The structured domestic migration rules and migration instruction sequences are clearly defined below, and the conversion method from the former to the latter and the execution details in a specific system are explained.

[0078] The so-called structured localization migration rules refer to a set of rules that describe the adjustment measures to be executed in the target localization environment in a fixed field and hierarchical format, targeting the component combinations, dependencies, and adaptation issues involved in a critical dependency chain. These rules include at least three aspects: First, the scope of application, which identifies the dependency chain associated with the rule, the relevant graph primitive numbers, and the corresponding business scenario tags, ensuring that the code segment, configuration item, or execution path requiring the rule can be accurately located during migration. Second, the migration conditions, which describe under what circumstances the rule needs to be triggered, such as the current target environment type, the detected interface difference level, the instruction path offset threshold, and the timing pressure level. Those skilled in the art can set these conditions as Boolean expressions or combined conditions, as long as they can be explicitly determined in the implementation. Third, the migration actions, which describe the specific adjustments that should be made to the system when the migration conditions are met, including interface replacement methods, configuration parameter modification methods, call sequence rearrangement methods, and concurrency limiting methods.

[0079] In practical implementation, each structured migration rule can be represented as a set of records with fixed fields. For example, the "RuleID" field can identify the rule number, the "ChainID" field can identify the associated key dependency chain, the "MatchPattern" field can describe the interface name or call signature to be matched, the "SourceEnv" and "TargetEnv" fields can indicate the source and target environments, the "ActionType" field can indicate whether interface replacement, parameter conversion, or call reordering is performed, and the "ActionDetail" field can be used to provide specific replacement content, such as replacing the original function A with function B in the domestic environment, adjusting the parameter order from (p1, p2, p3) to (p2, p3, p1), or adding specific initialization and cleanup operations before and after the call. Those skilled in the art can map these fields to configuration file entries, database table records, or structures in scripting languages ​​according to the programming language and configuration framework used in their projects, as long as the format is clear and can be parsed by the program.

[0080] After defining the structured migration rules, these rules need to be transformed into an executable sequence of migration instructions. An executable sequence of migration instructions can be understood as a series of atomic operations arranged in execution order. Each atomic operation can be directly called by the migration tool or script during execution, without requiring complex reasoning. To avoid uncertainty during the migration process, the instruction sequence generally needs a definite execution order, a clearly defined target object, and verifiable execution results. Therefore, each instruction can be abstracted as a combination of "operation type + target object + operation parameters". For example, one instruction can be represented as "modify key K in configuration file X, changing its value from V1 to V2", and another instruction can be represented as "search for call statement Z in source file Y and replace it with call statement Z'".

[0081] The conversion process from structured migration rules to a sequence of migration instructions typically involves three aspects: matching, expansion, and sorting. Matching refers to searching for objects in the source code, configuration files, scripts, or database configurations of the system to be migrated based on the "MatchPattern" or equivalent fields in the rule. For example, if a rule requires "matching all calls to function A," the system needs to search the source code for all instances of A and record their locations. Expansion involves concretizing the abstract "migration action" described in the rule into one or more directly executable instructions for each matched object. For example, an interface replacement rule might be expanded into three instructions: the first instruction backs up the original calling file, the second performs a text replacement operation, and the third updates the relevant build scripts or dependency declarations. Sorting involves adjusting the execution order of instructions based on dependencies to ensure that migration operations do not produce errors due to improper execution timing. For example, the instruction to update the target environment connection parameters in the configuration file must be executed first, followed by the instruction to restart the service processes that depend on that connection, and not the other way around.

[0082] When designing migration instructions, reversibility and security must also be considered. Reversibility means that if an instruction fails or produces unexpected results during migration, the system should be able to roll back to the pre-migration state through reverse operations. For example, before executing the instruction "modify configuration parameters from V1 to V2," a rollback instruction "change configuration parameters back from V2 to V1 if failure occurs" can be automatically generated and recorded in the migration log. Security means that the execution of instructions should not damage other services not within the migration scope. Therefore, the target object of the instruction should be located using exact matching, such as unique identifiers like file paths, function signatures, and service names, rather than fuzzy matching.

[0083] After generating a complete sequence of migration instructions, the actual system migration needs to be executed according to this sequence. Migration execution can be achieved through automated migration tools, script frameworks, or batch processing mechanisms provided by an integrated development environment (IDE). The instruction sequence can be imported into a migration execution engine, which executes each instruction sequentially, recording the execution status of each instruction, including execution time, result, and possible error messages. For example, when executing the instruction to "replace database driver configuration," the execution engine opens the specified configuration file, locates the corresponding configuration item, replaces the original driver class name with a domestic database driver class name, saves the modification, and then records the status as "successfully replaced" or "replacement failed" in the log. If an instruction fails, the execution engine can decide whether to stop the entire migration process or attempt to execute the corresponding rollback instruction based on a pre-defined strategy.

[0084] For migration actions involving timing adjustments or concurrency limits, the migration instruction sequence can include modifications to runtime parameters and service restarts. For example, if critical dependency chain analysis indicates that the response time of a certain service will increase in a domestic environment, and to avoid timeouts, the call timeout for this service needs to be adjusted from 200 milliseconds to 400 milliseconds in the gateway service, this modification can be written as the instruction "Modify the timeout parameter of service S in the gateway configuration file G, from 200 to 400", and scheduled to be executed before the service restart. The following instruction could be "Restart service S to make the new timeout setting take effect". In this way, migration execution not only involves code-level replacement but also includes adjustments to runtime parameters and operational strategies.

[0085] After the entire migration is completed, the system behavior before and after the migration can be compared based on the execution logs of the migration instructions. This comparison includes metrics such as interface call success rate, transaction success rate, and average response time, thereby verifying whether the structured migration rules and instruction sequence have achieved the expected adaptation effect. Through the above process, step S105 achieves the complete path from the set of critical dependency chains to the actual system migration, ensuring the targeted and controllable nature of the migration actions.

[0086] Furthermore, the step of generating structured domestic migration rules based on the set of key dependency chains, converting the structured domestic migration rules into an executable migration instruction sequence, and completing the system migration according to the migration instruction sequence includes: After obtaining the set of key dependency chains, migration constraint information is extracted based on the event hierarchy field, trigger interval field, and resource association ratio field in each key dependency chain segment to form migration constraint items that describe the technical limitations of the dependency chain segment. Based on the migration constraints, each item is compared with the interface specifications, instruction execution path requirements, and resource scheduling strategy of the domestic target environment to generate interface replacement constraints, instruction path correction constraints, and resource scheduling adjustment constraints. The three types of constraints are then merged to form a migration structure unit. The migration structure units are topologically sorted according to the causal order of their corresponding key dependency chain segments in the event sequence, and a structured localization migration rule containing execution order, adaptation conditions and exception rollback rules is generated based on the sorting structure. The structured localization migration rules are parsed into several atomic migration actions, and an executable migration instruction sequence is constructed based on the component loading method and transaction consistency requirements of the localization target environment. The migration instruction sequence is executed sequentially in the system migration window to complete the business system migration.

[0087] In the process of generating structured domestic migration rules based on the set of key dependency chains and transforming them into an executable sequence of migration instructions, it is necessary to first fully parse the event records contained in each key dependency chain segment. This ensures that the hierarchical field, trigger interval field, and resource association ratio field can be transformed into migration constraint information that can be used to describe the technical limitations during the migration process. The hierarchical field refers to the field in the event encoding used to identify the technical layer to which the event belongs. For example, it can identify whether the event belongs to the operating system call layer, database access layer, middleware communication layer, or processor instruction execution layer. Those skilled in the art will understand that the interface behavior of different layers may be constrained by different domestic components during migration; therefore, the hierarchical field can be used to determine the scope of components to be considered during the migration process. The trigger interval field represents the time interval between adjacent events, used to reveal the temporal dependency between events. The resource association ratio field represents the degree of overlap in the use of the same resource by two events. It is calculated by dividing the overlap by the duration of the shorter resource usage. The closer the value is to 1, the closer the dependency between the two events on the resource, and the more likely the migration will be affected by changes in resource scheduling methods. In this invention, by combining and analyzing the above three fields, the constraints that must be followed in the dependency chain segment, such as interface behavior, instruction triggering order, and resource scheduling order, can be extracted. For example, if the resource association ratio between a database write event and a cache refresh event reaches 0.9, it indicates that the two events share resources in most execution cycles. This type of high dependency will be extracted as a migration constraint to remind that the execution timing of the two events cannot be arbitrarily changed during migration.

[0088] After obtaining the migration constraints, these constraints need to be compared item by item with the interface specifications, instruction execution path requirements, and resource scheduling strategies of the target domestic environment. Interface specifications typically include the function names, parameter structures, and return types of the database interface in the target domestic environment. In this invention, if a migration constraint indicates that a certain interface must provide specific parameters or execution order, comparison can identify whether interface replacement is needed in the domestic environment. Instruction execution path requirements describe the specific execution order or dependencies of instructions in the target architecture. For example, some domestic processors may require two types of instructions to be executed in isolation or to pre-insert waiting instructions. This invention can identify whether instruction paths need to be modified by comparing the trigger intervals reflected in the migration constraints. Resource scheduling strategies typically describe the scheduling algorithms used by the operating system or middleware to handle resource contention, such as time-slice round-robin, priority scheduling, or lock contention mechanisms. This invention can analyze whether the resource management methods of the target environment will cause inconsistent behavior by comparing the resource association ratios in the migration constraints. The interface replacement constraints, instruction path correction constraints, and resource scheduling adjustment constraints generated by comparison will be merged into migration structure units, so that each migration structure unit can fully describe the migration requirements of a critical dependency chain segment in the localization environment.

[0089] After obtaining the migration structure units, they need to be topologically sorted according to the causal relationships of key dependency segments in the event sequence. Causality refers to the required execution order between events; if event A must be completed before event B, then A must be placed before B in the topological sort. This invention uses trigger order information and resource association ratio information in key dependency segments to determine whether there is a mandatory order for events. For example, if the resource association ratio is high, it indicates that the order in which two events use the same resource may be very sensitive during migration, requiring causal relationships to maintain the original execution order. After the topological sort is completed, structured domestic migration rules containing execution order, adaptation conditions, and exception rollback rules can be generated based on the sorted structure. The execution order ensures that migration actions can be completed step-by-step according to dependencies; adaptation conditions specify the interface or resource states under which the next migration action can be executed; and exception rollback rules specify the state to which the system should be restored to maintain consistency in the event of migration failure. For example, if an interface replacement action fails, it may be necessary to roll back the database connection to the pre-migration state to avoid data corruption.

[0090] After formulating structured localization migration rules, these rules need to be further parsed into atomic migration actions. An atomic migration action is the smallest indivisible unit of migration action with clearly defined inputs and outputs, such as replacing a single interface, adjusting a resource scheduling strategy, or rewriting an instruction path. By breaking down rules into atomic actions, the entire migration process can maintain high controllability in the execution chain and facilitate rollback in case of anomalies. Based on the component loading method and transaction consistency requirements of the target localization environment, these atomic migration actions need to be combined to generate an executable migration instruction sequence. For example, in some localized databases, index structures can only be changed after a transaction begins; therefore, the migration instruction sequence will place relevant actions within the transaction boundary. Finally, by executing the instruction sequence sequentially within the migration window, the localization migration process of the entire business system can be completed.

[0091] In the above embodiments, a method for migrating and adapting domestically produced systems based on multidimensional dependency graphs is provided. Correspondingly, this application also provides a device for migrating and adapting domestically produced systems based on multidimensional dependency graphs. Please refer to... Figure 2 This is a schematic diagram of an embodiment of a domestically developed system migration and adaptation device based on a multidimensional dependency graph, as described in this application. Since this embodiment, namely the second embodiment, is basically similar to the method embodiment, it is described simply; relevant details can be found in the description of the method embodiment. The system embodiment described below is merely illustrative.

[0092] The second embodiment of this application provides a domestically developed system migration and adaptation device based on a multidimensional dependency graph, comprising: The collection unit 201 is used to collect cross-level technical dependency clues of the business system to be migrated, and generate a dependency event sequence based on the triggering order and resource association relationship; Construction unit 202 is used to construct a multidimensional dependency graph with explicit dependency dimension, implicit coupling dimension and potential conflict dimension based on the sequence of dependent events, and form graph primitives from the multidimensional dependency graph to characterize the way events are associated. The generation unit 203 is used to generate an adaptation mapping tensor using graph primitives to describe the interface differences, instruction path offsets and timing tolerance ranges of various technical components under different domestic production target environments, and to form a migration adaptation resistance distribution accordingly. Forming unit 204 is used to infer the adaptation trend and potential bottlenecks of each dependency chain of the business system to be migrated based on the migration adaptation resistance distribution, and form a set of key dependency chains to be calibrated. Migration unit 205 is used to generate structured localization migration rules based on the set of key dependency chains, convert the structured localization migration rules into an executable migration instruction sequence, and complete the system migration according to the migration instruction sequence.

[0093] Although this application discloses preferred embodiments as described above, it is not intended to limit this application. Any person skilled in the art can make possible changes and modifications without departing from the spirit and scope of this application. Therefore, the scope of protection of this application should be determined by the scope defined in the claims of this application.

Claims

1. A method for migration and adaptation of domestically developed systems based on multidimensional dependency graphs, characterized in that, include: Collect cross-level technical dependency clues from the business systems to be migrated, and generate a dependency event sequence based on the triggering order and resource association; A multidimensional dependency graph with explicit dependency dimension, implicit coupling dimension and potential conflict dimension is constructed based on the dependent event sequence, and graph primitives are formed from the multidimensional dependency graph to characterize the event association mode. The adaptation mapping tensor is generated using graph primitives to describe the interface differences, instruction path offsets, and timing tolerance ranges of various technical components under different domestic production target environments, and a migration adaptation resistance distribution is formed accordingly. Based on the distribution of migration adaptation resistance, the adaptation trend and potential bottlenecks of each dependency chain of the business system to be migrated are inferred, forming a set of key dependency chains to be calibrated; The system migration is then completed based on the set of key dependency chains, structured localization migration rules are generated, structured localization migration rules are converted into an executable migration instruction sequence, and system migration is completed based on the migration instruction sequence.

2. The method for migration and adaptation of domestically produced systems based on multidimensional dependency graphs according to claim 1, characterized in that, The process involves collecting cross-level technical dependency clues from the business systems to be migrated, and generating a dependency event sequence based on the triggering order and resource association relationships, including: Before the business system runs, inject a unique hierarchical identifier into the operating system call entry point, database access entry point, middleware message entry point, and processor instruction trigger point, so that the dependency clues of each level can be clearly distinguished in subsequent processing, forming an initial dependency record with hierarchical attributes. During the operation of the business system, the initial dependency records with hierarchical attributes are sorted according to the timestamp when the records are generated, and the time difference between adjacent records is calculated as the event trigger interval. The trigger interval is then appended to the corresponding record to obtain a sorted dependency sequence containing trigger order information. Based on the sorted dependency sequence, the dependency records that access the same resource identifier are clustered, and the resource occupation time overlap between events in each cluster is calculated. The overlap is divided by the duration of the shorter occupation time to obtain the resource association ratio. The resource association ratio is appended to each event in the cluster to form an event clustering sequence with resource association ratio. Based on the event clustering sequence with resource association ratio, each event is combined and encoded according to its hierarchical identifier, trigger interval and resource association ratio to generate an event code that can uniquely reflect the triggering characteristics and resource association of the event in different levels. Using the event code as the key, the events are written into the dependent event sequence in order of occurrence, so that the dependent event sequence simultaneously contains cross-level triggering attributes, sorting triggering information and resource association relationship.

3. The method for migration and adaptation of domestically developed systems based on multidimensional dependency graphs according to claim 2, characterized in that, The construction of a multidimensional dependency graph based on the dependent event sequence, comprising explicit dependency dimension, implicit coupling dimension, and potential conflict dimension, and the formation of graph primitives from the multidimensional dependency graph to characterize the event association mode, includes: Each event in the dependent event sequence is split into a hierarchy field, a trigger interval field, and a resource association ratio field according to its event code. Event adjacency pairs are established according to the order of event occurrence. Each adjacency pair is regarded as an initial event association unit, so that each association unit carries the trigger order information required by the explicit dependency. For each initial event association unit, an implicit coupling strength value is generated based on the resource association ratio between the events. The implicit coupling strength value is obtained by mapping the resource association ratio to a fixed interval and linearly combining it with the trigger interval, so that the implicit coupling strength can simultaneously reflect the competitive relationship and temporal proximity of the two events on resources, thereby forming a weighted association unit with implicit coupling strength. A potential conflict tendency index is constructed for the weighted association unit based on the minimum time interval between events. The potential conflict tendency index is generated by multiplying the implicit coupling strength value by the inverse of the triggering interval as the base. This allows the conflict tendency index to reveal whether there is competitive triggering behavior between events and form a conflict identification unit for the potential conflict dimension. After obtaining conflict identification units with explicit dependency fields, implicit coupling strength fields, and potential conflict tendency indices, each unit is mapped to a directed graph edge between graph nodes, so that the graph edge contains three types of weight fields and uses event encoding as node identifier. A multidimensional dependency graph is constructed using all graph edges. The minimum closable path, the longest uninterrupted association chain, and the locally connected structure with the most significant resource competition are searched in the multidimensional dependency graph, and the searched structures are extracted as graph primitives to characterize the event association mode.

4. The method for migration and adaptation of domestically developed systems based on multidimensional dependency graphs according to claim 3, characterized in that, The method of generating an adaptation mapping tensor using graph primitives to describe the interface differences, instruction path offsets, and timing tolerance ranges of various technical components under different domestic production target environments, and thereby forming a migration adaptation resistance distribution, includes: The event nodes in each graph primitive are grouped according to the hierarchy field, implicit coupling strength field and potential conflict tendency index field carried by the node to generate component association feature vectors. The component-associated feature vectors are compared item by item with the interface specifications, instruction execution paths and timing requirements of the corresponding domestic target environment. The interface difference, instruction path offset and timing tolerance offset values ​​are quantified and combined into component difference triples. Based on the association order of events in the graph primitives, all component difference triples are arranged in a multidimensional structure according to component index, difference type and weight type to form an adaptation mapping tensor; The migration cost is calculated based on the interface difference, instruction path offset, and timing tolerance offset of each element in the adaptation mapping tensor. The migration cost is then combined with the potential conflict tendency index of the corresponding graph primitive to generate migration adaptation resistance units. All migration adaptation resistance units are then aggregated to form a migration adaptation resistance distribution.

5. The method for migration and adaptation of domestically developed systems based on multidimensional dependency graphs according to claim 4, characterized in that, The process involves inferring the adaptation trends and potential bottlenecks of each dependency chain in the business system to be migrated based on the migration adaptation resistance distribution, forming a set of key dependency chains to be calibrated, including: Each migration adaptation resistance unit in the migration adaptation resistance distribution is clustered according to its associated graph primitives. The average, maximum and growth gradient of the migration adaptation resistance values ​​within each cluster are calculated, and the dependency chain resistance feature vector is generated accordingly. Based on the maximum resistance value and growth gradient in the resistance feature vector of each dependency chain, the migration adaptation resistance distribution is mapped to the dependency chain index space. By analyzing the continuous rising segment of the resistance value in the mapping space, the adaptation trend rising interval is identified, and the dependency chain segment in the interval is generated as the dependency chain adaptation trend segment. The bottleneck contribution ratio is calculated for all migration adaptation resistance units contained in the dependency chain adaptation trend segment. The bottleneck contribution ratio is the migration adaptation resistance value of the specified unit divided by the maximum migration adaptation resistance value in the segment. Bottleneck events are located by the migration adaptation resistance units whose bottleneck contribution ratio exceeds a preset threshold, forming a bottleneck event sequence. The bottleneck event sequence is merged into several consecutive dependency chain segments according to the order of event occurrence, and cross-compared with the dependency chain adaptation trend segments. The dependency chain segments that simultaneously satisfy the conditions of a significant increase in adaptation trend and an outstanding bottleneck contribution ratio are marked as key dependency chain segments, and finally a set of key dependency chains to be calibrated is formed.

6. The method for migration and adaptation of domestically produced systems based on multidimensional dependency graphs according to claim 5, characterized in that, The process of generating structured domestic migration rules based on the set of key dependency chains, converting these structured domestic migration rules into an executable migration instruction sequence, and completing the system migration according to the migration instruction sequence includes: After obtaining the set of key dependency chains, migration constraint information is extracted based on the event hierarchy field, trigger interval field, and resource association ratio field in each key dependency chain segment to form migration constraint items that describe the technical limitations of the dependency chain segment. Based on the migration constraints, each item is compared with the interface specifications, instruction execution path requirements, and resource scheduling strategy of the domestic target environment to generate interface replacement constraints, instruction path correction constraints, and resource scheduling adjustment constraints. The three types of constraints are then merged to form a migration structure unit. The migration structure units are topologically sorted according to the causal order of their corresponding key dependency chain segments in the event sequence, and a structured localization migration rule containing execution order, adaptation conditions and exception rollback rules is generated based on the sorting structure. The structured localization migration rules are parsed into several atomic migration actions, and an executable migration instruction sequence is constructed based on the component loading method and transaction consistency requirements of the localization target environment. The migration instruction sequence is executed sequentially in the system migration window to complete the business system migration.

7. A domestically developed system migration and adaptation device based on a multidimensional dependency graph, characterized in that, include: The collection unit is used to collect cross-level technical dependency clues of the business system to be migrated, and generate a dependency event sequence based on the triggering order and resource association relationship. The building unit is used to construct a multidimensional dependency graph with explicit dependency dimension, implicit coupling dimension and potential conflict dimension based on the sequence of dependent events, and the multidimensional dependency graph forms a graph primitive used to characterize the way events are associated. The generation unit is used to generate an adaptation mapping tensor using graph primitives to describe the interface differences, instruction path offsets, and timing tolerance ranges of various technical components under different domestic production target environments, and to form a migration adaptation resistance distribution accordingly. The forming unit is used to infer the adaptation trend and potential bottlenecks of each dependency chain of the business system to be migrated based on the migration adaptation resistance distribution, and form a set of key dependency chains to be calibrated. The migration unit is used to generate structured localization migration rules based on the set of key dependency chains, convert the structured localization migration rules into an executable migration instruction sequence, and complete the system migration according to the migration instruction sequence.

Images