Game software operation control method and system

Abstract

The invention relates to the technical field of data processing, and discloses a game software operation control method and system. The method comprises the following steps: acquiring game operation monitoring data through a system-level hook; calculating a risk assessment value based on a dynamic weight adjustment algorithm; generating a hierarchical control instruction by using a game behavior sequence intelligent control algorithm; a control scheme is obtained through cooperative scheduling of the dependency graph; and performing quantitative processing by adopting the control effect evaluation index to obtain strategy parameter configuration. According to the method, the game software operation control accuracy and the user experience protection effect are improved.

Description

Technical Field

[0001] The present application relates to the field of data processing technology, and in particular to a method and system for controlling the operation of game software. Background Art

[0002] Existing methods for controlling gaming software operations primarily employ static control strategies based on process monitoring, managing the software's operation by identifying the game process name or window title. Traditional control methods typically set fixed time thresholds or resource usage limits. When the game software's runtime exceeds a preset value or system resource usage is excessive, the process is paused or terminated. These methods are widely used in internet cafe management systems, parental control software, and enterprise IT management, enabling a certain level of basic control over the running status of gaming software.

[0003] However, static control strategies cannot adapt to the differences in operating characteristics of different types of game software, resulting in low control accuracy and frequent miscontrol; secondly, the coarse-grained control method based on the process level ignores the complex dependencies between the various functional components within the game software, which can easily cause inconsistent game status and loss of user experience; thirdly, there is a lack of intelligent analysis and prediction capabilities for the game operation behavior sequence, making it impossible to achieve active prediction of abnormal behavior and refined control.

[0004] The problem with existing technologies is that they lack a deep understanding of the operating status of gaming software and the ability to dynamically adapt. Due to the high interactivity and real-time nature of gaming software, its operating status dynamically adjusts as the game content, user operations, and system environment change. Traditional static control strategies are unable to capture these dynamic changes. Further analysis revealed that gaming software contains complex functional dependencies and resource competition mechanisms. Simple process-level control cannot accurately locate control targets, resulting in poor control effectiveness. Therefore, there is an urgent need to establish a gaming software operation control method that can perceive the game's operating status in real time, intelligently predict behavioral trends, and accurately implement collaborative control. Summary of the Invention

[0005] The present application provides a game software operation control method and system, which is used to solve the problems in the existing game software operation control method that the static control strategy cannot adapt to the dynamic operation characteristics of the game and lacks refined collaborative control capabilities, thereby improving the accuracy of game software operation control and the user experience protection effect.

[0006] In a first aspect, the present application provides a method for controlling the operation of game software, the method comprising: The game software status is collected and processed through system-level hooks to obtain operation monitoring data; Performing weight calculation processing on the risk assessment function using a dynamic weight adjustment algorithm based on the operation monitoring data to obtain a risk assessment value; The risk assessment value is subjected to sequence prediction processing by a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions; Performing collaborative scheduling processing on the dependency graph according to the hierarchical control instructions to obtain a control solution; The control scheme is quantified by using control effect evaluation indicators to obtain strategy parameter configuration.

[0007] In a second aspect, the present application provides a game software operation control system, the game software operation control system comprising: The acquisition module is used to collect and process the status of the game software through system-level hooks to obtain operation monitoring data; A calculation module, configured to perform weight calculation processing on a risk assessment function using a dynamic weight adjustment algorithm based on the operation monitoring data to obtain a risk assessment value; A prediction module, configured to perform sequence prediction processing on the risk assessment value through a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions; A scheduling module, configured to perform collaborative scheduling processing on the dependency graph according to the hierarchical control instructions to obtain a control solution; The quantification module is used to quantify the effect of the control scheme through the control effect evaluation index to obtain the strategy parameter configuration.

[0008] In a third aspect, a game software operation control device is provided, comprising: a memory and at least one processor, wherein the memory stores instructions; the at least one processor calls the instructions in the memory so that the game software operation control device executes the above-mentioned game software operation control method.

[0009] In a fourth aspect, a computer-readable storage medium is provided, wherein instructions are stored in the computer-readable storage medium, and when the computer-readable storage medium is run on a computer, the computer executes the above-mentioned game software operation control method.

[0010] The technical solution provided in this application uses system-level hooks to collect and process game software status to obtain operational monitoring data. Compared to traditional process name identification methods, this method can penetrate deep into the game engine to obtain detailed operational information such as CPU usage, memory usage, and state transition events. This fundamentally addresses the problems of coarse monitoring data and low recognition accuracy in existing technologies. A dynamic weight adjustment algorithm weights the risk assessment function. By adaptively adjusting the weight coefficients specific to the game type, it overcomes the limitations of static threshold judgment methods and ensures that the risk assessment value accurately reflects the operational risk characteristics of different game types. The game behavior sequence intelligent control algorithm performs sequence prediction processing to generate hierarchical control instructions. It uses a hidden Markov model to predict game behavior trends and formulate a four-level control strategy. Compared to traditional binary control methods, this achieves a technological leap from extensive management and control to refined intelligent control. The collaborative scheduling of the dependency graph uses a directed acyclic graph structure to analyze the call relationships and data flows between internal game components. This solves the control conflict problem caused by the lack of collaborative consideration in existing technologies and ensures the systematic and consistent control operations.

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

[0012] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0013] Figure 1 This is a schematic diagram of an embodiment of a method for controlling the operation of game software in an embodiment of the present application; Figure 2 This is a schematic diagram of an embodiment of a game software running control system in an embodiment of the present application; Figure 3It is a schematic block diagram of the structure of the game software running control device in an embodiment of the present invention. DETAILED DESCRIPTION

[0014] The embodiments of the present application provide a method and system for controlling the operation of game software. The terms "first", "second", "third", "fourth", etc. (if any) in the specification and claims of this application and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or precedence. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments described herein can be implemented in an order other than that illustrated or described herein. In addition, the terms "including" or "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0015] For ease of understanding, the specific process of the embodiment of the present application is described below. Figure 1 In one embodiment of the game software operation control method of the present application, the following steps are included: Step S101: collect and process the status of the game software through a system-level hook to obtain operation monitoring data.

[0016] It is understandable that the execution subject of this application can be a game software running control system, or a terminal or a server, which is not limited here. The embodiment of this application is described by taking the server as the execution subject as an example.

