A graphical Linglong package management method

Abstract

The present application provides a graphical Linglong package management method, which relates to the field of computer technology, including: deep analysis of Linglong packages to extract deep features; establishing a dependency graph; configuring a graphical interactive interface for Linglong packages; generating Linglong package call instructions based on interactive information, performing collaborative operation analysis based on the dependency graph, and configuring timing collaborative call results; synchronously generating system resource monitoring instructions based on Linglong package call instructions; optimizing the call control of Linglong packages using timing collaborative call results and system resource status monitoring results, generating optimization results, and managing Linglong packages. This application can solve the technical problem in the prior art that in complex scenarios, the call order and resource allocation of Linglong packages are unreasonable, resulting in execution conflicts, which further affects the efficiency of Linglong package management. By constructing a relationship dependency graph and monitoring system resources, the efficiency of graphical Linglong package management is improved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a graphical Linglong package management method. Background Art

[0002] With the continuous advancement of software development and system integration, package management, as an important tool, plays a crucial role in automated deployment, maintenance, and updates. In these systems, Linglong packages (i.e., various dependent packages or modules) are widely used as independent, reusable software components to ensure the interoperability of different functional modules. Graphical Linglong package management tools typically display package information, dependencies, and execution status through a user-friendly graphical user interface (GUI), allowing users to quickly understand the usage of each Linglong package and perform operations as needed. However, in complex scenarios, due to the complex dependencies between packages, improper call ordering can lead to execution conflicts between packages. Furthermore, system resource usage constantly changes during the execution of different packages. Failure to fully consider the allocation of these resources can lead to resource conflicts and waste, impacting the normal execution of packages. Reasonable resource allocation is particularly crucial when multiple packages are executed in parallel. When multiple packages work together, execution conflicts are inevitable. This is especially true when resource usage is excessive or tasks are executed in the wrong order. This reduces the efficiency of the Linglong package management process and may even cause errors and exceptions.

[0003] In summary, the existing technology has technical problems in that the calling order and resource allocation of Linglong packages in complex scenarios are unreasonable, resulting in execution conflicts and resource waste, which further affects the management efficiency of Linglong packages. Summary of the Invention

[0004] The purpose of this application is to provide a graphical Linglong package management method to solve the technical problem in the existing technology that in complex scenarios, the calling order and resource allocation of Linglong packages are unreasonable, resulting in execution conflicts and resource waste, which further affects the efficiency of Linglong package management.

[0005] In view of the above problems, the present application provides a graphical Linglong package management method, wherein the graphical Linglong package management method includes: performing deep analysis on the Linglong package, and extracting deep features based on the deep analysis results; using the deep features to perform dependency analysis between Linglong packages, and establishing a dependency graph; configuring the graphical interactive interface of the Linglong package, and obtaining interaction information of the graphical interactive interface, wherein the interaction information is the user's operation information based on the graphical interactive interface; generating a Linglong package call instruction based on the interaction information, and performing collaborative operation analysis based on the dependency graph based on the Linglong package call instruction, and configuring a timing collaborative call result; synchronously generating a system resource monitoring instruction based on the Linglong package call instruction, performing real-time monitoring of the system resource status based on the system resource monitoring instruction, and establishing a system resource status monitoring result; using the timing collaborative call result and the system resource status monitoring result to perform call control optimization of the Linglong package, and generate an optimization result; and managing the Linglong package based on the optimization result.

[0006] The technical solution provided in this application has at least the following technical effects or advantages:

[0007] By performing a deep analysis of the Linglong package, deep features are extracted based on the deep analysis results; the deep features are used to perform dependency analysis between Linglong packages and establish a dependency graph; the graphical interaction interface of the Linglong package is configured, and interaction information of the graphical interaction interface is obtained, wherein the interaction information is the user's operation information based on the graphical interaction interface; a Linglong package call instruction is generated based on the interaction information, and a collaborative operation analysis based on the dependency graph is performed based on the Linglong package call instruction, and a timing collaborative call result is configured; a system resource monitoring instruction is synchronously generated based on the Linglong package call instruction, and the system resource status is monitored in real time based on the system resource monitoring instruction, and a system resource status monitoring result is established; the timing collaborative call result and the system resource status monitoring result are used to optimize the call control of the Linglong package and generate an optimization result; the Linglong package is managed based on the optimization result. In other words, by deeply analyzing the Linglong package to extract deep features, build a dependency graph, and clarify the interdependence between packages; configure a graphical interactive interface and obtain interaction information, perform collaborative operation analysis based on the dependency graph and user interaction information, and at the same time, monitor system resource usage, and perform call control optimization based on the timing collaborative call results and system resource status monitoring results, thereby improving the efficiency of graphical Linglong package management.

[0008] The above description is only an overview of the technical solution of the present application. In order to more clearly understand the technical means of the present application, which can be implemented in accordance with the contents of the description, and to make the above and other purposes, features and advantages of the present application more obvious and easy to understand, the specific implementation methods of the present application are specifically listed below. It should be understood that the content described in this section is not intended to identify the key or important features of the embodiments of the present application, nor is it intended to limit the scope of the present application. Other features of the present application will become easy to understand through the following description. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] In order to more clearly illustrate the technical solutions in this application or the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are merely exemplary, and a person of ordinary skill in the art can obtain other drawings based on the provided drawings without any creative work.

[0010] Figure 1 This is a flowchart of a graphical Linglong package management method for this application;

[0011] Figure 2 This is a flow chart of generating optimization results in a graphical Linglong package management method of this application. DETAILED DESCRIPTION

