A game software running control method and system

Abstract

The application relates to the technical field of data processing, and discloses a game software running control method and system. The method comprises the following steps: collecting game running monitoring data through a system-level hook; calculating a risk assessment value based on a dynamic weight adjustment algorithm; generating hierarchical control instructions by using a game behavior sequence intelligent control algorithm; obtaining a control scheme by collaborative scheduling through a dependency relationship diagram; and obtaining strategy parameter configuration by quantitatively processing control effect evaluation indexes. The application improves the accuracy of game software running control and the user experience protection effect.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of data processing, and in particular to a game software running control method and system. BACKGROUND

[0002] The existing game software running control method mainly adopts a static control strategy based on process monitoring, and realizes the running management of the game software by identifying the game process name or window title. The traditional control method usually sets a fixed time threshold or resource usage limit, and when it is detected that the running time of the game software exceeds the preset value or the system resource occupation is too high, the process is paused or terminated for control. This kind of method is widely used in Internet cafe management system, parental control software and enterprise IT management, and can realize the basic management and control of the running state of the game software to a certain extent.

[0003] However, the static control strategy cannot adapt to the differences in running characteristics of different types of game software, resulting in low control accuracy and frequent false control. Secondly, the coarse-grained control method based on the process level ignores the complex dependency relationship between the internal functional components of the game software, which is easy to cause inconsistent game state and loss of user experience. Thirdly, it lacks intelligent analysis and prediction ability of the game running behavior sequence, and cannot realize active abnormal behavior prediction and fine-grained control.

[0004] The problem of the prior art is the lack of deep understanding and dynamic adaptation ability of the running state of the game software. Since the game software has high interactivity and real-time characteristics, its running state will be dynamically adjusted with the changes of game content, user operation and system environment, and the traditional static control strategy cannot capture this dynamic change rule. Further analysis shows that there are complex functional dependency relationships and resource competition mechanisms inside the game software, and simple process-level control cannot accurately locate the control target, resulting in poor control effect. Therefore, it is urgent to establish a game software running control method that can realize real-time perception of the game running state, intelligent prediction of behavior trends and accurate implementation of collaborative control. SUMMARY

[0005] The present application provides a game software running control method and system, which solves the problems of the existing game software running control method that the static control strategy cannot adapt to the dynamic running characteristics of the game and lacks fine-grained collaborative control ability, and improves the accuracy of game software running control and the effect of user experience protection.

[0006] In a first aspect, the present application provides a game software running control method, which comprises:

[0007] The game software is processed by the system-level hook for state collection, and running monitoring data is obtained;

[0008] According to the operation monitoring data, a risk assessment function is processed by a dynamic weight adjustment algorithm to obtain a risk assessment value;

[0009] The risk assessment value is processed by a game behavior sequence intelligent control algorithm to obtain a hierarchical control instruction;

[0010] According to the hierarchical control instruction, a collaborative scheduling process is performed on the dependency graph to obtain a control scheme;

[0011] The control scheme is processed by a control effect evaluation index to obtain a strategy parameter configuration.

[0012] In a second aspect, the application provides a game software operation control system, which comprises:

[0013] A collection module is configured to perform state collection processing on the game software by a system-level hook to obtain operation monitoring data;

[0014] A calculation module is configured to perform weight calculation processing on a risk assessment function by a dynamic weight adjustment algorithm according to the operation monitoring data to obtain a risk assessment value;

[0015] A prediction module is configured to perform sequence prediction processing on the risk assessment value by a game behavior sequence intelligent control algorithm to obtain a hierarchical control instruction;

[0016] A scheduling module is configured to perform collaborative scheduling processing on a dependency graph according to the hierarchical control instruction to obtain a control scheme;

[0017] A quantification module is configured to perform effect quantification processing on the control scheme by a control effect evaluation index to obtain a strategy parameter configuration.

[0018] In a third aspect, a game software operation control device is provided, which comprises a memory and at least one processor, the memory storing instructions; the at least one processor invokes the instructions in the memory to enable the game software operation control device to perform the game software operation control method described above.

[0019] In a fourth aspect, a computer readable storage medium is provided, which stores instructions; when the instructions are run on a computer, the computer performs the game software operation control method described above.

[0020] In the technical scheme provided in the application, the system-level hook is used to collect and process the state of the game software to obtain the running monitoring data. Compared with the traditional process name recognition method, the fine running information such as CPU usage, memory occupation and state transition event can be obtained in the game engine, which fundamentally solves the problems of rough monitoring data and low recognition accuracy in the prior art. The dynamic weight adjustment algorithm calculates and processes the weight of the risk assessment function, and adjusts the weight coefficient of the game type adaptively, which overcomes the limitations of the static threshold judgment method, so that the risk assessment value can accurately reflect the running risk characteristics of different types of games. The game behavior sequence intelligent control algorithm generates hierarchical control instructions through sequence prediction processing, predicts the game behavior trend by using a hidden Markov model, and formulates a four-level control strategy. Compared with the traditional binary control method, the technical leap from extensive control to fine intelligent control is realized. The collaborative scheduling processing of the dependency graph analyzes the calling relationship and data flow among the internal components of the game through a directed acyclic graph structure, solves the control conflict problem caused by the lack of collaboration in the prior art, and ensures the systematicness and consistency of the control operation.

[0021] The control effect evaluation index is quantitatively processed to obtain the strategy parameter configuration, a comprehensive evaluation system including control success rate, performance retention rate and user experience satisfaction is established, and the parameters are continuously optimized through the reinforcement learning algorithm, forming a complete closed-loop control mechanism. Especially in the specific application field of game software running control, the organic combination of the dynamic weight adjustment algorithm and the game behavior sequence intelligent control algorithm enables the system to adjust the personalized control strategy according to the running characteristics of different game types such as MOBA, FPS and RPG, and the adaptive characteristics of the algorithm significantly improve the applicability and stability of the control scheme in complex game environments. The deep integration of the system-level hook technology and the collaborative scheduling of the dependency graph enables the control operation to be accurately positioned to specific game function components, avoiding the loss of user experience caused by the one-size-fits-all control in the traditional method. BRIEF DESCRIPTION OF DRAWINGS

[0022] In order to more clearly illustrate the technical scheme of the embodiments of the application, the following will briefly introduce the drawings needed in the embodiment description. Obviously, the drawings in the following description are some embodiments of the application, and those skilled in the art can obtain other drawings based on these drawings without creative labor.

[0023] Figure 1 An embodiment of the game software running control method in the embodiment of the application is shown in the figure;

[0024] Figure 2 An embodiment of the game software running control system in the embodiment of the application is shown in the figure;

[0025] Figure 3 is a structural schematic block diagram of a game software running control device in an embodiment of the present application. DETAILED DESCRIPTION

[0026] The embodiments of the present application provide a game software running control method and system. The terms "first", "second", "third", "fourth" and the like (if any) in the specification and claims of the present application and the above-described drawings are used to distinguish similar objects, and do not have to be used to describe a particular order or sequence. It should be understood that the data thus used can be interchanged under appropriate circumstances, so that the embodiments described herein can be implemented in an order other than that illustrated or described herein. In addition, the terms "include" or "have" and any variations thereof are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device that includes a series of steps or units does not have to be limited to only those steps or units clearly listed, but can include other steps or units not clearly listed or inherent to the process, method, product or device.