[0017] Specifically, system-level hooking technology can be used to obtain various runtime data in real time, and then process and analyze this data to monitor and optimize the game status. Hooks are interfaces provided by the operating system that allow programs to intercept operating system messages or events at specified times. In this application, hooks are often used to monitor and collect game runtime data.

[0018] System-level hooks operate based on an event-driven model. They insert messages into the operating system's message queue while the game process is running and capture various state changes in the game software. The data captured by the hook may include, but is not limited to, the game's frame rate, CPU and GPU usage, memory consumption, and input events (such as mouse clicks and keyboard keystrokes). This allows the hook to obtain relevant game data in real time without disrupting the normal operation of the game.

[0019] The collected raw data is passed to the data processing module, whose main function is to screen, filter, and perform preliminary data conversion. During the data collection process, due to the potential for a large amount of redundant information or noise, it must be effectively processed. Taking the game frame rate as an example, during the data collection process, the rendering time and calculation process of each frame are recorded. The system will filter important frame data based on set conditions (such as sampling frequency and threshold), thereby avoiding meaningless duplication of data.

[0020] The processed data is further analyzed through algorithms to obtain game performance metrics. For example, the game's frame rate data can be processed and used to evaluate current performance. If the frame rate data shows large fluctuations, it may mean that the CPU or GPU is overloaded. In this case, the system will automatically adjust the game settings, reducing the graphics quality or resolution to ensure smooth game operation. At the same time, by comparing the relationship between CPU and GPU utilization and frame rate, performance bottlenecks can be identified and game operation can be optimized.

[0021] Memory consumption is another key monitoring metric. The system uses hooks to capture memory usage in real time. The allocation and recycling of memory during the running of different games will directly affect the smoothness and stability of the game. During data processing, memory usage data is recorded along with timestamps to ensure that the memory status at each moment can be accurately tracked. Through algorithms, the system can analyze memory allocation in different game scenarios, identify links that may cause memory leaks, and provide corresponding repair suggestions to avoid lag or crashes after long-term operation.

[0022] When processing input events, the hook can also capture user interaction behaviors, such as mouse click locations and keyboard keystrokes. This data is recorded in real time and used to analyze user operating habits, behavioral patterns, and can even be used for cheating detection. During the data processing phase, these input events are classified and processed according to their timing and type. The system can analyze the smoothness of user operations and optimize the user experience based on different operating scenarios. For example, in fast-action games, the system can adjust the input response delay based on the user's keystroke frequency and accuracy to ensure the immediacy and accuracy of the operation.

[0023] During the data processing process, all captured data is ultimately compiled into a complete performance report. This report includes the changing trends of various indicators and is intuitively displayed through charts and graphs for developers and users to refer to. The collection and processing of this data not only helps optimize game performance, but also provides data support for subsequent game tuning, ensuring that the game can run stably in various hardware environments. At the same time, the hook's real-time data collection and processing mechanism also provides game developers with a powerful monitoring platform that can quickly respond to any anomalies in the game and ensure the continued healthy operation of the game.

[0024] Step S102: weighting the risk assessment function using a dynamic weight adjustment algorithm based on the operation monitoring data to obtain a risk assessment value; Specifically, during the process of dynamically adjusting the weights of the risk assessment function based on runtime monitoring data and calculating the risk assessment value, various monitoring data are integrated and processed using a dynamic weight adjustment algorithm to produce a risk assessment. The core of this process is data collection, weight adjustment, and calculation of the risk assessment function. Data comes from system monitoring indicators, such as the game software's runtime frame rate, CPU and GPU utilization, memory consumption, and user input response time. Different monitoring data corresponds to different risk dimensions, such as system load, performance bottlenecks, memory pressure, and user operation latency. Based on this monitoring data, the risk assessment function assigns appropriate weights to each risk and dynamically adjusts these weights to calculate a comprehensive risk assessment value. Real-time runtime data is obtained from the game process. This data includes performance indicators such as frame rate, CPU and GPU utilization, and memory consumption, as well as input events such as user operation frequency and response time. This raw data is captured and transmitted through a hook system, and each data item is recorded and categorized. To ensure data accuracy and completeness, the collected data undergoes preliminary cleaning and screening to remove noise and unnecessary duplication.

[0025] After data cleaning is complete, the system enters the weight calculation and risk assessment phase. Depending on the nature of the monitored data, different data items will have varying impacts on the risk assessment function. For example, frame rate and CPU usage reflect the performance load of the game, memory consumption is related to resource management and system stability, and input responsiveness directly impacts the user experience. To appropriately integrate this data into the risk assessment function, the system assigns a dynamic weight to each data item. This weighting is based on the current system operating status and the importance of the data. For example, under high game load, CPU usage will be given a higher weight, as CPU load can become a performance bottleneck. Conversely, when the game runs for extended periods, memory consumption will be given a higher weight, as memory leaks can impact the long-term stability of the system.

[0026] Based on real-time data monitoring results, the current risk contribution of each data point is assessed. If a metric's trend shows an anomaly (for example, CPU usage exceeding a preset threshold), its weight increases, indicating a greater contribution to the risk assessment. Conversely, if a metric's changes stabilize and no longer pose a significant risk, its weight decreases. This process requires a real-time feedback mechanism to continuously adjust the weights to ensure that the risk assessment function accurately reflects the health of the system under different operating conditions. Once all weights are calculated, the monitored data are weighted according to these dynamically adjusted weights to calculate a comprehensive risk assessment. The risk assessment function multiplies each data point by its corresponding dynamic weight and then sums these weighted data to produce a total risk assessment value. This value represents the overall risk level of the current system. Higher values ​​indicate greater risk and may require optimization measures, such as reducing graphics quality, freeing up memory, or adjusting game settings.

[0027] Step S103: The risk assessment value is subjected to sequence prediction processing by the game behavior sequence intelligent control algorithm to obtain hierarchical control instructions; Specifically, when implementing risk assessment values ​​through a game behavior sequence intelligent control algorithm for sequence prediction and generating 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 based on these predictions. The core of this process is to provide the system with precise hierarchical control instructions through step-by-step data processing, modeling, and algorithm optimization. This allows the game to automatically adjust its state based on real-time assessment results, ensuring a smooth gaming experience. The input is the previous risk assessment value, which is derived through a dynamic weight adjustment algorithm based on runtime monitoring data. The risk assessment value reflects the overall health of the current game runtime, including system load, memory usage, frame rate, input latency, and other data. This assessment provides a comprehensive perspective on the current state of the game system and provides essential reference for predicting the system's next actions.