[0012] This application provides a graphical Linglong package management method to solve the technical problem in the prior art that the call sequence and resource allocation of Linglong packages in complex scenarios are unreasonable, resulting in execution conflicts and resource waste, which further affects the efficiency of Linglong package management. By deeply analyzing the Linglong package to extract deep features, constructing a dependency graph, and clarifying the interdependencies between packages; configuring a graphical interactive interface and obtaining interaction information, performing collaborative operation analysis based on the dependency graph and user interaction information, and at the same time, monitoring system resource usage, performing call control optimization based on the time-series collaborative call results and system resource status monitoring results, the efficiency of graphical Linglong package management is improved.

[0013] Below, the technical solutions in this application will be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of this application, rather than all the embodiments of this application. It should be understood that this application is not limited to the example embodiments described herein. Based on the embodiments of this application, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of this application. It should also be noted that, for the convenience of description, only the parts related to this application, rather than all of them, are shown in the accompanying drawings.

[0014] For examples, please see the attached Figure 1The present application provides a graphical Linglong package management method, wherein the graphical Linglong package management method specifically includes the following steps:

[0015] S100: Perform deep analysis on the Linglong bag and extract deep features based on the deep analysis results.

[0016] Furthermore, the present application S100 includes:

[0017] Obtain the call records of the Linglong package, perform Linglong package association analysis based on the call records, and establish a first association; perform data analysis on each Linglong package, use the data analysis results to perform similarity calculation, and establish a second association, wherein the similarity calculation includes feature similarity calculation, function similarity calculation, and behavior similarity calculation; perform dependency depth and dependency breadth analysis between Linglong packages based on the first and second associations, and extract deep features.

[0018] Specifically, Linglong Package refers to graphical operations and Linglong Packages in software development, which are mainly used to solve the complexity and compatibility issues of traditional software package formats under Linux systems. In Linux systems, especially the Deepin operating system, Linglong Package is a new software package format that aims to simplify the software installation and management process. By using a graphical interface, users can more conveniently install, update, and uninstall software without relying on command line operations. Deep analysis refers to a more detailed analysis of the Linglong Package, usually including a comprehensive analysis of its source code, metadata, file structure, dependencies, functional features, etc. Deep analysis is not limited to the extraction of surface data, but also goes deep into the specific implementation of the package, dependencies, potential conflicts and problems, including but not limited to file structure analysis, metadata analysis, source code or binary analysis, behavioral analysis, etc.

[0019] Collect call records for each Linglong package. This data can be obtained using tools such as calltree, gprof, kprof, and gdb. These records are typically automatically generated through log files or monitoring systems and record every call event for the package, including the package name, call time, execution result, and other packages called. A call record refers to the log or data of each Linglong package being called, executed, or interacted with. It contains information such as timestamps, executed packages, called packages, and execution results. It is used to track the usage and interaction history of each Linglong package. The collected call records are organized into a connectivity matrix, with the rows representing the addresses of the called functions and the columns representing the addresses of the calling functions. The intersections in the matrix represent the call relationships between the two functions, and the accumulated values represent the number of calls. Linglong package association analysis is performed based on the call records to discover correlations between Linglong packages and establish a primary association. Association analysis is an analytical technique used to discover patterns and regularities in the co-occurrence of certain attributes in large datasets.

[0020] Perform data analysis on each Linglong package, including analyzing the package's attributes, functions, behaviors, and other information. Extract relevant information through in-depth analysis of the Linglong package's source code or configuration files. Use Python's json and yaml libraries to parse description files (manifest or metadata) to parse package names, version numbers, dependency lists, and more. Use system monitoring tools to capture runtime logs and analyze the package's runtime behavioral characteristics, such as called functions and generated outputs. Perform feature similarity calculations on the data analysis results, comparing features based on the package's basic properties (such as the operating system it depends on and resource requirements). Compare the feature vectors of each package and calculate the similarity between two packages using cosine similarity.

[0021] Functional similarity calculations are performed on the data analysis results. Functional descriptions of the packages are extracted and converted into function vectors. Functional similarity is assessed by comparing the similarity of the function vectors. For example, TF-IDF (Term Frequency-Inverse Document Frequency) is used to extract keywords from the function descriptions; cosine similarity is used to calculate the similarity of the function descriptions. Behavioral similarity calculations are performed on the data analysis results to analyze the runtime behavior of the packages, such as system calls, memory usage patterns, and network communications. Behavioral similarity is calculated by comparing behavior logs. For example, runtime behavior features of the packages (such as the number of system calls and network access frequency) are extracted; and the dynamic time warping (DTW) algorithm is used to match time series behavior data.

[0022] By combining the results of feature, function, and behavior similarity calculations, a second package association matrix is generated, reflecting the degree of similarity between Linglong packages. This similarity calculation establishes a second association, not only identifying direct dependencies between packages but also further linking packages with similar functions and behaviors. Combining the first and second associations, we analyze the depth and breadth of dependencies between packages. Dependency depth refers to analyzing the package hierarchy through the package dependency graph to determine the length of a package's dependency chain. Dependency breadth refers to analyzing the number of other packages a package directly depends on, helping to identify key packages in the system.

[0023] Based on the results of dependency analysis, deep features are extracted. These features describe the importance, complexity, and interdependencies of packages in the system. Deep features refer to the key attributes or characteristics of a package extracted from dependency depth and breadth analysis, describing key attributes such as the package's functionality, behavior patterns, and resource requirements. Through primary and secondary associations, the system can clearly identify direct dependencies and functional similarities between packages, avoiding potential errors in the package management process. The extraction of deep features helps identify key packages and core functions in the system, enabling more precise scheduling and optimization of package installation, updates, and uninstallation operations.

[0024] S200: Utilize the deep features to perform dependency analysis between Linglong packages and establish a dependency graph.