[0027] For ease of understanding, the specific flow of the embodiments of the present application is described below. Please refer to Figure 1 One embodiment of the game software running control method in the embodiments of the present application includes:

[0028] Step S101, performing state collection processing on the game software through a system-level hook, to obtain running monitoring data.

[0029] It can be understood that the execution subject of the present application can be a game software running control system, and can also be a terminal or a server, and the specific execution subject is not limited herein. The embodiments of the present application take the server as an example for description.

[0030] Specifically, various data during game running can be obtained in real time through the system-level hook technology, and a series of processing and analysis are performed on these data, so as to realize the monitoring and optimization of the game state. The hook is an interface provided by the operating system, which enables the program to intercept the messages or events of the operating system at a specified time. In this application, the hook is usually used to monitor and collect the running data of the game.

[0031] The working principle of the system-level hook is based on the event-driven mode. It is inserted into the message queue of the operating system when the game process runs, and captures various state changes of the game software. The data captured by the hook can include but is not limited to the frame rate of the game, the usage rate of CPU and GPU, memory consumption, input events (such as mouse clicks, keyboard presses), etc. In this way, the hook can obtain the relevant data of the game in real time without interfering with the normal running of the game.

[0032] The raw data collected will be passed to the data processing module, which is mainly responsible for filtering, filtering and preliminary conversion of data. During data collection, there may be a large amount of redundant information or noise, so it must be effectively processed. For example, in the case of game frame rate, the rendering time, calculation process, etc. of each frame will be recorded during data collection, and the system will filter important frame data according to the set conditions (such as sampling frequency, threshold, etc.) to avoid meaningless repeated data.

[0033] The processed data will be further analyzed by algorithms to obtain the performance indicators of the game. For example, the frame rate data of the game after processing can be used to evaluate the current running performance. If the frame rate data shows large fluctuations, it may mean that the CPU or GPU is overloaded, at which time the system will automatically adjust the game settings to reduce the graphics quality or resolution to ensure smooth operation of the game. At the same time, by comparing the usage rate of CPU and GPU with the frame rate, the performance bottleneck can be found, and the game running can be optimized.

[0034] Memory consumption is another key monitoring data, and the system captures memory usage in real time through hooks. During the running of different games, memory allocation and recycling will directly affect the smoothness and stability of the game. In the data processing process, memory usage data will be recorded with timestamps to ensure that the memory state at each moment can be accurately tracked. Through algorithms, the system can analyze the memory allocation in different game scenarios, identify the links that may cause memory leaks, and provide corresponding repair suggestions to avoid stuttering or crashing after a long time of running.

[0035] For the processing of input events, hooks can also capture user interaction behavior, such as mouse click position, keyboard key, etc. These data will be recorded in real time and used to analyze user operation habits, behavior patterns, and even used for cheating detection. In the data processing stage, these input events will be classified and processed according to their timing and type, and the system can analyze the smoothness of user operation and optimize user experience according to different operation scenarios. For example, in fast reaction games, the system can adjust the delay of input response according to the frequency and accuracy of user keystrokes to ensure the immediacy and accuracy of operation.

[0036] In the process of data processing, all captured data will eventually be organized into a complete performance report, which contains the trend of various indicators and is visually displayed through charts and graphs for developers and users to reference. The collection and processing of these data not only help optimize game performance, but also provide data support for subsequent game tuning, ensuring that the game can run stably on various hardware environments. At the same time, the real-time data collection and processing mechanism of the hook provides a powerful monitoring platform for game developers, enabling them to quickly respond to any abnormalities in game operation and ensure the sustained and healthy operation of the game.

[0037] Step S102, according to the running monitoring data, the risk assessment function is calculated by dynamic weight adjustment algorithm, and the risk assessment value is obtained;

[0038] Specifically, in the process of dynamically adjusting the weights of the risk assessment function according to the running monitoring data and calculating the risk assessment value, the integrated monitoring data is processed using a dynamic weight adjustment algorithm to obtain the risk assessment. The core of this process is data collection, weight adjustment, and risk assessment function calculation. The data comes from monitoring indicators in the system, such as frame rate during game software running, CPU and GPU usage, memory consumption, and user input response time, etc. Different monitoring data corresponds to different risk dimensions, such as system load, performance bottleneck, memory pressure, and user operation delay, etc. Through these monitoring data, the risk assessment function needs to assign appropriate weights to each risk, and after dynamically adjusting these weights, the comprehensive risk assessment value is calculated. Real-time running data is obtained from the game process. These data include frame rate, CPU and GPU usage, memory consumption, and other performance indicators, as well as input events such as user operation frequency and response time, etc. These raw data will be captured and transmitted through the hook system, and each data will be recorded and classified. In order to ensure the accuracy and completeness of the data, the collected data will be preliminarily cleaned and screened to remove noise and unnecessary duplicate data.

[0039] After data cleaning, the system enters the weight calculation and risk assessment phase. According to the nature of the monitoring data, different data items will have different effects on the risk assessment function. For example, frame rate and CPU usage data reflect the performance load of the game, memory consumption is related to resource management and system stability, and input response directly affects user experience. In order to reasonably integrate these data in the risk assessment function, the system needs to assign a dynamic weight to each item of data. The allocation of weights is based on the current running state of the system and the importance of the data. For example, in the high load state of the game, the weight of CPU usage will be relatively high, because at this time the CPU load may become a performance bottleneck. And in the case of long running time of the game, the weight of memory consumption will increase, because memory leakage problems may affect the long-term stability of the system.

[0040] According to the real-time data monitoring results, the current risk contribution of each data point is evaluated. If the change trend of an indicator shows abnormality (for example, CPU usage exceeds the preset threshold), the weight of the indicator will increase, indicating that the indicator contributes more to risk assessment; on the contrary, if the change of a certain indicator tends to be stable and no longer causes obvious risk, the weight of the indicator will decrease. This process needs to adjust the weight value through real-time feedback mechanism to ensure that in different running states, the risk assessment function can accurately reflect the health status of the system. When all the weight calculations are completed, the weighted values of each monitoring data will be calculated according to the dynamically adjusted weight values, and a comprehensive risk assessment value will be calculated. The risk assessment function multiplies each data with the corresponding dynamic weight, and then adds up these weighted data to get a total risk assessment value. This value represents the overall risk level of the current system, and the higher the value, the greater the risk of the system, which may need to take optimization measures, such as reducing the graphics quality, releasing memory or adjusting the game settings.

[0041] Step S103, the risk assessment value is processed by the game behavior sequence intelligent control algorithm for sequence prediction to obtain hierarchical control instructions;