[0028] Once the risk assessment value is generated, the next step is to enter the intelligent control algorithm portion of the behavior sequence. The task of this part is to use machine learning or deep learning models to predict possible changes in the game in the next few time steps based on historical game behavior data and the current risk assessment. By learning the relationship between game behavior and performance indicators in historical data, the system can identify potential connections between different risk assessment values ​​and game behavior. For example, when the system's risk assessment value is high, it may mean that the system is facing a large load. At this time, 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.

[0029] This historical data includes, but is not limited to, game frame rate fluctuations, CPU and GPU load, and memory usage. It is organized in a time series format to form sequential data on game behavior. This sequential data, obtained by monitoring and recording game performance, provides a foundation for subsequent predictions. Intelligent control algorithms use this historical behavior data, along with current risk assessments, to train models and accurately predict the system's next steps.

[0030] The goal of the intelligent control algorithm is to analyze historical data trends and identify control actions associated with risk assessment values. By training on this data, the model learns what adjustments the system should take when specific risk assessment values ​​are reached. For example, when the risk assessment value indicates high system stress, the model might predict that graphics quality should be reduced to reduce resource consumption; whereas when the risk assessment value is low, the system might adopt a more aggressive graphics rendering strategy to enhance the user's visual experience.

[0031] Through this intelligent control algorithm, the system generates a series of hierarchical control instructions that gradually guide adjustments to game behavior based on the predicted results. These control instructions typically include different levels of operations. For example, when the system is under high load, the first level of control instructions may simply reduce the resolution or disable 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 deeper algorithm optimization or even adjust the game's operation to adapt to different hardware environments. Each level of control instructions is dynamically generated based on the predicted risk assessment value and behavior sequence.

[0032] These control commands are closely tied to the real-time state of the game, effectively ensuring smooth gameplay. The system uses intelligent control algorithms to predict the game's future behavior and tiers control commands based on risk assessments. This ensures the game can respond promptly under high load, avoiding lags, crashes, and other issues. Control commands aren't just single actions; they're progressively adjusted based on different game requirements, hardware environments, and user experience needs, ensuring each command tailors the system state to its specific needs. Game state can be automatically adjusted based on real-time risk assessments, providing a smooth and dynamic user experience. The system not only handles current high loads but also anticipates future risks, preparing for them in advance and ensuring optimal performance in diverse environments. This method of predicting sequences and generating tiered control commands through intelligent behavior sequence control algorithms provides powerful support for intelligent regulation of gaming systems.

[0033] Step S104: performing collaborative scheduling processing on the dependency graph according to the hierarchical control instructions to obtain a control solution; Specifically, when collaboratively scheduling hierarchical control instructions based on a dependency graph to generate a control solution, the key goal is to generate an efficient and coordinated control solution by analyzing the hierarchical control instructions and the dependency graph within the system. A dependency graph is a visual representation of the interdependencies between various operations, resources, and tasks within a complex game or system. It illustrates the logical relationships between tasks, resources, and events, as well as their execution order. In this context, the core of collaborative scheduling is to ensure that all control instructions are executed in an orderly manner according to the constraints in the dependency graph, thereby optimizing system performance and avoiding conflicts. In the early stages of data processing, the system uses hierarchical control instructions to guide the scheduling process. These control instructions are generated by intelligent control algorithms and reflect the system's optimization objectives under a given risk assessment. Each control instruction represents a possible system adjustment action, encompassing multiple levels of strategies, such as reducing graphics load, adjusting memory allocation, or changing CPU / GPU scheduling. Each control instruction needs to be dynamically scheduled based on the system's real-time status to ensure that the various adjustment measures work together to avoid resource contention or interference.

[0034] During the dependency graph construction process, the system identifies the dependencies between tasks, operations, and resources and converts them into nodes and edges in the graph. Each node represents a task or resource, while an edge represents the dependencies between tasks. For example, a graph might have a node representing "graphics rendering" and another node representing "memory release." The two have a dependency relationship, meaning that memory release must occur before graphics rendering. Each edge in the dependency graph carries information about the order in which tasks are executed, which guides subsequent scheduling decisions.

[0035] During the collaborative scheduling process, the system analyzes the dependency graph based on hierarchical control instructions and, taking into account the system's current operating status, determines which operations should be prioritized and which can be deferred or optimized. Specifically, the system sorts the dependency graph by analyzing the priorities specified in the current control instructions. Based on these priorities, the system identifies critical paths within the graph—those core tasks that impact the overall system performance—and ensures that these critical tasks are prioritized for scheduling and execution.

[0036] By co-scheduling the dependency graph, the system also needs to handle potential conflicts between multiple control instructions. For example, in some cases, graphics rendering and memory optimization may involve the use of the same resources, and the order in which they are scheduled can affect final system performance. To avoid such conflicts, the system uses a scheduling algorithm to optimize the execution order of tasks, ensuring that all resource usage complies with the constraints in the dependency graph while maximizing resource efficiency. The scheduling algorithm automatically adjusts the execution order of tasks based on factors such as control instruction priority, resource availability, and task execution duration to avoid resource contention and ensure stable system operation. Co-scheduling goes beyond simple task sequencing; it comprehensively considers inter-task dependencies, resource requirements, and system load to generate a globally optimized control scheme. This control scheme dynamically adjusts the system state to ensure that the execution order of tasks complies with dependencies while minimizing idle time of system resources, thereby improving game or system efficiency. For example, if one task may require a large amount of memory while another requires CPU resources, the system will arrange the execution order of these two tasks based on the constraints in the dependency graph to ensure that they do not interfere with each other, thereby balancing CPU and memory usage.

[0037] Once all tasks are scheduled, the system generates a complete control plan. This plan includes the execution order of each control instruction and the required resource allocation method, ensuring that all tasks are coordinated and executed efficiently during system operation. The generated control plan not only optimizes the performance of the game or application, but also maximizes resource utilization, reducing unnecessary computing load and wasted system resources. In this way, collaborative scheduling effectively transforms risk assessments and control instructions into specific operational plans, ensuring that the system can adaptively optimize in complex operating environments and provide a smooth user experience. By combining hierarchical control instructions with task scheduling in a dependency graph, the system can ensure that each operation is performed at the appropriate time when handling complex calculations and resource allocation, avoiding conflicts and improving overall operational efficiency. This process effectively translates theoretical risk assessments into practical operations and performs comprehensive optimization at the system level.