[0025] Specifically, the extracted deep features are organized to ensure data accuracy. The dependencies of a Linglong package can be identified through its internal dependency fields. Each package in a Linglong package has a clear dependency list, including base dependencies, runtime dependencies, and transitive dependencies, which can be obtained by parsing the package's metadata file. Dependency analysis is performed using the dependency data extracted from the deep features. By comparing the dependency fields of each package, the dependency relationships between packages are identified. A directed graph can be used to represent the dependency relationships between packages. Each package is a node. If package A depends on package B, a directed edge is drawn from A to B in the graph. Based on the metadata of each package, the dependency fields are extracted and the relationship is established.

[0026] Based on the results of dependency analysis, packages and their dependencies are organized into a graph structure. Nodes in the graph represent Linglong packages, and edges represent dependency relationships. Each Linglong package is treated as a node, and directed edges are constructed in the graph based on the dependencies between Linglong packages. This connects all Linglong packages and forms a complete dependency graph. A dependency graph is a graph structure constructed through dependency analysis, with nodes representing Linglong packages and edges representing the dependencies of one package on another. The dependency graph clearly displays the dependency hierarchy and interactions between packages. Through graph visualization, users can intuitively see which packages depend on other packages and which packages are critical dependencies of the system. The dependency graph provides intuitive inter-package dependency information, helping users understand the relationships between packages. For complex systems, it clearly shows which packages are critical dependencies and which are optional.

[0027] S300: Configuring the graphical interaction interface of Linglong Package and obtaining interaction information of the graphical interaction interface, where the interaction information is operation information of the user based on the graphical interaction interface.

[0028] Specifically, the graphical interface (GUI) for configuring the Linglong package is the interface that interacts with the user through graphical elements (such as buttons, menus, text boxes, and icons). The graphical interface (GUI) is the medium through which users interact with the system. When configuring the Linglong package GUI, the first thing to do is to design the interface elements to ensure that users can manage the Linglong package through simple operations. The interface design must meet user needs and ensure its ease of use and intuitiveness. Interface element design includes the Linglong package list display, action buttons (providing installation, uninstallation, and update buttons, and users can click the corresponding button to select an action on a specific package), a search box (allowing users to search for Linglong packages by package name or other keywords), and a status bar.

[0029] For example, let's consider a simple GUI interface. The package list displays currently installed packages, with buttons allowing users to install, update, or uninstall a package. Users can search for Linglong packages by package name or other keywords in the search box, and the system will display matching packages. Clicking a package displays detailed package information and provides action buttons.

[0030] When users operate through the graphical interactive interface (GUI), their operation information needs to be captured and passed to the backend for processing. This information includes the user's specific desired operation, target package, selected version, and confirmation of the operation. For example, an event-driven programming model is used to capture user actions such as clicks, selections, and input on the GUI. This information is then passed to the system through backend data processing mechanisms (such as APIs and message queues) for appropriate operation. The GUI allows users to manage Linglong packages more intuitively and conveniently, eliminating the need to enter complex commands through the command line, lowering the barrier to entry.

[0031] S400: Generate a Linglong package calling instruction according to the interactive information, perform collaborative operation analysis based on the dependency graph based on the Linglong package calling instruction, and configure a timing collaborative calling result.

[0032] Specifically, based on the interactive information, i.e., the operational information entered by the user through the graphical interactive interface, including the selected target Linglong package, the operation type (e.g., install, uninstall, update), and other relevant parameters, the operation type, target package, version, and other information are parsed from the interactive information entered by the user through the graphical interface. Based on the parsed results, a standardized Linglong package call instruction is generated. A Linglong package call instruction is a system instruction generated by the parsing of interactive information, indicating the operation (e.g., install, update, uninstall) that the system needs to perform on the target Linglong package, as well as its dependency analysis. Collaborative operation analysis refers to determining the order and method of operations between multiple packages, as well as whether they can be executed in parallel or in steps, based on the analysis of the dependency graph.

[0033] Parse the interactive information entered by the user through the graphical interface to extract the operation target (i.e., the target Linglong package) and the operation type (e.g., install or uninstall). The target package and operation type are combined to form a standardized call instruction. Based on the call instruction, the target package is determined, and the inter-package collaboration relationships are analyzed using the dependency graph. The target package is located in the dependency graph and its direct and indirect dependencies are identified. Determine whether the installation, update, or uninstallation of the package requires support from other packages and check whether multiple operations can be performed in parallel. Typically, a depth-first search (DFS) is used to traverse the dependency graph to determine the complete dependency chain of the target package.

[0034] According to the dependency depth of the complete dependency chain of the target package, a hierarchical division is performed to determine which packages belong to the same layer. A timing call plan is generated based on the hierarchical division, including which packages to execute first, which packages can be executed in parallel, and which packages to execute last. The timing call plan is executed and verified to determine the final timing collaborative call result. The timing collaborative call result refers to the call plan generated after the collaborative operation analysis, which defines the sequence and timing of package operations to ensure correct dependencies and efficient operations. The timing collaborative call result refers to the call instruction execution plan configured according to the dependency and execution order of the call instructions, including the execution order and parallel execution strategy. By combining the call instruction with the dependency graph, the dependency chain of the package can be quickly analyzed and the optimal call plan can be generated. The dependency depth analysis and timing plan configuration ensure the correct operation order of the package, while optimizing efficiency by utilizing parallel operations.

[0035] S500: Synchronously generate a system resource monitoring instruction according to the Linglong package call instruction, perform real-time monitoring of the system resource status according to the system resource monitoring instruction, and establish a system resource status monitoring result.