[0042] Specifically, in the process of implementing the risk assessment value through the game behavior sequence intelligent control algorithm for sequence prediction processing, and obtaining hierarchical control instructions, the key task is to predict the future behavior of the game system based on the current risk assessment value, and generate corresponding control instructions through these predictions. The core of this process is through the step-by-step processing, modeling and algorithm optimization of data, ultimately providing accurate hierarchical control instructions for the system, enabling the game to automatically adjust its state according to real-time assessment results, thereby ensuring a smooth gaming experience. Through the previous risk assessment value as input, this value is derived based on running monitoring data through a dynamic weight adjustment algorithm. The risk assessment value reflects the overall health of the current game running state, such as system load, memory usage, frame rate, input delay, etc. This assessment value provides a comprehensive perspective of the current state of the game system and provides necessary references for predicting the next operation of the system.

[0043] Once the risk assessment value is generated, the next step is to enter the intelligent control algorithm for behavior sequence, which is responsible for predicting the changes that may occur in the game in the next few time steps based on historical game behavior data and the current risk assessment using machine learning or deep learning models. By learning the relationship between game behavior and performance indicators in historical data, the system can identify potential links between different risk assessment values and game behavior. For example, when the risk assessment value of the system is high, it may mean that the system is facing a large load, at which point the game may need to reduce graphics quality or adjust other configurations; conversely, when the assessment value is low, the game can perform more complex graphics rendering or other computationally intensive operations.

[0044] These historical data include but are not limited to game frame rate changes, CPU and GPU load, memory usage, etc., which are organized in a time series manner to form a sequence of game behavior data. This sequence data is obtained by monitoring and recording the running status of the game, providing a basis for subsequent prediction. The intelligent control algorithm will use these historical behavior data and the current risk assessment value to train the model to accurately predict the next behavior of the system.

[0045] The goal of the intelligent control algorithm is to analyze the trends of historical data and identify control actions related to risk assessment values. The model learns through training these data that when a particular risk assessment value appears, the system should take what kind of adjustment measures. For example, when the risk assessment value shows that the system is under a lot of pressure, the model may predict that the graphics quality should be reduced to reduce resource consumption; when the risk assessment value is low, the system can adopt a more aggressive graphics rendering strategy to improve the user's visual experience.

[0046] Through this intelligent control algorithm, the system will generate a series of hierarchical control instructions that will gradually guide the adjustment of game behavior based on the prediction results. These control instructions usually include different levels of operations, such as when the system load is high, the first level of instructions may be to simply reduce the resolution or turn off certain special effects; the second level of control instructions may be more detailed graphics optimization or reallocation of system resources; and the third level of control instructions may involve more in-depth algorithm optimization, or even adjusting the way the game runs to adapt to different hardware environments. Each level of control instruction is dynamically generated based on the predicted risk assessment value and behavior sequence.

[0047] These control instructions are closely related to the real-time state of the game and can effectively ensure smooth operation of the game. The system predicts the future behavior of the game through an intelligent control algorithm and processes the control instructions in layers according to the risk assessment value, ensuring that the game can respond in time when the load is high, avoiding situations such as lag, crashes, or unsmoothness. In this case, the control instructions are not just single operations, but are adjusted step by step according to different game needs, hardware environments, and user experience needs, ensuring that each instruction can adjust the system state specifically. It can automatically adjust the game state according to the real-time risk assessment, providing a smooth and dynamic user experience. The system not only copes with the current high load, but also predicts future risks and prepares in advance, ensuring that the game can achieve optimal performance in different running environments. This method of sequence prediction and hierarchical control instruction generation through behavior sequence intelligent control algorithm provides strong support for the intelligent regulation of game systems.

[0048] Step S104, performing collaborative scheduling processing on the dependency graph according to the hierarchical control instructions to obtain a control scheme;

[0049] Specifically, in the process of collaborative scheduling of the dependency graph according to the hierarchical control instructions, the key goal is to generate an efficient and coordinated control scheme by analyzing the hierarchical control instructions and the dependency graph in the system. The dependency graph refers to the visualization of the interdependence between various operations, resources, and tasks during the running of a complex game or system. It shows the logical relationship between tasks, resources, and events and their execution order. In this context, the core of collaborative scheduling is to ensure that each control instruction can be executed in order according to the constraints in the dependency graph, thereby optimizing system performance and avoiding conflicts. In the early stages of data processing, the system will guide the scheduling process through hierarchical control instructions. These control instructions are generated by intelligent control algorithms and reflect the optimization objectives of the system under a given risk assessment value. Each control instruction represents a possible system adjustment action, covering multiple levels of strategies, such as reducing graphics load, adjusting memory allocation, or changing CPU / GPU scheduling, etc. Each control instruction needs to be dynamically scheduled according to the real-time state of the system to ensure that each adjustment measure can work collaboratively and avoid resource contention or mutual interference.

[0050] In the process of constructing the dependency graph, the system identifies the dependencies between various tasks, operations, and resources and converts them into nodes and edges in the graph. Each node represents a task or resource, and the edge represents the dependency between tasks. For example, there may be a node representing "graphics rendering" and another node representing "memory release" in the graph, and there is a dependency between them, i.e., memory release must be performed before graphics rendering. Each edge in the dependency graph carries the order information of task execution, which will guide subsequent scheduling decisions.

[0051] In the collaborative scheduling process, the system will analyze the dependency graph according to the hierarchical control instructions, combined with the current running state of the system, to determine which operations to execute first, which operations to delay or optimize. Specifically, the system sorts the dependency graph by analyzing the priority specified in the current control instruction. According to these priorities, the system will find the critical path in the graph, i.e., the core tasks that affect the overall performance of the system, to ensure that these critical tasks are given priority in scheduling and execution.

[0052] By coordinating the scheduling of the dependency graph, the system also needs to handle possible conflicts between multiple control instructions. For example, in some cases, graphics rendering and memory optimization may involve the use of the same resources, and their scheduling order may affect the final system performance. To avoid such conflicts, the system will use a scheduling algorithm to optimize the execution order of tasks, ensuring that the use of all resources complies with the constraints in the dependency graph, while maximizing the efficiency of resource utilization. The scheduling algorithm will automatically adjust the execution order of tasks based on factors such as the priority of control instructions, resource availability, and task execution time, avoiding resource contention and ensuring stable operation of the system. Collaborative scheduling is not just a simple task ordering, but through comprehensive consideration of the dependency relationship between tasks, resource demand and system load, a globally optimized control scheme is generated. This control scheme can ensure that the execution order of each task not only meets the dependency relationship, but also maximizes the idle time of system resources, improving the running efficiency of games or systems. For example, a task may require a large amount of memory, while another task requires CPU resources. The system will arrange the execution order of these two tasks according to the constraints in the dependency graph, ensuring that they do not interfere with each other, thereby balancing the use of CPU and memory.

[0053] When all task scheduling is completed, the system will generate a complete control scheme. This scheme contains the execution order of each control instruction and the required resource allocation method, which can ensure that the system runs smoothly and efficiently. The generated control scheme not only optimizes the performance of games or applications, but also maximizes resource utilization, reducing unnecessary computational load and system resource waste. In this way, collaborative scheduling processing effectively converts risk assessment and control instructions into specific operation schemes, ensuring that the system can adaptively optimize in complex running environments and provide a smooth user experience. By combining hierarchical control instructions with task scheduling in the dependency graph, the system can ensure that each operation is performed at the appropriate time when dealing with complex calculations and resource allocation, avoiding conflicts and improving overall efficiency. This process effectively converts theoretical risk assessment into practical operations and conducts comprehensive optimization at the system level.