[0038] Step S105: quantify the effect of the control scheme using the control effect evaluation index to obtain the strategy parameter configuration.

[0039] Specifically, when quantifying the effectiveness of a control scheme using control effectiveness evaluation metrics, the core task is to evaluate the scheme's implementation and determine the specific policy parameter configuration. This process combines game system performance data with the control scheme's execution results to quantify the actual effectiveness of the control strategy. Based on this quantified result, the policy parameters are adjusted to optimize the system's overall performance. Quantifying the effectiveness of a control scheme requires not only capturing the system's operating state but also conducting in-depth analysis of this state based on multiple control metrics. Ultimately, the specific policy parameter configuration is derived for subsequent optimization and adjustment. The control scheme itself is derived through the coordinated scheduling of a dependency graph and contains a series of adjustment instructions designed to improve the game's performance or enhance the user experience. To verify the effectiveness of these instructions, the system first quantifies the control scheme by setting a set of control effectiveness evaluation metrics. Control effectiveness evaluation metrics typically cover multiple dimensions, such as performance, stability, user experience, and resource utilization, each representing a specific aspect of the control scheme. Performance metrics may include frame rate, CPU utilization, and GPU load, while user experience may be measured through response time, latency, and input smoothness.

[0040] During the quantification process, the system first needs to collect real-time data from the game or application after the control scheme is implemented. This data includes changes in the game's frame rate, resource consumption, system stability, input response time, and more. By monitoring this data in real time, the system can capture the impact of the control scheme on the system state and measure it using preset control effect evaluation indicators. For example, if the frame rate increases significantly after the control scheme is implemented, it means that the control scheme has effectively reduced the resource burden and improved system smoothness; if the system load remains within an acceptable range and memory consumption is low, it indicates that the control scheme has also achieved good results in optimizing resource utilization.

[0041] By analyzing the control effect evaluation indicators, the system can further explore the relationship between different control instructions. For example, the improvement in frame rate may be directly related to the reduction in CPU and GPU load. The system can analyze whether a certain control instruction (such as reducing graphics quality) effectively reduces the computing pressure of the GPU, thereby improving overall performance. Similarly, memory usage can also reflect the effectiveness of the control scheme. If memory consumption is low and stable, it means that the control scheme has effectively optimized resource allocation. The relationship between various evaluation indicators plays a vital role in system analysis. They help the system identify which control instructions have a positive impact and which may need to be adjusted or improved.

[0042] Data relevance and feedback mechanisms play a crucial role in this process. For example, the system may discover that a specific policy parameter configuration (such as reducing graphics resolution) improves frame rate within a certain range. However, if the reduction is too large, the user experience will be affected, leading to increased response latency. Therefore, the quantification of control effectiveness evaluation indicators involves more than just analyzing a single metric; rather, it involves a comprehensive assessment across multiple dimensions to determine the overall effectiveness of the control solution. This multi-metric, multi-dimensional data processing requires the system to effectively balance various indicators.

[0043] Quantified control effectiveness evaluation metrics provide guidance for policy parameter configuration. Specifically, the system uses an algorithm to convert these quantitative results into parameter configurations for the adjustment plan. For example, if the frame rate improvement meets expectations while memory usage remains low, the system may increase graphics quality settings to optimize the game's visuals. If system stability is poor, causing lag or crashes, the resource allocation parameters in the control plan may need further optimization to reduce GPU or CPU load. Based on these quantitative analysis results, the system can adjust policy parameter configurations in real time, continuously optimizing the control plan and improving overall game performance. Quantifying control effectiveness not only helps developers evaluate the effectiveness of their control plan but also provides data support for subsequent adjustments. Through quantitative analysis, the system can identify strengths and weaknesses in the control plan and adjust policy parameters in a timely manner to ensure optimal performance and user experience across various hardware configurations and operating environments. This approach enables dynamic optimization of the control plan, continuously adjusting itself based on feedback data, ultimately providing an efficient and stable gaming environment.

[0044] In a specific embodiment, the process of executing step S101 may specifically include the following steps: Inject system-level hooks into the game process to deploy monitoring code and obtain the process communication channel; The game software is processed and parameter acquisition is performed based on the process communication channel to obtain the CPU usage and memory usage; Analyze and process state transitions based on internal game engine events to obtain state transition events for level switching and character skill releases; Input CPU usage, memory usage, and state transition events into the ring buffer for data storage and processing to obtain a time-sensitive data set; The game type identification process is performed on the timeliness data set to obtain operation monitoring data.

[0045] Specifically, the system-level hook injection into the game process for monitoring code deployment is achieved through the API interface provided by the operating system, dynamically injecting 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, the monitoring code is written to the allocated memory area through the WriteProcessMemory function, and finally an inter-process communication channel is established. This communication channel uses a named pipe or shared memory. The named pipe creates a server-side pipe through the CreateNamedPipe function. The monitoring code in the game process acts as a client and connects to the pipe through the ConnectNamedPipe function, thus establishing a two-way data transmission channel.

[0046] Based on the established process communication channel, the monitoring code begins to obtain parameters for the gaming software. CPU usage is calculated by calling the GetProcessTimes function to obtain the kernel and user time of the process, and then calculating the ratio of the difference in CPU time between two sampling intervals to the time interval. Memory usage is obtained by using the GetProcessMemoryInfo function to obtain memory metrics such as the process's working set size and page file usage. The working set size reflects physical memory usage, and the page file usage reflects virtual memory usage. The monitoring code collects this data at fixed intervals and transmits it to the control end through the process communication channel.

[0047] Parsing state transitions within the game engine requires in-depth understanding of the game engine's event system. The monitoring code captures state transition events by hooking key game engine functions. This includes intercepting the scene manager's LoadLevel function to detect level switch events and the character controller's ExecuteSkill function to detect skill release events. When a function call is detected, the monitoring code parses the function parameters to obtain detailed event information. Level switch events record the source level ID, target level ID, and switch timestamp, while character skill release events record the character ID, skill ID, release timestamp, and skill duration. This event information is transmitted as structured data over a communication channel.

[0048] The ring buffer data storage and processing uses a circular queue data structure to manage time-sensitive data. The buffer is preset with a fixed size. When new data arrives, it is written to the buffer in chronological order. 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. Each data record contains a data type identifier, timestamp, data value, and validity flag. The buffer uses a read-write pointer separation method. The write pointer is responsible for writing data, and the read pointer is responsible for reading data. The two pointers move independently to avoid data contention. After the data is written to the buffer, the system sets an expiration time according to the timeliness requirements of the data. Data that exceeds the expiration time is automatically marked as invalid.