[0036] Specifically, system resource monitoring instructions are generated based on the Linglong package's call instructions to monitor system resource usage, such as CPU, memory, disk, and network usage. Based on the requirements of the Linglong package's call instructions, corresponding system resource monitoring instructions are generated to ensure that system resources are effectively monitored when executing Linglong package operations. System resource monitoring instructions track system resource usage during the call process, such as CPU utilization, memory usage, disk I / O, and network traffic.

[0037] First, Linglong package calls are parsed to determine the type of package management operation (e.g., install, uninstall, update). Based on the nature of the operation (e.g., installing a large package may require more CPU and memory resources), the corresponding system resource monitoring requirements are determined. For example, if the installation package requires downloading a large amount of data, the system will need to monitor network bandwidth and disk space.

[0038] Based on generated system resource monitoring instructions, the system's resource status is monitored in real time to ensure that the system is not overloaded when executing package operations. CPU, memory, disk, network, and other resource usage are regularly collected. Monitoring results are dynamically updated and displayed on the console or through a graphical interface to present resource status in real time. If resource usage exceeds a certain threshold (e.g., CPU usage exceeds 90%), an alarm is triggered or package management operations are suspended.

[0039] Based on the summary and recording of system resource usage collected during real-time monitoring of system resource status, the real-time monitored system resource data is stored and analyzed to create system resource status monitoring results. These can be log files, database records, or real-time charts on the monitoring interface. System resource status monitoring results should include historical data on resource usage, current status, and alerts for any abnormal conditions, such as CPU utilization, memory usage, and disk I / O. By monitoring system resource usage in real time, resource bottlenecks can be identified promptly during package management operations, preventing system crashes or overloads.

[0040] S600: Optimizing the call control of the Linglong package by utilizing the timing coordination call result and the system resource status monitoring result to generate an optimization result.

[0041] S700: Perform Linglong package management according to the optimization result.

[0042] Specifically, the timing coordination call result refers to the call instruction execution plan configured based on the call instruction dependencies and execution order, including the execution order and parallel execution strategy. The system resource status monitoring results should include historical data on resource usage, current status, and alerts for any abnormal conditions, such as CPU utilization, memory usage, and disk I / O.

[0043] In the dependency graph, the whole is divided into several nodes according to a specific algorithm to facilitate local optimization and management. Each node represents a subtask or module. Based on the results of the timing coordination call, the task is divided into different nodes, and a prediction window is created to divide the time interval of the task. When executing the nodes of each prediction window, the timing change trend is predicted in combination with the resource status monitoring results. The conflict risk factor of each window is calculated based on the prediction data (such as the possibility of memory overload, CPU contention risk, etc.), and the risk is judged based on the conflict risk factor to determine whether optimization is required. If the conflict risk factor is too high, an optimization instruction is generated to call the optimization.

[0044] Optimization algorithms are used to adjust execution plans and find the optimal call control strategy to ensure the highest efficiency and the least conflicts in task completion. Each task is evaluated for execution stability, speed, and system resource adaptability, and fitness is calculated based on this. The task with the highest fitness is selected as the final optimization result. The optimization result is the optimal call execution plan adjusted using optimization algorithms (such as genetic algorithms and particle swarm optimization). It includes the specific task execution sequence, timing arrangement, and resource allocation strategy to minimize resource conflicts between tasks and maximize execution efficiency.

[0045] Extract the specific content of the execution plan from the optimization results, such as the execution order of tasks, timing arrangements (such as start and end times), parallel execution task groups, and resource allocation strategies. For example, use a plan parsing module (which can be implemented in Python) to read and decode the optimization result file and generate the corresponding task execution instructions. Execute each task (i.e., the function of each Linglong package) according to the parsed optimization plan. For each task, execute the installation or update command, and simultaneously monitor the resource status to ensure that the execution process does not cause conflicts or resource overloads. Strictly enforce the timing and resource plan based on the optimization results to ensure that tasks are completed under ideal conditions. Through real-time monitoring and feedback mechanisms, identify and resolve problems in resource allocation and reduce waste of system resources.

[0046] Furthermore, the present application S400 includes:

[0047] The target package is determined by using the Linglong package call instruction, and the dependency graph is traversed through depth-first search to generate a complete dependency chain of the target package; the dependency depth of each package in the complete dependency chain is calculated, and the hierarchy is divided according to the dependency depth calculation result to generate a timing call plan; parallel call verification of the timing call plan is executed, and the timing collaborative call result is configured according to the parallel call verification result and the target package.

[0048] Specifically, the target Linglong package, or target package, is determined based on the Linglong package call instructions, which instruct the system to perform actions on the target Linglong package (such as installation, update, or uninstallation). Using the dependency graph, a depth-first search algorithm is used, starting from the target package, to traverse all its dependent packages to generate a complete dependency chain. Depth-first search is a graph traversal algorithm that prioritizes exploring nodes as far as possible along a path in the graph until it reaches a point where it cannot continue, then backtracking to the previous node to continue exploring unvisited branches. This algorithm is suitable for finding paths or chain-like structures, such as dependency chains. The specific process is as follows: Initialize a set to store visited nodes to avoid repeated visits. Define a recursive function, initialize the starting node, and mark it as visited; traverse the direct dependent packages (child nodes) of the current node; recursively call the recursive function to process the child nodes; and add the current node to the complete dependency chain. The recursive function is called to generate the dependency chain, starting from the target package.

[0049] For example, a dependency graph is A→B→D; A→C→E. The target package is A. The recursive function is called starting from A, traversing A's child nodes B and C. The recursive function is called on B, and it is found that B depends on D, so D is processed recursively. The recursive function is called on C, and it is found that C depends on E, so E is processed recursively. From the deepest D and E, it returns to B and C, and finally returns to the target package A. The final complete dependency chain is A→B→D→C→E.

