A method for loading game resource files based on access order sorting

Abstract

The present invention discloses a method for loading game resource files based on access order sorting, which relates to the technical field of game engine resource scheduling and is used to solve the problems of unreasonable resource loading order and increased loading delay. The method constructs a dependency graph by parsing resource metadata, uses nodes to represent resource files and directed edges to represent dependency relationships, performs loop detection and topological sorting to obtain structural parameters, combines topological structure with access frequency, uses Pareto sorting to generate an initial loading sequence, monitors the decompression ratio and call frequency of loaded resources in real time, calculates activity, collects the number of requests for unloaded resources and the depth of the dependency chain, and estimates demand intensity. An adjustment factor is constructed based on the Pareto level, activity, and demand intensity, and the loading sequence is reordered and tasks are reallocated. Dependency consistency is verified, key resources are loaded first, and dynamic scheduling optimization is achieved.

Description

Technical Field

[0001] The present invention relates to the technical field of game engine resource scheduling, and more particularly, to a method for loading game resource files based on access sequence sorting. Background Art

[0002] With the rapid development of mobile terminals, personal computing devices, and cloud gaming platforms, modern game applications contain a large number of complex resource files, such as image resources, audio resources, script resources, and model resources. To improve game loading speed and operation efficiency, existing technologies generally manage game resources through resource preloading, partitioned loading, or on-demand loading.

[0003] The existing technology has the following deficiencies:

[0004] At present, most existing resource loading mechanisms adopt static dependency graphs or fixed priority configurations, lacking dynamic evaluation of game resource access timing and dependency depth, resulting in unreasonable resource loading order and increased loading delay. Furthermore, it is impossible to adaptively adjust the resource scheduling strategy according to user behavior or scene switching during operation, which in turn affects the consistency and response speed of game operation. Therefore, a game resource file loading method based on access order sorting is proposed.

[0005] The above information disclosed in this Background section is only for enhancement of understanding of the background of the present disclosure and therefore it may contain information that does not form the prior art that is already known to a person of ordinary skill in the art. Summary of the Invention

[0006] In order to overcome the above-mentioned defects of the prior art, an embodiment of the present invention provides a game resource file loading method based on access order sorting, which solves the problems of unreasonable loading order, static resource scheduling, lack of perception of the running process, etc. raised in the above-mentioned background technology by applying dependency graph modeling, access frequency weight calculation, resource activity and demand intensity analysis, dynamic adjustment of loading sequence and task reallocation mechanism.

[0007] To achieve the above object, the present invention provides the following technical solution: a method for loading game resource files based on access order sorting, comprising the following steps:

[0008] Step S1: Parse the metadata table of the game resource file to construct a dependency graph, taking each game resource file as a node and the dependency relationship between the game resource files as a directed edge, and preprocess the dependency graph according to the nodes and directed edges;

[0009] Step S2: Calculate the priority weight of each game resource file based on the preprocessed dependency graph, detect the access frequency of each game resource file, and generate a loading sequence based on the priority weight of each game resource file;

[0010] Step S3: monitoring the usage status of the game resource files in the loading process and the game resource files that are not loaded in real time, and analyzing the activity of the game resource files in the loading process and the demand intensity of the game resource files that are not loaded according to the usage status;

[0011] Step S4: Adjust the order of game resource files in the loading sequence based on the comprehensive activity and demand intensity, and reallocate the loading tasks.

[0012] In a preferred embodiment, a dependency graph is constructed based on the dependency relationships in the game resource file metadata table;

[0013] After the dependency graph is constructed, loop detection and de-looping as well as pre-processing operations of each node structural parameter calculation are performed on the dependency graph to obtain the in-degree value, out-degree value and level value of each node.

[0014] In a preferred embodiment, the in-degree value, out-degree value and level value of each node are collected, and the weighted average value of each node is calculated. Priority weight;

[0015] Record the number of times each game resource file is accessed and normalize it to obtain the access frequency weight.

[0016] In a preferred embodiment, a Pareto optimal screening method is used to perform non-inferiority front sorting on the priority weights and the access frequency weights, thereby generating a loading sequence.

[0017] In a preferred embodiment, for a game resource file currently in the loading process, the resource decompression ratio and thread call frequency are collected;

[0018] The activity of the node is obtained by taking a weighted average of the resource decompression ratio and thread call frequency.

[0019] In a preferred embodiment, for game resource files that have not yet been loaded, the number of call requests and the dependency chain trigger depth are collected; the number of call requests and the dependency chain trigger depth are weighted averaged to obtain the node demand intensity.