[0049] Game type identification is achieved by analyzing the characteristic patterns in the time-sensitive data set. Different types of games have different resource usage patterns. First-person shooter games usually show large fluctuations in CPU usage, relatively stable memory usage, and frequent state transition events. Real-time strategy games show continuously high CPU usage, increasing memory usage as the game progresses, and state transition events concentrated in a specific time period. The identification algorithm first calculates the variance value 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 characteristic values ​​with a preset game type feature library. The feature library stores the standard feature value ranges for various game types. The matching process uses Euclidean distance to calculate similarity. The game type with the smallest distance is the identification result.

[0050] In a specific embodiment, the process of executing step S102 may specifically include the following steps: Classify and match the game type identifiers in the operation monitoring data to obtain the game type classification results; Initialize and assign values ​​to weight coefficients based on the game type classification results to obtain an initial weight coefficient combination; Perform least square fitting on the initial weight coefficient combination based on historical operating data to obtain the optimized weight coefficient; Input the operation monitoring data and optimized weight coefficient into the risk assessment function for weighted calculation to obtain the real-time risk calculation value; The real-time risk calculation value is subjected to threshold judgment processing to obtain the risk assessment value.

[0051] Specifically, the game type identifiers in the operational monitoring data are classified and matched through feature vector comparison. The algorithm extracts CPU usage fluctuation patterns, memory usage growth trends, and state transition event distribution characteristics, and then calculates the Euclidean distance with a pre-set game type feature library. The feature library stores the characteristics of moderate CPU usage, gradual memory growth, and concentrated team battle events for MOBA games; high CPU fluctuations, stable memory, and uniform event distribution for FPS games; and low CPU usage, continuous memory growth, and phased event distribution for RPG games. The type with the smallest distance is the classification result. Weight coefficient initialization and assignment are performed based on the game type classification results. MOBA games are assigned a CPU usage weight of 0.4, a memory usage weight of 0.3, and a state transition event weight of 0.3; FPS games are assigned a weight of 0.33 for all three; and RPG games are assigned a memory usage weight of 0.5, a CPU usage weight of 0.3, and a state transition event weight of 0.2, forming an initial weight coefficient combination tailored to the characteristics of different game types.

[0052] The least-squares fitting process optimizes initial weight coefficients using historical operational data. The algorithm collects the correspondence between monitoring indicators and actual risk levels from historical game records, establishes a linear regression model, and solves for the optimal weight coefficient by minimizing the sum of the squares of the difference between the predicted risk value and the actual risk value. The calculation process establishes a system of normal equations and uses matrix operations to obtain the optimized weight coefficients, ensuring that the weight configuration is more closely aligned with the actual game operation characteristics.

[0053] The weighted calculation process combines the operation monitoring data with 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 usage 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 three contribution values ​​are added together and normalized to obtain a real-time risk calculation value between 0 and 1.

[0054] The threshold judgment processing uses preset risk level thresholds to grade and evaluate the real-time risk calculation value, setting below 0.2 as low risk, 0.2 to 0.6 as medium risk, 0.6 to 0.8 as high risk, and above 0.8 as extremely high risk. The risk assessment level is determined based on the range of the real-time risk calculation value.

[0055] In a specific embodiment, the process of performing classification and matching processing on the game type identifiers in the operation monitoring data may specifically include the following steps: Perform hash value calculation on the game software file features in the operation monitoring data to obtain the file feature hash value; Input the file feature hash value into the game type feature library for matching query processing to obtain a preliminary classification identification; Analyze and process the protocol features according to the network communication protocol in the operation monitoring data to obtain the network protocol feature code; Based on the preliminary classification identification and network protocol feature code, a comprehensive judgment process is performed to obtain the confidence level of the game type; Threshold screening is performed on the confidence level of the game type to obtain the game type classification result.

[0056] Specifically, the hash value calculation process for game software file features generates a digital fingerprint of the key features of the game executable file using the 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 then inputs them into the hash function for calculation. The hash algorithm converts the variable-length file feature data into a fixed-length hexadecimal string. The same version of the same game generates the same hash value, while different games or different versions generate different hash values, forming a unique identifier for the game software.

[0057] The file feature hash value is entered into the game type feature library for matching and query processing, using a combination of exact matching and similarity matching. The feature library pre-stores standard hash values ​​for various game types and their corresponding game type tags. The query algorithm first performs an exact match, directly searching to see if the hash value exists in the feature library. If a match is successful, the corresponding game type identifier is returned. If an exact match fails, the algorithm initiates similarity matching mode, calculating the Hamming distance between the query hash value and each hash value in the feature library. Records with a Hamming distance below a preset threshold are considered candidate matches, and the game type with the highest match is returned as the preliminary classification identifier.

[0058] The protocol feature parsing process for network communication protocols uses deep packet inspection (DPI) technology to analyze network data packets during game execution. The algorithm captures network packets sent and received by the game process and analyzes the packet headers for characteristic information such as protocol type, port number, packet size, and communication frequency. Different game types have different network communication modes. MOBA games use UDP for high-frequency small packet communication, FPS games employ a hybrid of TCP and UDP for real-time data synchronization, and RPG games primarily use HTTP for data exchange. The algorithm extracts key features such as communication protocol type, average packet size, communication frequency, and data flow direction, and encodes them into a network protocol signature code.

[0059] The comprehensive judgment process uses multi-dimensional verification based on preliminary classification identifiers and network protocol signatures. The algorithm establishes a two-dimensional judgment matrix, with the horizontal axis representing the preliminary classification identifier derived from file features and the vertical axis representing the game type inference corresponding to the network protocol signature. The judgment algorithm calculates the degree of consistency between the two dimensional results. When the file features and network features point to the same game type, the confidence level is set to 0.9 or above. When the two features point to similar game types, the confidence level is set between 0.6 and 0.8. When the two feature results conflict, the confidence level is set to below 0.5. The algorithm also incorporates historical behavioral characteristics as auxiliary judgment basis, comprehensively calculating the game type confidence value.

[0060] Threshold screening assesses the reliability of game type determinations using pre-set confidence thresholds, with confidence thresholds above 0.8 considered high, 0.6 to 0.8 medium, and below 0.6 low. High-confidence classifications are directly output as the final game type classification results, while medium-confidence classifications require secondary verification with additional features. Low-confidence classifications are marked as unknown and require manual intervention or the default classification strategy.