[0050] Calculate the depth of the entire dependency chain, layer all packages according to the depth, and generate a sequential call plan. Dependency depth refers to the level of a package in the dependency chain, indicating the degree of indirect dependency of the package compared to the target package. The depth of the target package itself is 0, the depth of the directly dependent package is 1, and the depth of the dependent package is 2. According to the dependency depth of each package, the packages are assigned to different levels. Packages at different levels will be executed in sequence to ensure that the dependent package is executed before the package that depends on it. Define an initial depth for each package, and the target package depth is 0; traverse the dependency graph, and for each dependent package, the dependency depth is equal to the target package depth plus 1; recursively calculate the depth of each dependent package.

[0051] After the dependency depth is calculated, each package is grouped according to its depth value to form different hierarchies. Linglong packages will be called in hierarchical order, and packages with the same depth value can operate in parallel. Based on the hierarchical division, a sequential call plan is generated according to the order of the hierarchies. Packages within each layer can be executed in parallel, while packages between different layers need to be executed in depth order to ensure the correct dependency relationship. Starting from the deepest layer, calls are executed layer by layer; packages within each layer can be executed in parallel without depending on the execution order of other packages in the layer. The sequential call plan refers to the generation of a call sequence plan based on dependencies and depth after calculating the dependency depth of each package and performing hierarchical division, ensuring that packages are installed or uninstalled in order to avoid conflicts and dependency errors.

[0052] Following the hierarchy of the sequential call plan, starting from the deepest layer, the call operations are executed layer by layer. Packages at the same layer are operated in parallel, and their calls are verified to be successful. Parallel call verification refers to executing multiple call instructions simultaneously to verify their correctness and efficiency. Sequential collaborative call results refer to coordination and integration based on the execution order and results of the call instructions. A complete dependency chain is generated using depth-first search to ensure that package installation, update, and uninstall operations can correctly handle complex dependencies. Dependency depth calculation and hierarchical division are used to ensure that the package call sequence is logical, avoiding call failures due to sequence errors. Packages at the same level can operate in parallel, significantly shortening execution time and improving efficiency. Verification is performed after each call step to ensure the correctness of each package operation and reduce human intervention and errors.

[0053] Further, as attached Figure 2 As shown, this application S600 includes:

[0054] Based on the segmentation model, node segmentation of the timing collaborative call result is performed to establish a node segmentation result; using the node segmentation result to create a prediction window, using the prediction window to predict the timing state change based on the resource status monitoring result, and establishing a timing state change prediction result; according to the timing state change prediction result, the execution conflict risk factor is calculated, and the optimal fitting is performed based on the execution conflict risk factor to establish the optimal result.

[0055] Specifically, the results of time-series collaborative calls usually contain a series of package operation tasks with complex dependencies, and these tasks are coordinated and executed in chronological order. In order to manage and optimize these tasks more effectively, it is necessary to use a segmentation model to divide the tasks and convert them into nodes that can be processed independently. First, it is necessary to define how to divide the results of time-series collaborative calls. The segmentation rules are usually determined based on the dependencies between packages and resource requirements. According to the defined rules, the segmentation model divides the operation tasks in the results of time-series collaborative calls into multiple time nodes according to chronological order and resource requirements. Each node will contain a set of related operation tasks. During the segmentation process, it is also necessary to ensure that the operations of each node do not excessively occupy system resources. For example, when dividing nodes, if multiple operations within a node require a large amount of memory or CPU at the same time, these operations need to be divided into different nodes to avoid resource conflicts.

[0056] A partitioning model is an algorithm or method used to divide complex tasks or data into multiple smaller parts (nodes) based on specific rules. It is used to partition the results of a time-series collaborative call into multiple time nodes, each representing a specific package operation task. This allows large-scale operations to be rationally distributed across multiple time periods to avoid overloading system resources. The node partitioning result, processed by the partitioning model, is a set of operation nodes. These nodes are divided into different time periods based on timing and resource requirements, ensuring that operations within each node are coordinated and non-conflicting. After partitioning the results of a time-series collaborative call, the system generates a set of nodes, each containing multiple operation tasks. Each node requires analysis to ensure that tasks within the node do not conflict with each other during execution.

[0057] Node segmentation results are the result of segmentation, representing each segmented time series operation node. These nodes execute independently of other nodes, and the operation of each node is typically associated with a specific time period or resource usage. Detailed information about each node includes required resources (CPU, memory, disk, etc.), execution time, and involved packages.

[0058] Based on the node segmentation results, a period of time is selected as a prediction window. This focuses on operations and resource status changes within a specific time period, helping the system predict trends in system resources over future time periods. Historical system resource monitoring data, combined with current operation plans, is used to construct a prediction window and analyze resource usage patterns. The data within the window helps calculate resource trends and predict future resource status by fitting historical data.

[0059] Based on the created forecast window, you can predict resource status changes over a future period. Using the forecast window and historical resource status monitoring data, a time series analysis model is used to predict resource status trends over the future period. Based on the characteristics of the resource status, an appropriate time series forecasting model, such as a long short-term memory network or an ARIMA model, is selected. Historical resource status data within the forecast window is input into the forecast model to calculate resource usage over the future period. This generates resource status change trends within the forecast window, including CPU, memory, and other resource usage at each point in time.

[0060] Based on the results of the time series state change prediction, risks such as resource contention and task dependency conflicts are assessed, and the execution conflict risk factor for each node is determined. The final time series state change prediction result of each prediction window is used as the initial system state for the next prediction window. The conflict risk factors of the initial system state and the final time series state change results of the current prediction window are superimposed and calculated, and the superimposed result is used as the conflict risk factor for the current prediction window. The above steps are repeated for all prediction windows, and the conflict risk factor of each prediction window is used to determine whether optimization is necessary. The conflict risk factor represents the numerical value of resource conflict risk and is used to assess the degree to which system resource bottlenecks may occur during task execution.