[0020] In a preferred embodiment, a fuzzy input set is constructed based on fuzzy logic with the activity and demand intensity of the nodes as inputs.

[0021] In a preferred embodiment, a membership function is constructed based on the fuzzy input set to obtain a fuzzy output set;

[0022] The centroid method is used to defuzzify the fuzzy output set and obtain the adjustment factor of each node.

[0023] In a preferred embodiment, after the adjustment factors of all nodes are calculated, an adjustment factor set is constructed to generate an adjusted loading sequence.

[0024] In a preferred embodiment, the load tasks are redistributed according to the adjusted load sequence, and the specific operations include checking the current load tasks, analyzing the priorities, reassigning tasks and updating the load queue, and checking the dependency consistency.

[0025] Technical effects and advantages of the present invention:

[0026] 1. The present invention constructs a dependency graph by parsing resource metadata, represents resource files through nodes, represents their dependencies through directed edges, performs loop detection and topological sorting, and obtains the structural parameters of each node. On this basis, the initial loading sequence is generated by combining the topological structure and access frequency using Pareto sorting. Subsequently, the decompression ratio and thread call frequency of the loaded resources are monitored in real time to calculate their activity; the call requests and dependency chain depth of the unloaded resources are collected to estimate their demand intensity. Furthermore, an adjustment factor is constructed based on the Pareto level, activity and demand intensity of the resources, the loading sequence is reordered, and the loading tasks are reallocated. Before task scheduling, the dependency consistency is verified to ensure that the loading order of each resource satisfies the dependency relationship, ultimately achieving priority loading and dynamic scheduling optimization of key resources, improving game operation efficiency and user experience. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] Figure 1 This is a flow chart of an implementation method of a game resource file loading method based on access order sorting according to the present invention.

[0028] Figure 2 The present invention is a schematic diagram of the steps of a method for loading game resource files based on access order sorting. DETAILED DESCRIPTION

[0029] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention. Example

[0030] See also Figures 1 to 2 , a method for loading game resource files based on access order sorting, comprising the following steps:

[0031] Step S1: Parse the metadata table of the game resource file to construct a dependency graph, taking each game resource file as a node and the dependency relationship between the game resource files as a directed edge, and preprocess the dependency graph according to the nodes and directed edges;

[0032] Step S2: Calculate the priority weight of each game resource file based on the preprocessed dependency graph, detect the access frequency of each game resource file, and generate a loading sequence based on the priority weight of each game resource file;

[0033] Step S3: monitoring the usage status of the game resource files in the loading process and the game resource files that are not loaded in real time, and analyzing the activity of the game resource files in the loading process and the demand intensity of the game resource files that are not loaded according to the usage status;

[0034] Step S4: Adjust the order of game resource files in the loading sequence based on the comprehensive activity and demand intensity, and reallocate the loading tasks.

[0035] The specific implementation is as follows:

[0036] In step S1, the metadata table corresponding to the game resource file is parsed. The metadata table is a structured data set containing unique identifiers and dependencies, recording the unique identifiers and dependency information of the game resource files. The dependency information includes a joint trigger relationship and a first-to-last-to relationship. The joint trigger relationship indicates that the game resource file needs to be loaded synchronously with other game resource files, and the first-to-last-to relationship indicates that the game resource file needs to be loaded after other game resource files.

[0037] The dependency relationships of game resource files are structurally modeled, with each game resource file being considered a node in the dependency graph and the dependency relationships being considered directed edges in the dependency graph.

[0038] If a game resource file has a joint trigger relationship with another game resource file, create a directed edge from the game resource file to the other game resource file, and set the edge weight to one;

[0039] If a game resource file must be used after another game resource file is loaded, create a directed edge from the other game resource file to the game resource file, and set the edge weight equal to one.

[0040] Therefore, the dependency graph is defined as a directed graph, denoted as G=(V,E), where:

[0041] Node Set Indicates all game resource files to be loaded;

[0042] Edge Set .

[0043] After the dependency graph is constructed, the pre-processing operations of loop detection and de-looping and structural parameter calculation of each node are performed on the dependency graph. The specific implementation is as follows:

[0044] The dependency graph structure is tested for directed cycles through topological sorting. If a directed cycle is detected in the dependency graph, that is, a group of nodes forming a loop, the minimum weight edge is marked and deleted to break the loop, ensuring that the loading order can be linearly advanced, making the dependency graph a topologically ordered graph.

[0045] In the calculation of each node's structural parameters, for each node, calculate its in-degree value. The calculation formula is: ,in, Indicates the in-degree value, which depends on the game resource file The number of other game resource files;