[0054] Step S105, the control scheme is processed by the control effect evaluation index to obtain the strategy parameter configuration.

[0055] Specifically, in the process of quantifying the control scheme through the control effect evaluation index, the core task is to obtain specific strategy parameter configurations by evaluating the implementation effect of the scheme. This process quantifies the actual effect of the control strategy by combining the performance data of the game system and the execution results of the control scheme, and adjusts the strategy parameters according to the quantification results, thereby optimizing the overall performance of the system. The effect quantification of the control scheme not only requires capturing the running state of the system, but also needs to analyze these states in depth according to multiple control indicators, and finally obtain specific strategy parameter configurations for subsequent optimization and adjustment. The control scheme itself is obtained through the collaborative scheduling of the dependency graph, which contains a series of adjustment instructions aimed at improving the running effect of the game or enhancing the user experience. In order to test the effectiveness of these instructions, the system first needs to quantify the control scheme by setting a set of control effect evaluation indicators. Control effect evaluation indicators usually involve multiple dimensions, such as performance, stability, user experience, resource utilization, etc. Each indicator represents a certain aspect of the control scheme. Performance indicators may include frame rate, CPU usage, GPU load, etc., while user experience may be measured by response time, latency, input smoothness, etc.

[0056] In the process of quantification, the system first needs to collect data in real time after the game or application executes the control scheme. These data include the frame rate change of the game, resource consumption, system stability, input response time, etc. By monitoring these data in real time, the system can capture the impact of the control scheme on the system state and measure it through the preset control effect evaluation indicators. For example, if the frame rate is greatly improved after the implementation of the control scheme, it means that the control scheme effectively reduces the resource burden and improves the smoothness of the system; if the system load remains within an acceptable range and the memory consumption is low, it means that the control scheme has achieved good results in optimizing resource usage.

[0057] Through the analysis of the control effect evaluation indicators, the system can further explore the relationship between different control instructions. For example, the improvement of frame rate may have a direct relationship with the reduction of CPU and GPU load. The system can analyze whether a control instruction (such as reducing graphics quality) effectively reduces the computational pressure of the GPU, thereby improving overall performance. Similarly, the use of memory can also reflect the effect of the control scheme. If the memory consumption is low and stable, it means that the control scheme effectively optimizes resource allocation. The relationship between various evaluation indicators plays a crucial role in system analysis, helping the system to identify which control instructions have a positive impact and which may need to be adjusted or improved.

[0058] In this process, the relevance of data and feedback mechanisms play an important role. For example, the system may find that a certain policy parameter configuration (such as reducing the graphics resolution) can improve the frame rate within a certain range, but when the reduction is too large, the user experience will be affected, resulting in increased response delay. Therefore, the quantitative processing of control effect evaluation indicators is not just an analysis of a single indicator, but a comprehensive evaluation through multiple dimensions to determine the overall effectiveness of the control scheme. This multi-indicator, multi-dimensional data processing process requires the system to effectively balance the balance between various indicators.

[0059] The quantized control effect evaluation indicators will provide guidance for policy parameter configuration. Specifically, the system converts these quantitative results into parameter configurations for adjustment schemes through algorithms. For example, if the frame rate improvement meets expectations and the memory usage remains low, the system may increase the graphics quality settings to optimize the game picture; if the system stability is poor, resulting in lag or crashes, the resource allocation parameters in the control scheme may need to be further optimized to reduce the load of GPU or CPU. Through these quantitative analysis results, the system can adjust the policy parameter configuration in real time, thereby continuously optimizing the control scheme and improving the overall performance of the game. The quantitative processing of control effect not only helps developers evaluate the implementation effect of the control scheme, but also provides data support for subsequent scheme adjustment. Through quantitative analysis, the system can identify the advantages and disadvantages of the control strategy and adjust the policy parameters in a timely manner to ensure that the game can achieve the best performance and user experience under various hardware configurations and running environments. Through this method, the control scheme can achieve dynamic optimization and continuously adjust itself based on feedback data, ultimately providing an efficient and stable game running environment.

[0060] In a specific embodiment, the process of performing step S101 can specifically include the following steps:

[0061] Injecting a system-level hook into the game process for monitoring code deployment processing, obtaining a process communication channel;

[0062] Performing parameter acquisition processing on the game software based on the process communication channel, obtaining CPU usage and memory usage;

[0063] Performing analysis processing on state transitions based on internal events of the game engine, obtaining state transition events of level switching and character skill release;

[0064] Inputting the CPU usage, memory usage, and state transition events into a ring buffer for data storage processing, obtaining a set of time-sensitive data;

[0065] Performing game type identification processing on the set of time-sensitive data, obtaining running monitoring data.

[0066] Specifically, the system-level hook injection game process monitoring code deployment process is achieved by using the API interface provided by the operating system to dynamically inject the monitoring code into the memory space of the target game process. The hook program first creates a new thread in the game process through the CreateRemoteThread function, then allocates memory space in the target process using the VirtualAllocEx function, then writes the monitoring code into the allocated memory area through the WriteProcessMemory function, and finally establishes an inter-process communication channel. The communication channel uses the named pipe or shared memory method. The named pipe creates a server pipe through the CreateNamedPipe function, and the monitoring code in the game process acts as a client to connect the pipe through the ConnectNamedPipe function, thereby establishing a bidirectional data transmission channel.

[0067] Based on the established process communication channel, the monitoring code starts the parameter acquisition process for the game software. The CPU usage is obtained by calling the GetProcessTimes function to obtain the kernel mode time and user mode time of the process, and then calculating the ratio of the CPU time difference between two sampling intervals to the time interval. The memory usage is obtained by the GetProcessMemoryInfo function to obtain the working set size, page file usage and other memory indicators of the process, among which the working set size reflects the physical memory occupation and the page file usage reflects the virtual memory occupation. The monitoring code collects these data every fixed time interval and transmits the data to the control end through the process communication channel.

[0068] The state transition analysis process of the internal events of the game engine needs to deeply analyze the event system of the game engine. The monitoring code captures the state transition events by hooking the key functions of the game engine, including intercepting the LoadLevel function of the scene manager to detect the level switching event, and intercepting the ExecuteSkill function of the character controller to detect the skill release event. When detecting the function call, the monitoring code analyzes the function parameters to obtain the event details. The level switching event records the source level ID, target level ID and switching timestamp, and the character skill release event records the character ID, skill ID, release timestamp and skill duration. These event information is transmitted in the form of structured data through the communication channel.