[0061] If optimization is required, local optimization instructions are generated to reduce conflict risk factors while optimizing resource allocation and execution efficiency as the objective function. Resource allocation for conflicting nodes is optimized (for example, reducing CPU resource allocation). The execution order of nodes is reordered to avoid resource competition. An optimization algorithm (such as a genetic algorithm or a particle swarm algorithm) is used to perform a comprehensive fit of the states of all windows to find the global optimal solution. The optimal execution plan is determined based on the optimized fitness function value.

[0062] Optimal fit refers to optimizing and adjusting based on the evaluation results of execution conflict risk factors. By adjusting parameters such as execution timing and resource allocation, we can reduce conflict risks and ensure efficient resource use. By combining prediction and optimization, we can avoid resource bottlenecks and improve system stability. Through optimized task scheduling, we can reduce execution time and improve task completion efficiency. Dynamically adjust task resource allocation to maximize system resource utilization and reduce idleness or overload.

[0063] Furthermore, the present application further comprises the following steps:

[0064] The terminal time series state change prediction result of each prediction window is used as the initial system state of the next prediction window, and the conflict risk factor of the current prediction window is superimposed and calculated based on the conflict risk factors of the initial system state and the terminal time series state change result, and the superimposed calculation result is used as the conflict risk factor of the current prediction window; after traversing all the prediction windows, all the calculated conflict risk factors are used to perform risk discrimination factor by factor, and the risk discrimination result is used to perform call optimization of the time series collaborative call result to establish the optimization result.

[0065] Specifically, for each prediction window, we extract the predicted results for the end-of-term time series state change, i.e., the resource usage status at the end of that window, including CPU utilization and memory usage. The resource status at the end of the prediction window is used as the initial state for the next window, ensuring temporal coherence and consistency, and ensuring that resource state changes are continuous during the calculation of multiple consecutive prediction windows. The conflict risk factor is an indicator used to measure the probability or impact of system resource overload, conflict, or the likelihood of conflict within a specific time window. It typically considers factors such as the overlap of multiple resource demands and the concurrent execution of tasks.

[0066] The conflict risk factor for the current window is calculated by combining the conflict risk factors of the initial system state (i.e., the end state of the previous window) and the state change results of the end time series. Specifically, the conflict risk factor of the current window is combined with the conflict risk factor at the end of the previous window for cumulative analysis. Through weighted superposition, if certain windows have a greater impact on the system due to resource conflicts, these windows can be given higher weights. Superposition calculation combines the conflict risk factor of each forecast window with the results of the previous window for cumulative analysis, forming a risk assessment for consecutive time periods. Repeat the above steps for each forecast window to calculate the conflict risk factor for each window.

[0067] Perform risk assessment on each conflict risk factor, and determine whether resources may be overloaded or conflict based on the conflict risk factor. Pre-set a factor threshold based on the system's resource capacity, usage scenarios, and expected load conditions. Compare all conflict risk factors obtained from all prediction windows with the factor threshold to obtain a risk assessment result. If the risk assessment result is lower than the factor threshold, it is considered that the system resource allocation is within a safe range and no adjustment is required. The original timing coordination call result is retained, that is, execution continues according to the current resource scheduling. Conversely, if the conflict risk factor of a window is greater than or equal to the threshold, the optimization requirement is triggered. Based on the local optimization instructions, analyze which tasks need to be adjusted and which resources need to be reallocated to reduce resource conflicts.

[0068] The optimization call is executed through local optimization instructions. The fitness of each solution obtained is evaluated, and the solution with the highest fitness is ultimately selected as the optimization result. The optimized result is the optimization result, which includes the adjusted task execution plan and resource allocation plan. It can effectively reduce the probability of resource conflicts and improve system resource utilization and stability. By superimposing and identifying conflict risk factors for each prediction window, an optimized solution for the time-series collaborative call results is ultimately generated. This helps the system identify and resolve potential resource conflicts in advance, avoid system overload, optimize resource allocation, and improve overall system performance and reliability.

[0069] Furthermore, the present application further comprises the following steps:

[0070] Configure the factor threshold, use the factor threshold to trigger and identify all conflicting risk factors, and establish the risk identification result; if the risk identification result is lower than the factor threshold, retain the timing coordination call result of the corresponding position; if the risk identification result is higher than or equal to the factor threshold, generate a local optimization instruction, execute the call optimization according to the local optimization instruction, and generate the optimization result.

[0071] Specifically, the factor threshold is configured based on the system's resource capacity, usage scenarios, and expected load conditions. The factor threshold is a preset standard value used to assess the severity of system resource conflicts. When the conflict risk factor is higher than or equal to the threshold, it indicates that the system is in a potential overload or risk state, and measures need to be taken to optimize or adjust it. The conflict risk factor of each forecast window is compared with the pre-set factor threshold to determine the risk status of each forecast window. Trigger identification is the process of evaluating the conflict risk factor. By comparing it with the factor threshold, it identifies which time windows require risk factors to take measures (such as adjusting the system configuration, performing optimization, etc.). The risk identification result refers to the result generated by comparing the conflict risk factor with the factor threshold, including being lower than the factor threshold or higher than or equal to the factor threshold.

[0072] If the conflict risk factor is lower than the factor threshold, that is, the risk judgment result is lower than the factor threshold, then the system resource allocation is considered to be within a safe range and no adjustment is required. At this time, the original timing coordination call result is retained, that is, execution continues according to the current resource scheduling.