[0061] In a specific embodiment, the process of executing step S103 may specifically include the following steps: Input the risk assessment value into the game behavior sequence model for state abstraction processing to obtain the game running state sequence; The game running state sequence is processed through the hidden Markov model to predict the behavior trend and obtain the abnormal behavior prediction results; The control strategy level is divided into four levels according to the abnormal behavior prediction results, resulting in resource limitation, function disabling, interaction control and process control. Perform node judgment processing on the decision tree based on the four-level control hierarchy to obtain the control decision path; The control decision path is processed by instruction encoding to obtain hierarchical control instructions.

[0062] Specifically, risk assessment values ​​are input into the game behavior sequence model for state abstraction. This process converts continuous numerical risk assessment results into discrete state identifiers. The state abstraction model predefines a set of typical game operation states, including normal operation, light load, moderate load, heavy load, and critical state. The abstraction algorithm maps states based on the numerical range of the risk assessment value: 0 to 0.2 is mapped to normal operation, 0.2 to 0.4 is mapped to light load, 0.4 to 0.6 is mapped to moderate load, 0.6 to 0.8 is mapped to heavy load, and 0.8 to 1.0 is mapped to critical. The algorithm records the state transition process in a time series, forming a game operation state sequence.

[0063] The game's state sequence is processed using a hidden Markov model for behavioral trend prediction. This model is constructed using a state transition probability matrix and an observation probability matrix. The hidden Markov model consists of a hidden state layer and an observed state layer. The hidden state represents the inherent operating mode of the game system, while the observed state corresponds to the actual monitored state sequence. The model training process uses historical state sequence data to learn state transition probabilities and calculate the probability distribution of transitioning from the current state to the next state. Based on the current observed state sequence and the learned transition probabilities, the prediction algorithm uses a forward algorithm to calculate the probability of each state within a future time window. When the predicted probability of an abnormal state exceeds a set threshold, an abnormal behavior prediction result is generated.

[0064] The results of abnormal behavior predictions are used to classify the control strategy hierarchy. The control intensity is determined based on the severity and impact of the predicted abnormality. The grading algorithm classifies the abnormality prediction results into four levels: minor, moderate, severe, and extremely severe. Minor abnormalities correspond to the resource restriction control level, which intervenes by limiting the upper limit of CPU usage and memory allocation. Moderate abnormalities correspond to the function disable control level, which shuts down non-core game functions and special effects rendering. Severe abnormalities correspond to the interaction control level, which limits the frequency of user input responses and network communication bandwidth. Extremely severe abnormalities correspond to the process control level, which suspends the game process or forcibly terminates program execution.

[0065] The four-level control hierarchy processes node judgments in the decision tree, building a hierarchical decision structure to determine specific control measures. The root node of the decision tree determines the type and severity of anomalies. The first-level child nodes select appropriate control strategy branches based on the game type, and the second-level child nodes select specific control parameters based on the current system resource status. The decision algorithm traverses the decision tree path, performing conditional judgments at each node. Branches that meet the conditions are executed downward, ultimately reaching the leaf node to obtain a specific combination of control measures. The decision path records the complete judgment sequence from the root node to the leaf node, including information on control level selection, parameter settings, and execution priority. The control decision path performs instruction encoding, converting the decision results into system-executable control instructions. The encoding algorithm uses a structured instruction format containing four fields: instruction type, target object, control parameters, and execution timing. Resource restriction instructions are encoded as restriction type, target resource, and restriction value. Function disable instructions are encoded as disable flag, function module, and disable duration. Interaction control instructions are encoded as control type, interaction object, and control strength. Process control instructions are encoded as process operation, target process, and operation parameters. The encoded hierarchical control instructions are sorted by execution priority.

[0066] In a specific embodiment, the process of executing step S104 may specifically include the following steps: Perform dependency analysis on the control targets in the hierarchical control instructions to obtain a dependency graph with a directed acyclic graph structure; Calculate the dependency strength of nodes and edges in the dependency graph to obtain a comprehensive dependency strength value of call frequency, data transmission volume, and criticality; Based on the comprehensive dependency strength value, the control impact range is traced upstream and analyzed downstream to obtain the impact link; Based on the impact link, the path planning process is carried out to minimize the loss, and a scheduling strategy is obtained for phased implementation; The scheduling strategy is processed through early warning notification and step-by-step execution to obtain a control plan.

[0067] Specifically, the control targets within hierarchical control instructions undergo dependency parsing. By analyzing the call relationships and data flows between components in the game system, a dependency model is established. The parsing algorithm identifies the target objects involved in the control instructions, including the rendering engine, physics engine, audio system, network module, and input processing module. The algorithm analyzes the function call relationships, shared memory access, and message passing mechanisms between modules to determine the direction and type of dependency. The rendering engine relies on the physics engine for positional data, the audio system on the rendering engine for spatial information, and the network module on all subsystems for status data. The parsing results form a directed acyclic graph structure, with nodes representing system components and directed edges representing dependency directions.

[0068] Dependency strength calculations are performed on nodes and edges in the dependency graph. The overall dependency strength value is determined by quantifying the importance and impact of each dependency. The calculation algorithm uses three metrics: call frequency, data transfer volume, and criticality between components. Call frequency is measured by monitoring the number of function calls per unit time, data transfer volume is calculated by calculating the number of bytes of data transferred between components, and criticality is weighted based on the component's impact on the overall system functionality. The algorithm normalizes the three metrics and sums them according to their weights, weighting call frequency at 0.4, data transfer volume at 0.3, and criticality at 0.3, resulting in a comprehensive dependency strength value between 0 and 1.

[0069] The scope of control impact is determined by integrating dependency strength values ​​for upstream tracing and downstream analysis. A graph traversal algorithm is used to determine the impact of control operations. The upstream tracing algorithm searches backward along the dependency relationships from the target node, identifying all upper-level components that directly or indirectly depend on the target component. The downstream analysis algorithm searches forward along the dependency relationships from the target node, identifying all lower-level components that depend on the target component. The dependency strength values ​​along the path are recorded during the traversal process. Dependencies with strengths above 0.6 are marked as strong, those between 0.3 and 0.6 as medium, and those below 0.3 as weak. The algorithm integrates upstream and downstream dependency links to form a complete impact chain graph.