[0069] The circular buffer data storage process uses a circular queue data structure to manage time-sensitive data. The buffer has a fixed size, and when new data arrives, it is written in chronological order to the buffer, and when the buffer is full, the oldest data is automatically overwritten. CPU usage, memory usage, and state transition event data are aligned according to a unified timestamp, and each data record contains a data type identifier, a timestamp, a data value, and a validity flag. The buffer uses separate read and write pointers, with the write pointer responsible for data writing and the read pointer responsible for data reading. The two pointers move independently to avoid data contention. After data is written to the buffer, the system sets an expiration time based on the data's time sensitivity requirements, and data that exceeds the expiration time is automatically marked as invalid.

[0070] The game type recognition process is achieved by analyzing the feature patterns in the time-sensitive data set. Different types of games have different resource usage patterns. First-person shooter games typically have large fluctuations in CPU usage, relatively stable memory usage, and frequent state transition events. Real-time strategy games have a high CPU usage, increasing memory usage as the game progresses, and state transition events concentrated in specific time periods. The recognition algorithm first calculates the variance of CPU usage, the growth trend of memory usage, and the frequency distribution of state transition events in the data set, and then matches these feature values with a pre-set game type feature library. The feature library stores the standard feature value ranges for various game types, and the matching process uses Euclidean distance to calculate similarity. The game type with the smallest distance is the recognition result.

[0071] In a specific embodiment, the process of performing step S102 can specifically include the following steps:

[0072] Classifying and matching the game type identifier in the running monitoring data to obtain a game type classification result;

[0073] Initializing and assigning the weight coefficients based on the game type classification result to obtain an initial weight coefficient combination;

[0074] Performing least squares fitting on the initial weight coefficient combination based on historical running data to obtain optimized weight coefficients;

[0075] Inputting the running monitoring data and the optimized weight coefficients into the risk assessment function for weighted calculation to obtain real-time risk calculation values;

[0076] Performing threshold judgment on the real-time risk calculation values to obtain risk assessment values.

[0077] Specifically, the game type identification in the running monitoring data is classified and matched by feature vector comparison, and the algorithm extracts the CPU usage fluctuation mode, memory occupation growth trend and state transition event distribution characteristics, and performs Euclidean distance calculation with the preset game type feature library. The feature library stores the CPU medium usage, memory gradual growth and team battle event centralized characteristics of the MOBA type game, the CPU high frequency fluctuation, memory stability and event uniform distribution characteristics of the FPS type game, and the CPU low frequency usage, memory continuous growth and event phased distribution characteristics of the RPG type game. The type with the smallest distance is the classification result. The weight coefficient initialization assignment process performs differential configuration according to the game type classification result, and sets the CPU usage weight to 0.4, the memory occupation weight to 0.3 and the state transition event weight to 0.3 for the MOBA type game, sets the three weights to 0.33 for the FPS type game, and sets the memory occupation weight to 0.5, the CPU usage weight to 0.3 and the state transition event weight to 0.2 for the RPG type game, to form an initial weight coefficient combination for different game type characteristics.

[0078] The least square method fitting process optimizes the initial weight coefficient through historical running data, the algorithm collects the corresponding relationship between the monitoring indicators and the actual risk level in the historical game record, establishes a linear regression model, and solves the optimal weight coefficient by minimizing the sum of squares of the difference between the predicted risk value and the true risk value. The calculation process establishes a normal equation group, and uses matrix operation to obtain the optimized weight coefficient, so that the weight configuration is more suitable for the actual game running characteristics.

[0079] The weighted calculation process combines the running monitoring data and the optimized weight coefficient to calculate the real-time risk value, the CPU usage value is multiplied by the corresponding weight to obtain the CPU risk contribution value, the memory occupation value is multiplied by the corresponding weight to obtain the memory risk contribution value, and the state transition event frequency is multiplied by the corresponding weight to obtain the event risk contribution value. The sum of the three contribution values is normalized to obtain the real-time risk calculation value between 0 and 1.

[0080] The threshold judgment process classifies and evaluates the real-time risk calculation value through the preset risk level threshold, sets 0.2 or less as low risk, 0.2 to 0.6 as medium risk, 0.6 to 0.8 as high risk, and 0.8 or more as extremely high risk, and determines the risk evaluation level according to the interval where the real-time risk calculation value is located.

[0081] In a specific embodiment, the process of performing classification and matching of the game type identification in the running monitoring data can specifically include the following steps:

[0082] Hash value calculation is performed on the game software file characteristics in the running monitoring data to obtain file characteristic hash values;

[0083] The file feature hash value is input into a game type feature library for matching query processing to obtain a preliminary classification identifier.

[0084] According to the network communication protocol in the operation monitoring data, the protocol features are analyzed and processed to obtain network protocol feature codes.

[0085] Based on the preliminary classification identifier and the network protocol feature code, comprehensive judgment processing is performed to obtain a game type confidence level.

[0086] The game type confidence level is subjected to threshold screening processing to obtain a game type classification result.

[0087] Specifically, the hash value calculation processing of the game software file features generates a digital fingerprint of the key features of the game executable file through MD5 or SHA-256 algorithm. The algorithm reads the file header information, version number, compilation timestamp and resource segment data of the game main program file, concatenates these feature data and inputs them into a hash function for calculation. The hash algorithm converts the indefinite-length file feature data into a fixed-length hexadecimal string. The same version file of the same game generates the same hash value, and different games or different versions generate different hash values, forming a unique identifier of the game software.

[0088] The file feature hash value input into the game type feature library for matching query processing adopts a combination of exact matching and similarity matching. The feature library pre-stores standard hash values of various games and their corresponding game type labels. The query algorithm first performs exact matching, directly retrieves whether the hash value exists in the feature library, and returns the corresponding game type identifier if the matching is successful. If the exact matching fails, the algorithm starts the similarity matching mode, calculates the Hamming distance between the hash value to be queried and each hash value in the feature library, and returns the game type with the highest matching degree as the preliminary classification identifier.

[0089] The protocol feature analysis processing of the network communication protocol analyzes the network data packets during the game running through the deep packet inspection technology. The algorithm captures the network data packets sent and received by the game process, analyzes the protocol type, port number, packet size and communication frequency and other feature information in the packet header. Different types of games have different network communication modes. MOBA games use UDP protocol for high-frequency small packet communication, FPS games use mixed TCP and UDP protocols for real-time data synchronization, and RPG games mainly use HTTP protocol for data exchange. The algorithm extracts key features such as communication protocol type, average packet size, communication frequency and data flow direction, and encodes to generate network protocol feature codes.

[0090] The comprehensive judgment processing performs multi-dimensional verification based on the preliminary classification identifier and the network protocol feature code. A two-dimensional judgment matrix is established by the algorithm. The horizontal axis is the preliminary classification identifier obtained by the file feature, and the vertical axis is the game type inference corresponding to the network protocol feature code. The consistency degree of the results of the two dimensions is calculated by the judgment algorithm. When the file feature and the network feature point to the same game type, the confidence is set to 0.9 or above. When the two features point to similar game types, the confidence is set to 0.6 to 0.8. When the two feature results conflict, the confidence is set to 0.5 or below. The algorithm also introduces historical behavior features as auxiliary judgment basis to comprehensively calculate the game type confidence value.