[0073] If the conflict risk factor for a window is greater than or equal to the threshold—that is, if the risk assessment result is higher than or equal to the factor threshold—an optimization requirement is triggered. The system then generates a local optimization instruction, executes the optimization process, adjusts task scheduling or resource allocation, and optimizes system operation. A local optimization instruction is generated based on specific conditions and performs local optimization for a specific time window or task. Local optimization typically aims to alleviate system pressure and adjust task scheduling to avoid resource conflicts.

[0074] Establish optimization objectives, such as ensuring task execution efficiency while reducing conflict risk factors. Multi-objective optimization can be employed, incorporating risk factors, task execution resource costs, task completion stability, maximum allowable system resource consumption, and minimum task stability requirements as objective functions. Determine a list of tasks to be optimized. Reallocate resources within the task execution environment, lowering the priority of tasks with high conflict risk or reducing their resource usage. Adjust the order of task execution to avoid running high-risk tasks concurrently with other resource-intensive tasks. Optimize specific task execution operations, such as changing algorithms and optimizing execution paths, ultimately generating multiple task execution plans. Use a fitness function to evaluate each task execution plan and select the optimal one.

[0075] Based on local optimization instructions, it analyzes which tasks require adjustment and which resources require reallocation, thereby reducing resource conflicts. Call optimization refers to the optimization process that adjusts task execution order and resource allocation based on the results of the fitness function to improve task execution efficiency, stability, and resource utilization. By comparing with factor thresholds, it accurately identifies and distinguishes high-risk and low-risk windows, ensuring targeted optimization measures and timely adjustments to task scheduling and resource allocation, avoiding system crashes or performance bottlenecks under high load, and enhancing system stability and reliability.

[0076] Furthermore, the present application further comprises the following steps:

[0077] Configure the execution stability feature and use the execution stability feature as the first evaluation feature; configure the speed evaluation feature and use the speed evaluation feature as the second evaluation feature; configure the system resource adaptation evaluation feature and use the system resource adaptation evaluation feature as the third evaluation feature; construct a fitness function based on the first evaluation feature, the second evaluation feature, and the third evaluation feature, and use the fitness function to complete call optimization.

[0078] Specifically, we configure execution stability features, which measure the reliability and stability of the system during task execution. These typically include task failure rate, execution error frequency, and the fluctuation range of task execution time, reflecting the robustness of the system's operation. This involves extracting stability metrics from task execution logs, such as task failure rate, error rate, and stability of task execution time. We use execution stability as the first evaluation feature.

[0079] Configure speed evaluation features, which measure the speed or efficiency of task execution. These include task response time, completion time, or average execution time. These features are used to measure the system's efficiency in completing tasks. Select and set metrics that reflect execution speed, such as execution time and response time, and use the speed evaluation feature as the secondary evaluation feature.

[0080] The configuration system resource adaptation evaluation feature, which measures the rationality and efficiency of resource allocation during task execution, includes the utilization and adaptability of resources such as CPU, memory, and I / O, reflecting whether the system is effectively utilizing available resources. By monitoring CPU, memory, and network bandwidth utilization and combining resource allocation with the adaptability of resource utilization, the system resource adaptation evaluation feature is used as the third evaluation feature.

[0081] The fitness function is a functional model that integrates the three aforementioned characteristics and is used to evaluate overall performance. It can take the form of a weighted sum model, a linear regression model, or a machine learning model. For example, based on the importance of execution stability, speed evaluation, and system resource adaptation evaluation, weights are assigned to each evaluation characteristic, determining their respective weights. Based on the relationship between each evaluation characteristic's weight and its corresponding evaluation characteristic, a fitness function is constructed. The fitness function can be optimized using a genetic algorithm, particle swarm optimization algorithm, or a greedy algorithm to select the task execution solution with the highest fitness.

[0082] Each execution task is evaluated for execution stability, speed, and system resource adaptability, generating corresponding evaluation characteristic values. The fitness value of each task is calculated based on the fitness function and ranked from high to low. Based on the fitness function results, the execution order or resource allocation scheme with the highest fitness value is selected to optimize overall system performance. By comprehensively evaluating execution stability, speed, and resource adaptability, the system can achieve multi-objective optimization and improve task execution efficiency.

[0083] Furthermore, the present application further comprises the following steps:

[0084] The optimization result is used to control the execution of the Linglong package and generate an execution monitor; an execution verification is performed based on the execution monitor and the optimization result, and an execution exception is established; and the execution exception is reported as an exception.

[0085] Specifically, according to the task sequence and resource allocation plan in the optimization result, the corresponding Linglong package is executed step by step. The execution status of the task is recorded in real time, including the task start time, end time, resource utilization (such as CPU, memory, disk I / O, etc.) and any possible abnormal events (such as timeouts). The execution monitoring data is compared with the optimization result plan one by one to calculate the execution deviation (such as time delay, resource excess, etc.). For example, assuming that the execution time of task A in the plan is 2 seconds, but the actual time is 3 seconds, it is judged to be a timeout. Among the deviations found by comparison and verification, the part that exceeds the predefined threshold is judged as an anomaly, and the anomaly record is sent to the management system or user end. For example, if the CPU utilization exceeds the plan by more than 10% or the task timeout exceeds 2 seconds, an alarm is triggered.

[0086] Execution anomalies are notified to relevant personnel through an alert system via email, text message, sound, or color, allowing for timely resolution. Exception reports are also generated and stored for problem diagnosis and resolution. Optimization results serve as the basis for execution, ensuring tasks are executed according to the planned sequence and resource allocation, reducing errors caused by human intervention. The monitoring module provides real-time visibility into task execution status and resource usage, enabling timely identification and location of execution issues and shortening response time.

[0087] In summary, the graphical Linglong package management method provided by this application has the following technical effects:

[0088] By performing a deep analysis of the Linglong package, deep features are extracted based on the deep analysis results; the deep features are used to perform dependency analysis between Linglong packages and establish a dependency graph; the graphical interaction interface of the Linglong package is configured, and interaction information of the graphical interaction interface is obtained, wherein the interaction information is the user's operation information based on the graphical interaction interface; a Linglong package call instruction is generated based on the interaction information, and a collaborative operation analysis based on the dependency graph is performed based on the Linglong package call instruction, and a timing collaborative call result is configured; a system resource monitoring instruction is synchronously generated based on the Linglong package call instruction, and the system resource status is monitored in real time based on the system resource monitoring instruction, and a system resource status monitoring result is established; the timing collaborative call result and the system resource status monitoring result are used to optimize the call control of the Linglong package and generate an optimization result; the Linglong package is managed based on the optimization result. In other words, by deeply analyzing the Linglong package to extract deep features, build a dependency graph, and clarify the interdependence between packages; configure a graphical interactive interface and obtain interaction information, perform collaborative operation analysis based on the dependency graph and user interaction information, and at the same time, monitor system resource usage, and perform call control optimization based on the timing collaborative call results and system resource status monitoring results, thereby improving the efficiency of graphical Linglong package management.

[0089] The above description of the disclosed embodiments is intended to enable one skilled in the art to implement or use the present application. Various modifications to these embodiments will be readily apparent to one skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present application. Therefore, the present application is not limited to the embodiments shown herein, but is intended to conform to the widest scope consistent with the principles and novel features disclosed herein.

[0090] Obviously, those skilled in the art may make various changes and modifications to the present application without departing from the spirit and scope of the present application. Thus, if these modifications and variations of the present application fall within the scope of the present application and its equivalents, the present application is intended to include these modifications and variations.

Claims

1. A graphical Linglong package management method, characterized in that: include: Perform deep analysis on Linglong package and extract deep features based on the results; Using the deep features to perform dependency analysis between Linglong packages and establish a dependency graph; Configuring the graphical interaction interface of Linglong Package and obtaining interaction information of the graphical interaction interface, wherein the interaction information is operation information of the user based on the graphical interaction interface; Generate a Linglong package call instruction according to the interaction information, perform collaborative operation analysis based on the dependency graph based on the Linglong package call instruction, and configure a timing collaborative call result; Synchronously generate a system resource monitoring instruction according to the Linglong package call instruction, perform real-time monitoring of the system resource status according to the system resource monitoring instruction, and establish a system resource status monitoring result; Utilizing the timing coordination call result and the system resource status monitoring result to optimize the call control of the Linglong package and generate an optimization result; Perform Linglong package management based on the optimization results; The method comprises: performing node segmentation of the time series collaborative call result based on a segmentation model, and establishing a node segmentation result; creating a prediction window using the node segmentation result, and using the prediction window to predict the time series state change based on the resource state monitoring result, and establishing a time series state change prediction result; calculating an execution conflict risk factor according to the time series state change prediction result, performing optimal fitting based on the execution conflict risk factor, and establishing the optimal result; using the end time series state change prediction result of each prediction window as the initial system state of the next prediction window, and performing a superposition calculation of the conflict risk factor of the current prediction window based on the conflict risk factor of the initial system state and the end time series state change result, and using the superposition calculation result as the conflict risk factor of the current prediction window; The calling optimization is executed according to the local optimization instruction to generate the optimization result, including: configuring an execution stability feature, and using the execution stability feature as a first evaluation feature; configuring a speed evaluation feature, and using the speed evaluation feature as a second evaluation feature; Configuring a system resource adaptation evaluation feature, and using the system resource adaptation evaluation feature as a third evaluation feature; A fitness function is constructed according to the first evaluation feature, the second evaluation feature, and the third evaluation feature, and the call optimization is completed using the fitness function.

2. A graphical Linglong package management method as claimed in claim 1, characterized in that: The deep analysis of the Linglong package and the extraction of deep features based on the deep analysis results include: Obtaining a call record of the Linglong package, performing a Linglong package association analysis based on the call record, and establishing a first association; Performing data analysis on each Linglong package, performing similarity calculation using the data analysis results, and establishing a second association, wherein the similarity calculation includes feature similarity calculation, function similarity calculation, and behavior similarity calculation; Based on the first association and the second association, the dependency depth and dependency breadth of Linglong Baoji are analyzed to extract deep features.

3. A graphical Linglong package management method as claimed in claim 1, characterized in that: The step of performing collaborative operation analysis based on the dependency graph based on the Linglong package call instruction and configuring the timing collaborative call result includes: Determine the target package using the Linglong package call instruction, and traverse the dependency graph through a depth-first search to generate a complete dependency chain of the target package; Calculate the dependency depth of each package in the complete dependency chain, divide the layers according to the dependency depth calculation results, and generate a timing call plan; Execute parallel call verification of the timing call plan, and configure the timing collaborative call result according to the parallel call verification result and the target package.

4. A graphical Linglong package management method according to claim 1, characterized in that: The calculating the execution conflict risk factor according to the time series state change prediction result, performing optimization fitting based on the execution conflict risk factor, and establishing the optimization result includes: After traversing all the prediction windows, all the calculated conflict risk factors are used to perform risk identification factor by factor, and the risk identification results are used to perform call optimization of the time series collaborative call results to establish the optimization results.

5. A graphical Linglong package management method as claimed in claim 1, characterized in that: The graphical Linglong package management method further includes: Using the optimization result to control the execution of Linglong package and generate execution monitoring; Performing execution verification based on the execution monitoring and the optimization result, and establishing execution exceptions; The execution exception is reported as an exception.

Images