[0046] Then for each node, calculate its out-degree value, the calculation formula is ,in, Indicates the degree value, that is, the game resource file The number of other game resource files it depends on;

[0047] Finally, based on the topological sorting algorithm, starting from all nodes with zero in-degree in the dependency graph, the level value of each node is recursively calculated downwards. The calculation formula is: ,in, Representation node All direct predecessor nodes of Initially, all nodes without predecessors set up The level value reflects the depth of the game resource file in the dependency chain and measures the logical level of its loading order.

[0048] It should be noted that topological sorting refers to the linear ordering of all nodes in a directed acyclic graph, so that for any directed edge from one node to another, one node is always placed before another in the sorting. This is used to determine the processing order under dependency relationships and ensure that the subsequent resource loading order satisfies logical dependencies. A predecessor node is a node that points to a target node in the dependency graph. If a node has a directed edge pointing to another node, it is called the direct predecessor of the other node. The set of direct predecessor nodes is defined as the set of all nodes that point to the current node.

[0049] By uniformly modeling the joint trigger relationship and the first-to-last-to relationship between game resource files as a directed graph structure, the complex dependency relationship between resources can be effectively reflected; by introducing topological sorting and loop detection mechanisms, the resource dependency chain can be automatically sorted and feasible loading path planning can be achieved, avoiding loading deadlocks or resource conflicts caused by circular dependencies; in addition, through the quantitative calculation of structural parameters such as in-degree values, out-degree values ​​and hierarchical values, a logical basis is provided for subsequent resource priority determination, enhancing the rationality and controllability of loading scheduling.

[0050] In step S2, for each node in the dependency graph G=(V,E) Perform topology analysis and collect the in-degree values ​​of each node , out-degree value and level values ;

[0051] Based on the above structural parameters, calculate each node The priority weight is calculated as follows: ,in, is the priority weight, weight coefficient , and satisfies ;

[0052] By accessing the log system, the number of times each game resource file is accessed is recorded as the access frequency of the game resource file during use. Frequency of access Normalize to get the access frequency weight The specific calculation formula is ;

[0053] Use Pareto optimal screening method to prioritize weights and access frequency weight Perform non-inferior front sorting to generate a loading sequence. The specific process is as follows:

[0054] Each node The priority weight and access frequency weight are constructed as a two-dimensional target vector ;

[0055] Defining Nodes Dominant Node The condition is and And at least one is strictly greater than, if there is no node Dominant Node , then the node Belongs to the first-level Pareto frontier;

[0056] Repeat the dominance screening steps, peel off the previous frontier nodes one by one, and obtain the subsequent frontier set until all nodes are assigned to a non-inferior frontier layer. The Pareto level is ,but Pareto level;

[0057] Based on the Pareto level of the node Perform the main sorting, the lower the level, the higher the priority; in the same Pareto frontier, further according to or Perform secondary sorting;

[0058] The final loading sequence is recorded as ,in This loading sequence will serve as the initial input for subsequent loading scheduling tasks.

[0059] It should be noted that the log system refers to a monitoring module used to collect and record the usage status of game resource files, including indicators such as the number of accesses, thread call frequency, and call requests, which are used to construct the access frequency weight in this step S2; the Pareto optimal screening method is a multi-objective decision-making sorting method used to identify a set of elements in the target space where no other target vectors are not inferior to the current vector in all targets; non-inferior frontier sorting is a process of dividing all objects to be sorted into multiple levels according to the dominance relationship, and the lower the sorting level is, the better; domination means that in multi-objective optimization, a node is better than or equal to another node in all target dimensions, and is better than the other node in at least one target dimension, then the node is said to dominate the other node; primary sorting refers to the Pareto level determined by the non-inferior frontier stratification as the sorting basis, and the smaller the level value, the higher the sorting priority; secondary sorting is to use a single indicator to further refine the sorting results when the primary sorting level is the same, to ensure the stability of the sorting and fine-grained scheduling control.

[0060] Through topological structure analysis, the in-degree, out-degree and hierarchical values ​​of resource files are obtained, and a weight coefficient is introduced to calculate the resource priority, which can reflect the structural importance of resources in the overall dependency graph. By accessing the log system to collect access frequencies and normalize them, and combining them with the Pareto optimal screening method for non-inferior frontier sorting, multi-objective optimization of resource loading scheduling is achieved, taking into account access activity while ensuring the rationality of dependencies, effectively improving the intelligence level of resource scheduling.

[0061] In step S3, for the game resource file currently being loaded, the resource decompression ratio and thread call frequency are collected by accessing the log system;