[0091] The threshold screening processing performs reliability evaluation on the game type judgment result by pre-setting the confidence threshold. The high confidence classification is set to 0.8 or above, the medium confidence classification is set to 0.6 to 0.8, and the low confidence classification is set to 0.6 or below. The high confidence classification is directly output as the final game type classification result. The medium confidence classification needs to be verified again combined with additional features. The low confidence classification is marked as unknown type and needs manual intervention or uses the default classification strategy.

[0092] In a specific embodiment, the process of performing step S103 can specifically include the following steps:

[0093] The risk assessment value is input into the game behavior sequence model for state abstraction processing to obtain a game running state sequence.

[0094] The game running state sequence is subjected to behavior trend prediction processing by a hidden Markov model to obtain an abnormal behavior prediction result.

[0095] According to the abnormal behavior prediction result, the control strategy level is hierarchically divided to obtain four levels of control levels of resource limitation, function disablement, interaction control and process control.

[0096] Based on the four-level control level, node judgment processing is performed on the decision tree to obtain a control decision path.

[0097] The control decision path is subjected to instruction encoding processing to obtain a hierarchical control instruction.

[0098] Specifically, the risk assessment value is input into the game behavior sequence model for state abstraction processing. By converting the continuous numerical risk assessment result into a discrete state identifier, the state abstraction model predefines a typical state set of game running, including normal running state, light load state, medium load state, heavy load state and critical state. The abstraction algorithm maps the state according to the numerical range of the risk assessment value, 0 to 0.2 is mapped to the normal running state, 0.2 to 0.4 is mapped to the light load state, 0.4 to 0.6 is mapped to the medium load state, 0.6 to 0.8 is mapped to the heavy load state, and 0.8 to 1.0 is mapped to the critical state. The algorithm records the state transition process in time sequence to form the game running state sequence.

[0099] The game running state sequence is processed by the hidden Markov model for behavior trend prediction. The hidden Markov model includes a hidden state layer and an observation state layer. The hidden state represents the internal running mode of the game system, and the observation state corresponds to the actual monitored state sequence. The model training process uses historical state sequence data to learn the state transition probability, and calculates the probability distribution of transitioning from the current state to the next state. The prediction algorithm uses the forward algorithm to calculate the probability of each state appearing in the future time window based on the current observation state sequence and the learned transition probability, and generates an abnormal behavior prediction result when the prediction probability of the abnormal state exceeds a certain threshold.

[0100] The abnormal behavior prediction result is processed by the control strategy level for hierarchical division. According to the severity and influence range of the predicted anomaly, the control intensity is determined, and the hierarchical algorithm divides the abnormal prediction result into four levels: slight abnormality, medium abnormality, severe abnormality and extremely severe abnormality. Slight abnormality corresponds to the resource limit control level, which intervenes by limiting the CPU usage limit and memory allocation limit, medium abnormality corresponds to the function disable control level, which closes non-core game functions and special effect rendering, severe abnormality corresponds to the interaction control level, which limits the user input response frequency and network communication bandwidth, and extremely severe abnormality corresponds to the process control level, which suspends the game process or forcibly ends the program execution.

[0101] The four-level control hierarchy performs node judgment processing on the decision tree. The specific control measures are determined by constructing a hierarchical decision structure. The root node of the decision tree judges the abnormal type and severity. The first layer of sub-nodes selects the appropriate control strategy branch according to the game type. The second layer of sub-nodes selects the specific control parameters according to the current system resource state. The decision algorithm traverses the decision tree path, and performs condition judgment at each node. The branch that meets the condition continues to execute downward, and finally reaches the leaf node to obtain the specific control measure combination. The decision path records the complete judgment sequence from the root node to the leaf node, including control level selection, parameter setting, and execution priority information. The control decision path is processed by instruction encoding to convert the decision result into a system executable control instruction. The encoding algorithm uses a structured instruction format containing four fields: instruction type, target object, control parameter, and execution time. The resource limitation instruction is encoded as a limitation type plus a target resource plus a limitation value. The function disable instruction is encoded as a disable identifier plus a function module plus a disable duration. The interactive control instruction is encoded as a control type plus an interactive object plus a control intensity. The process control instruction is encoded as a process operation plus a target process plus an operation parameter. The encoded hierarchical control instruction is sorted according to the execution priority.

[0102] In a specific embodiment, the process of performing step S104 can specifically include the following steps:

[0103] The control targets in the hierarchical control instruction are analyzed for dependency relationship to obtain a dependency relationship graph in a directed acyclic graph structure;

[0104] The nodes and edges in the dependency relationship graph are calculated for dependency strength to obtain a comprehensive dependency strength value of call frequency, data transmission volume, and criticality;

[0105] The control influence range is traced upstream and analyzed downstream according to the comprehensive dependency strength value to obtain an influence link;

[0106] The influence link is used for minimum loss path planning to obtain a phased implementation scheduling strategy;

[0107] The scheduling strategy is processed for early warning notification and gradual execution to obtain a control scheme.

[0108] Specifically, the control target in the hierarchical control instruction is subjected to a dependency relationship analysis process to establish a dependency relationship model by analyzing the calling relationship and data flow among components in the game system. The algorithm identifies the target objects involved in the control instruction, including rendering engine, physics engine, audio system, network module, and input processing module, etc. The algorithm analyzes the function calling relationship, shared memory access, and message passing mechanism among the modules to determine the dependency direction and dependency type. The rendering engine depends on the physics engine to provide position data, the audio system depends on the rendering engine to provide spatial information, and the network module depends on all subsystems to provide state data. The parsing result constructs a directed acyclic graph structure, with nodes representing system components and directed edges representing dependency relationship direction.

[0109] The nodes and edges in the dependency relationship graph are subjected to a dependency strength calculation process to determine the comprehensive dependency strength value by quantifying the importance and influence range of each dependency relationship. The algorithm calculates three-dimensional indicators of calling frequency, data transmission volume, and criticality between components. The calling frequency is obtained by monitoring the number of function calls per unit time, the data transmission volume is obtained by calculating the number of data bytes transmitted between components, and the criticality is set by assigning a weight value according to the influence of the component on the overall system function. The algorithm normalizes the three indicators and sums them according to the weights, with the calling frequency weight set to 0.4, the data transmission volume weight set to 0.3, and the criticality weight set to 0.3, to obtain a comprehensive dependency strength value between 0 and 1.

[0110] The comprehensive dependency strength value is subjected to an upstream tracing and downstream analysis process to determine the control operation's impact range. The upstream tracing algorithm starts from the target node and searches backward along the dependency relationship to identify all upper-level components that directly or indirectly depend on the target component. The downstream analysis algorithm starts from the target node and searches forward along the dependency relationship to identify all lower-level components that depend on the target component. The dependency strength values along the path are recorded during the traversal process, with dependency relationships with strength values higher than 0.6 marked as strong dependencies, between 0.3 and 0.6 marked as medium dependencies, and lower than 0.3 marked as weak dependencies. The algorithm forms a complete impact link graph by combining the upstream and downstream dependency links.