[0070] Minimizing loss paths for impacting links is handled through an optimization algorithm that determines the optimal execution sequence for control operations. The planning algorithm formulates a constrained optimization problem with the objective of minimizing system functional loss. The algorithm calculates the impact of different control sequences on overall system performance, prioritizing control objectives with low dependency strength and a small impact range, while deferring control operations for core functional components. The planning results divide control operations into multiple execution phases: the first phase handles peripheral auxiliary functions, the second phase handles medium-important functions, and the third phase handles core functional modules, forming a phased scheduling strategy.

[0071] The scheduling strategy provides early warning notifications and a step-by-step execution process, ensuring the smooth implementation of control operations through a sequential control mechanism. The early warning notification module sends a preparation signal to relevant components before executing a control operation. The notification includes the control type, expected execution time, and scope of impact. The execution processing module implements the control operation step by step according to the scheduling strategy's phases. After each phase, the system status is checked to ensure it meets expectations. In the event of an anomaly, subsequent operations are suspended and a rollback mechanism is initiated. During execution, the response status and performance changes of each component are monitored in real time to ensure that the control effect meets the expected goals. Ultimately, a control plan is generated with detailed execution steps and a timeline.

[0072] In a specific embodiment, the process of executing step S105 may specifically include the following steps: Perform accurate control number statistics on the execution results of the control scheme to obtain the control success rate value; Compare and analyze the game performance indicators before and after the control to obtain the performance retention rate values ​​of the frame rate retention rate and the response time change rate; Quantify the user experience satisfaction based on the user's gaming behavior data to obtain the user experience satisfaction value; The control effect evaluation index value is obtained by performing weighted product calculation based on the control success rate value, performance retention rate value and user experience satisfaction value; The control effect evaluation index value is input into the reinforcement learning algorithm for parameter optimization to obtain the strategy parameter configuration.

[0073] Specifically, accurately counting the number of control attempts made during the execution of a control scheme and obtaining a control success rate is the first step in evaluating its effectiveness. During this process, the system counts the number of successes achieved during multiple executions of the control scheme and calculates its success rate. Specifically, each execution of a control scheme may involve multiple subtasks or operations. The system records the execution results (success or failure) of each task and, based on these records, calculates the ratio of successes to the total number of executions. This control success rate reflects how often the control scheme achieves its intended effect during actual execution and serves as a fundamental indicator 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 operational steps that may require optimization.

[0074] After determining the control success rate, the next step is to analyze and compare the game's performance metrics before and after the control, obtaining performance retention values ​​for the frame rate retention rate and response time change rate. During this process, the system compares and analyzes the performance data before and after the control, focusing primarily on two key performance indicators: frame rate and response time. The frame rate retention rate reflects whether the control scheme successfully maintains the smoothness of the game, while the response time change rate reflects the smoothness of the interaction between the player and the game. By comparing the frame rate data before and after the control, the system can assess the control scheme's impact on the smoothness of the game screen; by comparing the response time data before and after the control, the system can assess the control scheme's impact on the game's interactivity. If the control scheme can increase the frame rate or reduce response time fluctuations without affecting the gaming experience, the performance retention rate will be high, indicating that the control scheme has achieved the desired performance optimization goals.

[0075] After obtaining the control success rate and performance retention rate, the system will quantify the experience satisfaction based on the user's gaming behavior data to obtain a user experience satisfaction value. User behavior data typically includes the user's operation frequency, interaction time, problems encountered during the game, in-game ratings, etc. This data can reflect the user's real experience. By analyzing this data and combining it with the results of the control solution's execution, the system evaluates the user's satisfaction with the gaming experience. If the control solution successfully improves the game's smoothness and responsiveness, user satisfaction will generally increase. The system will calculate a user experience satisfaction value through specific algorithms, such as a weighted score based on behavioral data. This value quantifies the user's satisfaction after the control solution is implemented.

[0076] After obtaining the control success rate, performance retention rate, and user experience satisfaction values, the system performs a weighted product calculation to produce a control effectiveness evaluation index. This weighted product calculation combines these three indicators according to their importance to create a final control effectiveness evaluation value. The weight of each indicator reflects its relative importance in the final evaluation and is typically set based on actual needs and system objectives. 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 may be increased accordingly. By multiplying these weighted values, the system obtains a comprehensive control effectiveness evaluation index that reflects the overall effectiveness of the control solution. This control effectiveness evaluation index value serves as input to the reinforcement learning algorithm for parameter optimization. During this process, the system uses the reinforcement learning algorithm to optimize the control solution parameters to maximize the control effectiveness evaluation index. The reinforcement learning algorithm uses a reward and penalty mechanism to adjust the control strategy and parameters based on changes in the control effectiveness evaluation index, thereby gradually optimizing the control solution. For example, if the current control scheme is ineffective in improving frame rate and response time, the system will adjust the relevant parameters in the control strategy through reinforcement learning, gradually finding the optimal control scheme and ultimately optimizing the overall system performance. In this way, the system can achieve automated strategy optimization, continuously improving the execution of the control scheme through learning, and enhancing the player experience and game operation efficiency.

[0077] The above describes the game software running control method in the embodiment of the present application. The following describes the game software running control system in the embodiment of the present application. Figure 2 In the embodiment of the present application, one embodiment of the game software running control system includes: The acquisition module is used to collect and process the status of the game software through system-level hooks to obtain operation monitoring data; A calculation module, configured to perform weight calculation processing on a risk assessment function using a dynamic weight adjustment algorithm based on the operation monitoring data to obtain a risk assessment value; A prediction module, configured to perform sequence prediction processing on the risk assessment value through a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions; A scheduling module, configured to perform collaborative scheduling processing on the dependency graph according to the hierarchical control instructions to obtain a control solution; The quantification module is used to quantify the effect of the control scheme through the control effect evaluation index to obtain the strategy parameter configuration.

[0078] above Figure 2The game software execution control system in the embodiment of the present invention is described in detail from the perspective of modular functional entities. The game software execution control device in the embodiment of the present invention is described in detail from the perspective of hardware processing.

[0079] Reference Figure 3 In the embodiment of the present invention, a game software operation control device is also provided. The game software operation control device can be a server, and its internal structure can be as follows: Figure 3 As shown. The game software operation control device includes a processor, memory, display screen, input device, network interface and database connected via a system bus. The computer-designed processor is used to provide computing and control capabilities. The memory of the game software operation control device includes 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 operation of the operating system and computer program in the non-volatile storage medium. The database of the game software operation control device is used to store the corresponding data in this embodiment. The network interface of the game software operation control device is used to communicate with an external terminal via a network connection. When the computer program is executed by the processor, the above method is implemented.