[0062] The resource decompression ratio is the decompressed percentage of the current game resource files, defined as ,in, For game resource files The number of bytes of data currently decompressed, The total number of data bytes.

[0063] The thread call frequency is the frequency at which the game resource file is called to the main thread or rendering thread. The number of calls per unit time is collected and recorded as ,in, For nodes The number of thread calls within the sampling period T.

[0064] Define nodes based on resource decompression ratio and thread call frequency Activity for

[0065] ;

[0066] in, is the weight coefficient, satisfying η1+η2=1. Activity The higher the value, the more active the game resource files will be during the loading process.

[0067] For game resource files that have not yet been loaded, real-time monitoring of call attempts and reference requests generated during the running process is performed, and the number of call requests and the trigger depth of the dependency chain are collected;

[0068] The number of call requests indicates the number of times the game resource file is requested by other components or resource nodes within a given time window T, recorded as ;

[0069] The dependency chain trigger depth indicates that the node The shortest call path depth in the dependency chain is defined as ,in Indicates that the node currently in the active state To Node The length of the dependency path, The currently active resource collection.

[0070] Define nodes based on the number of call requests and the trigger depth of the dependency chain Demand intensity for

[0071] ;

[0072] in, is the weight coefficient, satisfying Demand intensity The higher it is, the more likely the game resource file is to be accessed during the current run.

[0073] It should be noted that the dependency chain refers to a directed path sequence formed by the dependency relationship between game resource files.

[0074] By introducing the resource decompression ratio and thread call frequency, an activity index is established for game resource files during the loading process, accurately reflecting the intensity of resource usage in real-time loading. At the same time, the number of call requests and the dependency chain trigger depth of resource files that have not yet been loaded are collected to build a demand intensity assessment model, enabling the system to proactively identify potential key resources and improve the foresight and responsiveness of loading scheduling.

[0075] In step S4, fuzzy language variables are constructed based on fuzzy logic algorithm. and demand intensity They are divided into three fuzzy sets: Low, Medium, and High. The output variable is the adjustment factor , which is also divided into three fuzzy sets: weak priority (Low), medium priority (Medium), and strong priority (High).

[0076] It should be noted that the division of fuzzy sets can be adjusted according to actual conditions. For example, although this embodiment takes three fuzzy sets as an example, in practice, the activity level and demand intensity can be divided into more than three sets.

[0077] Constructing variables using triangular functions The fuzzy membership function is as follows:

[0078] ;

[0079] ;

[0080] ;

[0081] Among them, a, b, and c are the dividing points of the fuzzy interval, which are obtained by professionals based on historical statistical data and will not be elaborated here.

[0082] The minimum membership principle is used to obtain the rule matching strength, and all the activated rule results are superimposed through the maximum synthesis principle to construct the fuzzy output set. The centroid method is then used to perform the defuzzification operation and calculate the continuous real value adjustment factor , whose formula is ,in, Represents the membership function of the adjustment factor fuzzy output.

[0083] After completing the adjustment factor calculation for all nodes, construct the adjustment factor set ,in accordance with Sort in descending order to generate the adjusted loading sequence .

[0084] like ,but Sort by priority ;

[0085] like , then keep it in the original loading sequence The relative order in order to maintain scheduling stability;

[0086] After the sequence rearrangement is completed, according to the adjusted loading sequence Execute the reallocation of loading tasks. Specific allocation operations include checking the current loading tasks, analyzing and comparing priorities, reassigning tasks, updating the loading queue, and verifying dependency consistency;

[0087] Check the currently loaded task by scanning the current task queue and thread scheduling queue to extract the set of task nodes being scheduled or queued. ;

[0088] Analyze the priority comparison analysis The corresponding nodes in Value and The median is compared, if there is a node exist After the corresponding position in the task drops to other unloaded nodes, its task will be suspended or withdrawn;

[0089] Reassign tasks and update the load queue according to the adjusted load sequence , sequentially generate and submit resource loading tasks to the task scheduler, ensuring that high-priority resources are at the front of the queue and ensuring the loading response time of key resources;

[0090] Verify dependency consistency Before submitting a task, check the direct predecessor set of each game resource file in the adjusted loading sequence to confirm that its dependent resources have been loaded or are being loaded, ensuring that the loading order meets the dependency constraints.

[0091] It should be noted that the task scheduler refers to a system module used to receive and schedule resource loading tasks. It adds resource loading tasks to the execution queue according to the priority order of the loading sequence and allocates thread resources for execution; dependency constraints refer to the dependency order rules that must be followed to ensure the correctness and consistency of resource loading.