[0111] The impact link is subjected to a minimum loss path planning process to determine the optimal execution order of the control operation. The planning algorithm establishes a constrained optimization problem with the objective function of minimizing system function loss. The algorithm calculates the impact of different control orders on the overall system performance, prioritizes processing control targets with low dependency strength and small impact range, and delays processing control operations of core function components. The planning result divides the control operations into multiple execution stages, with the first stage processing peripheral auxiliary functions, the second stage processing medium important functions, and the third stage processing core function modules, forming a phased implementation scheduling strategy.

[0112] The pre-warning module sends a preparation signal to relevant components before the execution of the control operation, and the content of the notification includes the control type, the expected execution time, and the impact range. The execution processing module implements the control operation step by step according to the order of the stages of the scheduling strategy. After the completion of each stage, the system state is checked to see if it meets the expectations. In the case of abnormal conditions, the subsequent operation is suspended and the rollback mechanism is started. During the execution process, the response state and performance index changes of each component are monitored in real time to ensure that the control effect reaches the expected target, and finally a control scheme containing specific execution steps and time arrangement is generated.

[0113] In a specific embodiment, the process of executing step S105 can specifically include the following steps:

[0114] The execution result of the control scheme is accurately controlled for a number of times, and a control success rate value is obtained;

[0115] The game performance indicators are compared and analyzed before and after the control, and the performance retention rate values of the frame rate retention rate and the response time change rate are obtained;

[0116] The user experience satisfaction is quantitatively evaluated based on the user game behavior data, and a user experience satisfaction value is obtained;

[0117] The control effect evaluation index value is obtained by weighted product calculation based on the control success rate value, the performance retention rate value, and the user experience satisfaction value;

[0118] The control effect evaluation index value is input into the reinforcement learning algorithm for parameter optimization processing, and the strategy parameter configuration is obtained.

[0119] Specifically, the execution result of the control scheme is accurately controlled for a number of times, and a control success rate value is obtained, which is the first step to evaluate the effect of the control scheme. In this process, the system will count the number of successes of the control scheme in multiple executions, and calculate the success rate of the control scheme. Specifically, the control scheme may involve multiple sub-tasks or operations in each execution, and the system will record the execution result (success or failure) of each task, and calculate the ratio of the number of successes to the total number of executions according to these records. This control success rate value reflects the frequency of the control scheme achieving the expected effect in actual execution, and is a basic index for subsequent optimization. By accurately counting the success and failure of each control action, the system can quantitatively analyze the effectiveness of the current control scheme and identify the operation steps that may need to be optimized.

[0120] After obtaining the control success rate, the next step is to compare and analyze the game performance indicators before and after the control, and obtain the frame rate retention rate and response time change rate performance retention rate values. In this process, the system will compare and analyze the performance data before and after the control, mainly focusing on the frame rate and response time, which are the two key performance indicators. Frame rate retention rate reflects whether the control scheme successfully maintains the smoothness of the game, while response time change rate reflects whether the interaction between the player and the game is smooth. By comparing the frame rate data before and after the control, the system can evaluate the impact of the control scheme on the smoothness of the game picture; by comparing the response time data before and after the control, the system can evaluate the impact of the control scheme on the interactivity of the game. If the control scheme can improve the frame rate or reduce the response time fluctuation without affecting the game experience, the performance retention rate value will be higher, indicating that the control scheme has achieved the expected goal in performance optimization.

[0121] After obtaining the control success rate and performance retention rate, the system will quantitatively evaluate the user experience satisfaction based on the user game behavior data, and obtain the user experience satisfaction value. User behavior data usually includes user operation frequency, interaction time, problems encountered in the game process, in-game ratings, etc. These data can reflect the user's real experience, and the system analyzes these data, combined with the execution result of the control scheme, to evaluate the user's satisfaction with the game experience. If the control scheme successfully improves the smoothness of the game and improves the responsiveness, the user's satisfaction will usually improve. The system will calculate a user experience satisfaction value through specific algorithms, such as weighted scoring based on behavior data, which quantifies the user's satisfaction after the implementation of the control scheme.

[0122] After obtaining the control success rate value, the performance retention rate value, and the user experience satisfaction value, the system performs weighted product calculation processing to obtain the control effect evaluation index value. Weighted product calculation is a process of weighting the three indicators according to their importance to synthesize a final control effect evaluation value. The weight of each indicator reflects its relative importance in the final evaluation, which is usually set according to actual needs and system goals. For example, if game smoothness and responsiveness have a greater impact on user experience, the system may assign higher weights to performance retention rate and control success rate; if user experience is crucial to game optimization, the weight of user experience satisfaction will be increased accordingly. Through the multiplication of these weighted values, the system can obtain a comprehensive control effect evaluation index reflecting the overall effect of the control scheme. The control effect evaluation index value is input into the reinforcement learning algorithm for parameter optimization processing. In this process, the system optimizes the parameters in the control scheme through the reinforcement learning algorithm to maximize the control effect evaluation index. The reinforcement learning algorithm adjusts the control strategy and parameters according to the changes in the control effect evaluation index through a reward and punishment mechanism, gradually optimizing the control scheme. For example, if the current control scheme performs poorly in improving frame rate and response time, the system will adjust the relevant parameters in the control strategy through reinforcement learning to gradually find the optimal control scheme, ultimately optimizing the overall performance of the system. In this way, the system can achieve automated strategy optimization, continuously learning to improve the execution effect of the control scheme and enhance player experience and game running efficiency.

[0123] The game software running control method in the embodiments of the present application is described above, and the game software running control system in the embodiments of the present application is described below. Please refer to Figure 2 An embodiment of the game software running control system in the embodiments of the present application includes:

[0124] The acquisition module is configured to perform state acquisition processing on the game software through a system-level hook to obtain running monitoring data.

[0125] The calculation module is configured to perform weight calculation processing on the risk assessment function through a dynamic weight adjustment algorithm according to the running monitoring data to obtain a risk assessment value.

[0126] The prediction module is configured to perform sequence prediction processing on the risk assessment value through a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions.

[0127] The scheduling module is configured to perform collaborative scheduling processing on the dependency relationship graph according to the hierarchical control instructions to obtain a control scheme.

[0128] The quantification module is configured to perform effect quantification processing on the control scheme through a control effect evaluation index to obtain strategy parameter configuration.

[0129] The above Figure 2 The game software running control system in the embodiment of the application is described in detail from the perspective of the modular functional entity, and the game software running control device in the embodiment of the application is described in detail from the perspective of hardware processing.

[0130] With reference to Figure 3 The embodiment of the application also provides a game software running control device, which can be a server, and the internal structure of the game software running control device can be as shown in Figure 3 The game software running control device comprises a processor, a memory, a display screen, an input device, a network interface and a database connected through a system bus. The processor of the computer is used to provide computing and control capabilities. The memory of the game software running control device comprises a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operating system and the computer program in the non-volatile storage medium. The database of the game software running control device is used to store corresponding data in the embodiment. The network interface of the game software running control device is used to communicate with external terminals through network connection. The computer program is executed by the processor to implement the above method.