[0080] Those skilled in the art will understand that Figure 3 The structure shown in the figure is merely a block diagram of a portion of the structure related to the solution of the present invention, and does not constitute a limitation on the game software running control device to which the solution of the present invention is applied.

[0081] The present invention 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, which, when executed on a computer, cause the computer to execute the steps of the game software operation control method.

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

[0083] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the portion that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions for causing a game software execution control device (which can be a personal computer, server, or network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as a USB flash drive, a mobile hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0084] The above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A method for controlling the operation of game software, characterized in that: The method comprises: The game software status is collected and processed through system-level hooks to obtain operation monitoring data; Performing weight calculation processing on the risk assessment function using a dynamic weight adjustment algorithm based on the operation monitoring data to obtain a risk assessment value; The risk assessment value is subjected to sequence prediction processing by a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions; Performing collaborative scheduling processing on the dependency graph according to the hierarchical control instructions to obtain a control solution; The control scheme is quantified by using control effect evaluation indicators to obtain strategy parameter configuration.

2. The game software operation control method according to claim 1, characterized in that: The operation monitoring data includes CPU usage, memory usage, and state transition events. The operation monitoring data obtained by collecting and processing the state of the game software through the system-level hook includes: Inject system-level hooks into the game process to deploy monitoring code and obtain the process communication channel; Performing parameter acquisition processing on the game software based on the process communication channel to obtain CPU usage and memory usage; Analyze and process state transitions based on internal game engine events to obtain state transition events for level switching and character skill releases; Inputting the CPU usage, memory usage and state transition events into a ring buffer for data storage processing to obtain a time-sensitive data set; The game type identification process is performed on the timeliness data set to obtain the operation monitoring data.

3. The game software operation control method according to claim 1, characterized in that: The weight calculation process of the risk assessment function is performed using a dynamic weight adjustment algorithm according to the operation monitoring data to obtain a risk assessment value, including: Performing classification and matching processing on the game type identifiers in the operation monitoring data to obtain a game type classification result; Initialize and assign values ​​to weight coefficients according to the game type classification results to obtain an initial weight coefficient combination; Performing least squares fitting processing on the initial weight coefficient combination based on historical operation data to obtain optimized weight coefficients; Inputting the operation monitoring data and the optimized weight coefficient into the risk assessment function for weighted calculation processing to obtain a real-time risk calculation value; A threshold judgment process is performed on the real-time risk calculation value to obtain the risk assessment value.

4. The game software operation control method according to claim 3, characterized in that: The classifying and matching the game type identifiers in the operation monitoring data to obtain a game type classification result includes: Performing hash value calculation processing on the game software file features in the operation monitoring data to obtain a file feature hash value; Inputting the file feature hash value into the game type feature library for matching query processing to obtain a preliminary classification identifier; Parsing the protocol features according to the network communication protocol in the operation monitoring data to obtain a network protocol feature code; Performing comprehensive determination based on the preliminary classification identifier and the network protocol feature code to obtain a confidence level of the game type; Threshold screening is performed on the game type confidence to obtain the game type classification result.

5. The game software operation control method according to claim 1, characterized in that: The risk assessment value is subjected to sequence prediction processing by a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions, including: Inputting the risk assessment value into the game behavior sequence model for state abstraction processing to obtain a game running state sequence; Performing behavior trend prediction processing on the game running state sequence using a hidden Markov model to obtain abnormal behavior prediction results; The control strategy level is hierarchically divided according to the abnormal behavior prediction result to obtain a four-level control hierarchy of resource limitation, function disabling, interaction control and process control; Perform node judgment processing on the decision tree based on the four-level control hierarchy to obtain a control decision path; The control decision path is subjected to instruction encoding processing to obtain the hierarchical control instruction.

6. The game software operation control method according to claim 1, characterized in that: The collaborative scheduling process of the dependency graph according to the hierarchical control instructions to obtain a control scheme includes: Perform dependency analysis on the control targets in the hierarchical control instructions to obtain a dependency graph with a directed acyclic graph structure; Performing dependency strength calculation on the nodes and edges in the dependency graph to obtain a comprehensive dependency strength value of call frequency, data transmission volume, and criticality; Perform upstream tracing and downstream analysis on the control impact range according to the comprehensive dependency strength value to obtain an impact link; Performing loss-minimizing path planning based on the impacted links to obtain a scheduling strategy implemented in stages; The scheduling strategy is subjected to early warning notification and step-by-step execution processing to obtain the control plan.

7. The game software operation control method according to claim 1, characterized in that: The control scheme is quantified by using control effect evaluation indicators to obtain strategy parameter configuration, including: Performing statistical processing on the execution results of the control scheme to accurately control the number of times and obtain a control success rate value; Compare and analyze the game performance indicators before and after the control to obtain the performance retention rate values ​​of the frame rate retention rate and the response time change rate; Quantify the user experience satisfaction based on the user's gaming behavior data to obtain the user experience satisfaction value; A weighted product calculation is performed based on the control success rate value, the performance retention rate value, and the user experience satisfaction value to obtain a control effect evaluation index value; The control effect evaluation index value is input into the reinforcement learning algorithm for parameter optimization processing to obtain the strategy parameter configuration.

8. A game software running control system, characterized in that: Used to implement the game software operation control method according to any one of claims 1 to 7, the game software operation control system comprises: The acquisition module is used to collect and process the status of the game software through system-level hooks to obtain operation monitoring data; A calculation module, configured to perform weight calculation processing on a risk assessment function using a dynamic weight adjustment algorithm based on the operation monitoring data to obtain a risk assessment value; A prediction module, configured to perform sequence prediction processing on the risk assessment value through a game behavior sequence intelligent control algorithm to obtain hierarchical control instructions; A scheduling module, configured to perform collaborative scheduling processing on the dependency graph according to the hierarchical control instructions to obtain a control solution; The quantification module is used to quantify the effect of the control scheme through the control effect evaluation index to obtain the strategy parameter configuration.

9. A game software running control device, characterized in that: The game software operation control method comprises a memory and a processor, wherein the memory stores a computer program that can be run on the processor, and when the processor executes the computer program, the game software operation control method according to any one of claims 1 to 7 is implemented.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the processor is caused to execute the game software execution control method according to any one of claims 1 to 7.

Images