[0092] By introducing fuzzy logic algorithms, flexible modeling of the complex nonlinear relationship between activity and demand intensity is achieved, avoiding the rigid resource scheduling problem caused by traditional hard rule boundaries. At the same time, the loading order is dynamically rearranged based on continuous adjustment factors to improve the flexibility and adaptability of loading scheduling. Further combined with mechanisms such as task reassignment and dependency consistency verification, dynamic optimization and safe scheduling of the resource loading process can be achieved.

[0093] The above formulas are all dimensionless and numerical calculations. The formulas are obtained by collecting a large amount of data and performing software simulation to obtain the most recent real situation. The preset parameters in the formulas are set by technicians in this field according to actual conditions.

[0094] The above embodiments can be implemented in whole or in part by software, hardware, firmware or any other combination. When implemented using software, the above embodiments can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer program are loaded or executed on a computer, the process or function described in the embodiment of the present application is generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another computer-readable storage medium. For example, the computer instructions can be transmitted from one website, computer, server or data center to another website, computer, server or data center via wired or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device such as a server or data center that contains one or more available media sets. The available medium can be a magnetic medium (e.g., a floppy disk, a hard disk, a tape), an optical medium (e.g., a DVD), or a semiconductor medium. The semiconductor medium can be a solid-state drive.

[0095] It should be understood that in the various embodiments of the present application, the size of the serial numbers of the above-mentioned processes does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present application.

[0096] Those skilled in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0097] Those skilled in the art will clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0098] In the several embodiments provided in this application, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are merely schematic. For example, the division of the units is merely a logical function division. In actual implementation, there may be other division methods, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0099] The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple network units. Some or all of these units may be selected to achieve the purpose of this embodiment according to actual needs.

[0100] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0101] If the functions are implemented in the form of software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art, or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for enabling a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0102] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of this application. Therefore, the scope of protection of this application should be based on the scope of protection of the claims.

Claims

1. A method for loading game resource files based on access order sorting, characterized by: The following steps are involved: Step S1: Parse the metadata table of the game resource file to construct a dependency graph, taking each game resource file as a node and the dependency relationship between the game resource files as a directed edge, and preprocess the dependency graph according to the nodes and directed edges; Step S2: Calculate the priority weight of each game resource file based on the preprocessed dependency graph, detect the access frequency of each game resource file, and generate a loading sequence based on the priority weight of each game resource file; Step S3: monitoring the usage status of the game resource files in the loading process and the game resource files that are not loaded in real time, and analyzing the activity of the game resource files in the loading process and the demand intensity of the game resource files that are not loaded according to the usage status; For the game resource files currently being loaded, collect the resource decompression ratio and thread call frequency; The activity of the node is obtained by taking a weighted average of the resource decompression ratio and thread call frequency; For game resource files that have not yet been loaded, collect the number of call requests and the trigger depth of the dependency chain; perform a weighted average of the number of call requests and the trigger depth of the dependency chain to obtain the node's demand intensity; Step S4: adjusting the order of game resource files in the loading sequence based on the comprehensive activity and demand intensity, and reallocating loading tasks; Based on fuzzy logic, the activity and demand intensity of nodes are used as input to construct a fuzzy input set; Construct membership functions based on fuzzy input sets and obtain fuzzy output sets; The centroid method is used to defuzzify the fuzzy output set and obtain the adjustment factor of each node; After completing the calculation of the adjustment factors of all nodes, the adjustment factor set is constructed to generate the adjusted loading sequence.

2. The method for loading game resource files based on access order sorting according to claim 1, characterized in that: Build a dependency graph based on the dependencies in the game resource file metadata table; After the dependency graph is constructed, loop detection and de-looping as well as pre-processing operations of each node structural parameter calculation are performed on the dependency graph to obtain the in-degree value, out-degree value and level value of each node.

3. The method for loading game resource files based on access order sorting according to claim 2, characterized in that: Collect the in-degree value, out-degree value and level value of each node, and calculate the weighted average of each node Priority weight; Record the number of times each game resource file is accessed and normalize it to obtain the access frequency weight.

4. The method for loading game resource files based on access order sorting according to claim 3, characterized in that: The Pareto optimal screening method is used to sort the priority weights and access frequency weights into non-inferiority frontiers to generate a loading sequence.

5. The method for loading game resource files based on access order sorting according to claim 1, characterized in that: The loading tasks are redistributed according to the adjusted loading sequence. The specific operations include checking the current loading tasks, analyzing the priority comparison, reassigning tasks and updating the loading queue, and verifying the dependency consistency.

Images