[0131] Those skilled in the art can understand Figure 3 The structure shown in the embodiment is only a block diagram of part of the structure related to the scheme of the application, and does not constitute a limitation on the game software running control device to which the scheme of the application is applied.

[0132] The application also provides a computer readable storage medium, which can be a non-volatile computer readable storage medium or a volatile computer readable storage medium. The computer readable storage medium stores instructions, and when the instructions are run on a computer, the computer executes the steps of the game software running control method.

[0133] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the above-described system, system and unit can refer to the corresponding processes in the foregoing method embodiments, which will not be described herein.

[0134] The integrated unit, if implemented in the form of a software function unit and sold or used as an independent product, can be stored in a computer readable storage medium. Based on such understanding, the technical solutions of the present application or the entire or part of the technical solutions that essentially contribute to the prior art can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes a plurality of instructions for causing a game software running control 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: a U disk, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk, and various media that can store program codes.

[0135] The above embodiments are only used to illustrate the technical solutions of the present application, rather than limit them; although the present application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that they can still modify the technical solutions recorded in the foregoing embodiments, or make equivalent replacements for part of the technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A game software execution control method characterized by comprising: The method comprises: The game software is state collected and processed through a system-level hook to obtain running monitoring data; A risk assessment function is weight calculated and processed through a dynamic weight adjustment algorithm according to the running monitoring data to obtain a risk assessment value; The risk assessment value is sequentially predicted through a game behavior sequence intelligent control algorithm to obtain a hierarchical control instruction; A control scheme is obtained by cooperatively scheduling a dependency relationship graph according to the hierarchical control instruction, comprising: control targets in the hierarchical control instruction are dependency relationship analyzed to obtain a dependency relationship graph in a directed acyclic graph structure; nodes and edges in the dependency relationship graph are dependency strength calculated to obtain a comprehensive dependency strength value of calling frequency, data transmission volume and criticality; a control influence range is upstream traced and downstream analyzed according to the comprehensive dependency strength value to obtain an influence link; a scheduling strategy implemented in stages is obtained by planning a minimized loss path based on the influence link; the scheduling strategy is prewarning notified and gradually executed to obtain the control scheme; The control scheme is effect quantized through a control effect evaluation index to obtain a strategy parameter configuration.

2. The game software execution control method according to Claim 1, characterized by The running monitoring data comprises CPU usage, memory occupation and state transition events, the game software is state collected and processed through a system-level hook to obtain running monitoring data, comprising: A system-level hook is injected into a game process for monitoring code deployment processing to obtain a process communication channel; CPU usage and memory occupation are obtained by acquiring parameters of the game software based on the process communication channel; State transitions are analyzed according to game engine internal events to obtain state transition events of level switching and character skill release; The CPU usage, memory occupation and state transition events are input into a ring buffer for data storage processing to obtain a timeliness data set; The running monitoring data is obtained by identifying the game type of the timeliness data set.

3. The game software execution control method according to Claim 1, characterized by The risk assessment function is weight calculated and processed through a dynamic weight adjustment algorithm according to the running monitoring data to obtain a risk assessment value, comprising: Game type identifiers in the running monitoring data are classified and matched to obtain a game type classification result; Weight coefficients are initialized and valued according to the game type classification result to obtain an initial weight coefficient combination; The initial weight coefficient combination is least square fitted based on historical running data to obtain optimized weight coefficients; The running monitoring data and the optimized weight coefficients are input into a risk assessment function for weighted calculation to obtain a real-time risk calculation value; The real-time risk calculation value is threshold judged to obtain the risk assessment value.

4. The game software execution control method according to Claim 3, characterized by The game type identifiers in the running monitoring data are classified and matched to obtain a game type classification result, comprising: File feature hash values are calculated from game software file features in the running monitoring data to obtain file feature hash values; The file feature hash value is input into a game type feature library for matching query processing, and a preliminary classification identifier is obtained; According to the network communication protocol in the running monitoring data, the protocol features are analyzed and processed to obtain network protocol feature codes; Based on the preliminary classification identifier and the network protocol feature codes, comprehensive judgment processing is performed to obtain a game type confidence level; The game type confidence level is subjected to threshold screening processing to obtain the game type classification result.

5. The game software execution control method according to Claim 1, characterized by The risk assessment value is input into a game behavior sequence model for state abstraction processing to obtain a game running state sequence; The game running state sequence is subjected to behavior trend prediction processing by a hidden Markov model to obtain an abnormal behavior prediction result; According to the abnormal behavior prediction result, the control strategy level is hierarchically divided to obtain four levels of control levels, namely, resource limitation, function disablement, interaction control, and process control; Based on the four levels of control levels, node judgment processing is performed on a decision tree to obtain a control decision path; the control decision path is subjected to instruction encoding processing to obtain the hierarchical control instruction. The control scheme is subjected to effect quantification processing by a control effect evaluation index to obtain a strategy parameter configuration, including:

6. The game software execution control method according to Claim 1, characterized by The number of accurate control times of the execution result of the control scheme is counted to obtain a control success rate value; Game performance indicators are compared and analyzed before and after control to obtain performance retention rate values of frame rate retention rate and response time change rate; User experience satisfaction is quantitatively evaluated based on user game behavior data to obtain a user experience satisfaction value; Based on the control success rate value, the performance retention rate value, and the user experience satisfaction value, weighted product calculation processing is performed to obtain a control effect evaluation index value; The control effect evaluation index value is input into a reinforcement learning algorithm for parameter optimization processing to obtain the strategy parameter configuration. The game software running control system for implementing the game software running control method according to any one of claims 1 to 6 comprises:

7. A game software execution control system characterized by comprising: A collection module for performing state collection processing on game software through a system-level hook to obtain running monitoring data; A calculation module for performing weight calculation processing on a risk assessment function through a dynamic weight adjustment algorithm based on the running monitoring data to obtain a risk assessment value; A prediction module for performing sequence prediction processing on the risk assessment value through a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions; ​ The scheduling module is configured to perform collaborative scheduling processing on the dependency graph according to the hierarchical control instruction to obtain a control scheme, including: performing dependency relationship analysis processing on a control target in the hierarchical control instruction to obtain a dependency graph in a directed acyclic graph structure; performing dependency strength calculation processing on nodes and edges in the dependency graph to obtain a comprehensive dependency strength value of a calling frequency, a data transmission amount, and a criticality; performing upstream tracing and downstream analysis processing on a control influence range according to the comprehensive dependency strength value to obtain an influence link; performing minimum loss path planning processing based on the influence link to obtain a scheduling strategy for implementation in stages; and performing early warning notification and step-by-step execution processing on the scheduling strategy to obtain the control scheme; The quantification module is configured to perform effect quantification processing on the control scheme by using a control effect evaluation index to obtain a strategy parameter configuration.

8. A game software execution control device characterized by comprising: The computer program, when executed by the processor, causes the processor to implement the game software running control method in any one of claims 1 to 6.

9. A computer readable storage medium having stored thereon a computer program, characterized in that, The computer program, when executed by the processor, causes the processor to implement the game software running control method in any one of claims 1 to 6.

Images