Compilation and unified runtime method for game acceleration strategy
By generating runtime decision graphs using the ID-ASL language and dynamic world model, the problems of high integration costs and rigid strategies in game acceleration services are solved, enabling flexible real-time strategy adjustments and intelligent decision-making.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- RAYTHEON (WUHAN) NETWORK TECH CO LTD
- Filing Date
- 2026-02-04
- Publication Date
- 2026-05-15
AI Technical Summary
In existing technologies, the integration and strategy adjustment of game acceleration services are costly, lack flexibility and intelligence, and make it difficult to achieve optimal decision-making based on real-time data.
Acceleration strategies are defined using the intent-driven acceleration strategy language ID-ASL, a runtime decision graph is generated by combining a dynamic world model, and the underlying services are called through a unified adapter layer to realize the compilation of strategies and a unified runtime method.
It reduces redundant investment by developers, improves version iteration efficiency, supports real-time strategy adjustments, breaks vendor lock-in, and enhances system flexibility and autonomy.
Smart Images
Figure CN122044583A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of game acceleration strategy technology, specifically to a method for compiling and unifying the runtime of game acceleration strategies. Background Technology
[0002] In the process of game development and operation, in order to ensure players have a low-latency and high-stability experience in different network environments, developers generally need to integrate third-party game acceleration services. Currently, there are multiple service providers in the market that provide game acceleration capabilities. Each service provider usually provides independent software development kits and application programming interfaces for developers to call. In this model, developers must individually access and adapt to each service provider's SDK.
[0003] In existing technologies, different service providers have different SDK interface specifications, authentication methods, and parameter formats. For each service provider integrated, developers need to relearn its technical documentation, write adaptation code, and conduct functional testing and troubleshooting, forming a "siloed" integration structure. When it is necessary to expand to integrate new service providers or update the API of existing service providers, the development team needs to repeatedly invest a lot of manpower and time, and the cost of version maintenance and iteration continues to accumulate. In addition, in the existing integration methods, acceleration strategies are often embedded in business logic in a hard-coded form, which cannot be dynamically adjusted according to real-time network status, fluctuations in service quality of service providers, or changes in operational strategies. This results in a lack of flexibility and intelligence in acceleration behavior, making it difficult to achieve optimal decision-making based on real-time data. Based on this, this invention designs a compilation and unified runtime method for game acceleration strategies to solve the above problems. Summary of the Invention
[0004] The purpose of this invention is to provide a compilation and unified runtime method for game acceleration strategies, which solves the problems of high time cost and lack of flexibility in the background technology.
[0005] To solve the above-mentioned technical problems, the present invention provides the following technical solution: The compilation and unified runtime method for game acceleration strategies include the following steps: Step S1: Define acceleration strategies based on the intent-driven acceleration strategy language ID-ASL: Use the declarative domain-specific language ID-ASL to write strategy files that are independent of business code to describe the intent and rules for accelerating business; the strategy files include service provider selection conditions, switching trigger conditions, and execution actions; Step S2: Compile and optimize the ID-ASL policy file based on the world model: Input the policy file and a dynamically updated world model into the policy compiler; The world model stores the API interface signatures of each service provider, supported regional nodes, historical performance indicators, and billing model information; The policy compiler performs semantic verification on the policy file according to the world model and compiles it to generate a runtime decision graph; The runtime decision graph is a deterministic finite state machine (DFA), where state nodes represent execution phases and edges represent transitions based on input conditions; Step S3, Execute the runtime decision graph on the client: Integrate the compiled runtime decision graph into the client's general SDK, and through its built-in decision graph execution engine, receive real-time environmental input signals, drive the decision graph state transition, and output a specific service call instruction when the termination state is reached; the environmental input signals include network latency, packet loss rate, and user geographical location; Step S4: Call the underlying service through the unified adapter layer: According to the service call instruction, select the corresponding service provider adapter through the unified adapter layer, convert the standardized instruction into the call format of the specific service provider API and execute it to complete the transparent call of the game acceleration service.
[0006] Preferably, the ID-ASL policy file is a declarative configuration file, the contents of which include: Service provider selection criteria are used to define the rules for selecting service providers based on region, performance indicators, and cost preferences; Switching trigger conditions are used to define rules for triggering service switching based on real-time network performance metrics and changes in service provider status; The execution action specifies the standardized service instruction to be invoked when certain conditions are met.
[0007] Preferably, in step S2, the world model is a versioned knowledge base, the structure of which includes a set of service providers. ; For each service provider p i Define its capability vector Where reg is the set of regions, end represents the list of nodes, lat represents historical delay data, and cos represents billing information; During compilation, the strategy compiler queries C... pi Parse the abstract intent in ID-ASL and bind it to a concrete implementation.
[0008] Preferably, in step S2, the compilation process includes an optimization step: performing static analysis and reorganization on the multi-condition branches in the strategy file, merging redundant judgments, and generating a decision graph with the fewest number of states and the shortest average transition path. The objective function is to minimize the average decision cost T. avg The calculation formula is as follows: ; Where S is the set of states, P(s) is the access probability of state s, and t(s) is the processing time in state s.
[0009] Preferably, in step S3, the state transition process of the decision graph execution engine is formally described as follows: given the current state and input vector x t Where Q is the state set, x t Including real-time environmental signals, the transfer function δ is executed, as shown in the following formula: ; Until the output state is reached ; And execute the associated output action, namely the service invocation instruction.
[0010] Preferably, in step S4, the unified adapter layer maintains an adapter registry, and each service provider adapter implements a unified interface execute(instruction), where instruction is a standardized calling instruction; the adapter internally encapsulates the service provider SDK initialization, authentication, parameter assembly, and asynchronous callback processing logic.
[0011] Preferably, the method is implemented based on the following modules: The policy definition module provides an environment for editing and validating the ID-ASL language and generating policy files. The policy compiler connects to the world model database and is used to compile and optimize policy files into runtime decision graphs. The client SDK has an embedded decision graph execution engine, which is used to load and execute the runtime decision graph and generate service call instructions based on real-time input. The unified adapter layer, deployed on the client, is used to receive the service call instructions and call the corresponding service provider adapter to execute the specific API call.
[0012] Preferably, the world model database is a cloud service that supports dynamic updates; the policy compiler is an offline and online service that receives policy files and a current world model snapshot, and outputs the compiled decision. Figure 2 Number bases.
[0013] Preferably, it further includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it is able to control the electronic device to perform the following functions: Obtain strategy files and world model data; The execution strategy compilation logic is used to generate a runtime decision graph. During game execution, the runtime decision graph is executed based on real-time environmental parameters to generate service call instructions; The service call instruction is executed through a unified adapter interface to invoke the corresponding third-party game acceleration service.
[0014] Preferably, when the computer program is executed by the processor, the instructions stored in the storage medium include compilation instructions for processing the policy file, state machine execution instructions for driving the decision graph, and service scheduling instructions for invoking the unified adapter layer.
[0015] Compared with the prior art, the beneficial effects achieved by the present invention are: 1. This invention decouples business intent from the underlying service provider SDK through a unified strategy definition language and compilation system. Developers no longer need to repeatedly write adaptation code for each service provider, learn heterogeneous API specifications, or conduct independent testing, thus avoiding the redundant investment of siloed integration. When a new service provider is added or an existing API is updated, only the strategy file needs to be adjusted and recompiled, without modifying the business code, greatly reducing manpower and time costs and improving version iteration efficiency.
[0016] 2. In this invention, declarative ID-ASL policy files are independent of business code, supporting dynamic adjustment of policies based on real-time network status and service provider quality fluctuations. Localized intelligent decision-making is achieved through a runtime decision graph generated during compilation. Policies can be independently hot-updated without redeploying clients, enabling operators to quickly respond to environmental changes and achieve optimal service selection and switching based on real-time data, completely overcoming the rigidity of hard-coded policies.
[0017] 3. In this invention, by abstracting the APIs of heterogeneous service providers through a unified adapter layer, the upper-layer strategy logic only focuses on standardized instructions and does not need to be aware of specific implementation details. This not only reduces the complexity of the system, but also gives developers the ability to flexibly replace or expand service providers, fundamentally breaking the vendor lock-in and enhancing the autonomy and business space of technology selection. Attached Figure Description
[0018] Figure 1 This is a flowchart illustrating the overall process of the method of the present invention. Figure 2 This is a system module architecture diagram of the present invention. Detailed Implementation
[0019] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.
[0020] Example 1; Please see Figures 1-2 The compilation and unified runtime method for game acceleration strategies include the following steps: Step S1: Define acceleration strategies based on the intent-driven acceleration strategy language ID-ASL: Use the declarative domain-specific language ID-ASL to write strategy files that are independent of business code to describe the intent and rules for accelerating business; the strategy files include service provider selection conditions, switching trigger conditions, and execution actions; Step S2: Compile and optimize the ID-ASL policy file based on the world model: Input the policy file and a dynamically updated world model into the policy compiler; The world model stores the API interface signatures of each service provider, supported regional nodes, historical performance indicators, and billing model information; The policy compiler performs semantic verification on the policy file based on the world model and compiles it to generate a runtime decision graph; The runtime decision graph is a deterministic finite state machine (DFA), where state nodes represent execution phases and edges represent transitions based on input conditions; Step S3, Execute the runtime decision graph on the client: Integrate the compiled runtime decision graph into the client's general SDK, and through its built-in decision graph execution engine, receive real-time environmental input signals, drive the decision graph state transition, and output a specific service call instruction when the termination state is reached; environmental input signals include network latency, packet loss rate, and user geographical location; Step S4: Call the underlying service through the unified adapter layer: Based on the service call instruction, select the corresponding service provider adapter through the unified adapter layer, convert the standardized instruction into the call format of the specific service provider's API and execute it to complete the transparent call of the game acceleration service.
[0021] The ID-ASL policy file is a declarative configuration file, and its contents include: Service provider selection criteria are used to define the rules for selecting service providers based on region, performance indicators, and cost preferences; Switching trigger conditions are used to define rules for triggering service switching based on real-time network performance metrics and changes in service provider status; The execution action specifies the standardized service instruction to be invoked when certain conditions are met.
[0022] In step S2, the world model is a versioned knowledge base, the structure of which includes a set of service providers. ; For each service provider p i Define its capability vector Where reg is the set of regions, end represents the list of nodes, lat represents historical delay data, and cos represents billing information; During compilation, the strategy compiler queries C... pi Parse the abstract intent in ID-ASL and bind it to a concrete implementation.
[0023] In step S2, the compilation process includes optimization steps: static analysis and reorganization of multi-condition branches in the strategy file, merging redundant judgments, and generating a decision graph with the fewest number of states and the shortest average transition path. The objective function is to minimize the average decision cost T. avg The calculation formula is as follows: ; Where S is the set of states, P(s) is the access probability of state s, and t(s) is the processing time in state s.
[0024] In step S3, the state transition process of the decision graph execution engine is formally described as follows: given the current state and input vector x t Where Q is the state set, x t Including real-time environmental signals, the transfer function δ is executed, as shown in the following formula: ; Until the output state is reached ; And execute the associated output action, namely the service invocation command.
[0025] In step S4, the unified adapter layer maintains an adapter registry, and each service provider adapter implements a unified interface execute(instruction), where instruction is a standardized calling command; the adapter encapsulates the service provider SDK's initialization, authentication, parameter assembly, and asynchronous callback processing logic.
[0026] The working principle of this invention is as follows: First, in the strategy definition phase, developers use declarative ID-ASL to write a strategy file independent of business code. This file describes the intent and rules for accelerating business in a high-level abstraction, including service provider selection conditions, switching trigger conditions, and execution actions. The declarative nature of ID-ASL decouples business logic from the underlying implementation, avoids the rigidity of hard coding, and improves the flexibility and maintainability of the strategy.
[0027] Next, during the compilation and optimization phase, the policy file and a dynamically updated world model are input into the policy compiler. The world model, serving as a versioned knowledge base, stores the API signatures of each service provider, supported geographic nodes, historical performance metrics, and billing model information. Its structure is formally represented as a set of service providers P and a capability vector C for each service provider, where reg is the geographic set, end is the node list, lat is historical latency data, and cos is billing information. The compiler performs semantic validation of the ID-ASL policy by querying C, binding the abstract intent to the concrete implementation, and generates a runtime decision graph through static analysis and optimization. This decision graph is a deterministic finite state machine, where state nodes represent execution phases and edges represent transitions based on input conditions. The optimization objective is to minimize the average decision cost T, thereby ensuring the minimum number of states in the decision graph and the shortest average transition path, improving runtime efficiency.
[0028] Then, during the client execution phase, the compiled runtime decision graph is integrated into the client's general SDK, driving state transitions through its built-in decision graph execution engine. The engine receives real-time environmental input signals, such as network latency, packet loss rate, and user geolocation. Formally, it is described as follows: given the current state and input vector, it executes the transition function until the output state is reached, and outputs specific service call instructions.
[0029] Finally, during the service invocation phase, the service invocation instructions are executed through a unified adapter layer. The adapter layer maintains an adapter registry, and each service provider adapter implements a unified `execute(instruction)` interface, where `instruction` represents the standardized invocation command. Internally, the adapter encapsulates the service provider SDK's initialization, authentication, parameter assembly, and asynchronous callback processing logic, converting the standardized commands into the specific service provider's API invocation format and executing them. This achieves transparent invocation of the game acceleration service, ensuring isolation between upper-layer strategies and underlying heterogeneous APIs, and resolving issues of high integration costs and vendor lock-in.
[0030] Example 2; Please see Figures 1-2 In this embodiment of the invention, the method is implemented based on the following modules: The policy definition module provides an environment for editing and validating the ID-ASL language and generating policy files. The policy compiler connects to the world model database and is used to compile and optimize policy files into runtime decision graphs. The client SDK has an embedded decision graph execution engine, which is used to load and execute the runtime decision graph and generate service call instructions based on real-time input. The unified adapter layer, deployed on the client, is used to receive service call instructions and invoke the corresponding service provider adapter to execute specific API calls.
[0031] The world model database is a cloud-based service that supports dynamic updates; the policy compiler is a dual-service (offline and online) that receives policy files and a snapshot of the current world model, and outputs the compiled decision. Figure 2 Number bases.
[0032] The working principle of this invention is as follows: The invention utilizes a modular architecture, including a policy definition module, a policy compiler, a client SDK, and a unified adapter layer. These modules work collaboratively to improve the system's scalability and maintainability. The policy definition module provides an editing and validation environment for the ID-ASL language, generating policy files that conform to syntax and semantics, ensuring the accuracy and consistency of intent expression, thereby reducing the learning cost for developers and supporting independent version management of policies.
[0033] The strategy compiler module connects to a world model database, a cloud-based service that supports dynamic updates to reflect changes in service provider information. The compiler, operating offline or online, receives strategy files and a snapshot of the current world model. By querying the capabilities within the world model, it binds abstract rules from ID-ASL to specific service provider implementations and performs compilation optimization. The optimization process includes static analysis and reorganization of multi-conditional branches to generate runtime decisions with the fewest states and the shortest average transition path. Figure 2 The radix-based approach optimizes the objective function, ensuring efficient decision-making. The compiled output can be integrated into the client as a resource package, supporting hot updates and allowing strategy adjustments without modifying business logic.
[0034] The client SDK module embeds a decision graph execution engine, responsible for loading and executing the runtime decision graph. During game runtime, the engine receives real-time environmental input signals, drives the decision graph state transitions, and generates service call instructions from the output state. This localized execution avoids network latency, achieves millisecond-level decision response, and improves the user experience.
[0035] The unified adapter layer module is deployed on the client side. After receiving service call instructions, it selects the corresponding service provider adapter through the adapter registry and performs the conversion of standardized instructions into API calls. The adapter encapsulates the heterogeneous details of various service provider SDKs, providing a unified interface and ensuring the reliability of calls and asynchronous processing capabilities. Through modular design, this invention achieves full-process automation from policy definition to execution, reduces system coupling, supports rapid integration of new service providers or adjustment of policies, and demonstrates the engineering advantages of high cohesion and low coupling.
[0036] Example 3; Please see Figures 1-2In this embodiment of the invention, a memory, a processor, and a computer program stored in the memory and capable of running on the processor are also included. When the processor executes the program, it can control the electronic device to perform the following functions: acquire strategy files and world model data; execute strategy compilation logic to generate a runtime decision graph; execute the runtime decision graph based on real-time environmental parameters during game runtime to generate service call instructions; and execute the service call instructions through a unified adapter interface to call the corresponding third-party game acceleration service.
[0037] When the computer program is executed by the processor, the instructions stored in the storage medium include compilation instructions for processing policy files, state machine execution instructions for driving the decision graph, and service scheduling instructions for invoking the unified adapter layer.
[0038] The working principle of this invention is as follows: The working principle of this invention is implemented through a computer program, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it controls the electronic device to perform the following functions: acquire strategy files and world model data; execute strategy compilation logic to generate a runtime decision graph; during game runtime, execute the decision graph based on real-time environmental parameters to generate service call instructions; and call the corresponding third-party game acceleration service through a unified adapter interface.
[0039] The program includes compilation instructions for processing policy files, state machine execution instructions for driving the decision graph, and service scheduling instructions for invoking the unified adapter layer. The compilation instructions parse and optimize the ID-ASL policy based on world model data, compiling the intent into an efficient DFA decision graph. The optimization process uses static analysis to reduce state redundancy and ensure minimal decision overhead. The state machine execution instructions receive environmental input signals at runtime, driving state transitions and achieving adaptive decision-making without external intervention. The service scheduling instructions call specific services through the unified adapter layer. The adapter implements the `execute(instruction)` interface, handling API conversion and asynchronous callbacks to ensure reliable calls.
[0040] How it works: Developers use declarative ID-ASL to write policy files independent of business code, defining abstract intents such as service provider selection, switching conditions, and execution actions. Then, the policy compiler, combined with a dynamically updated world model, performs semantic verification and optimization on the policy files, compiling them into a runtime decision graph in the form of an efficient deterministic finite state machine, aiming to minimize average decision overhead. Subsequently, at client runtime, the decision graph execution engine integrated in the SDK receives real-time environmental signals such as network latency and geographical location, driving the state machine to quickly transition and generating specific standardized service call instructions in the output state. Finally, a unified adapter layer translates these instructions into calls to specific service provider APIs and executes them. The adapter encapsulates the heterogeneous details of various service provider SDKs. The entire working principle, through a closed loop of "intent definition - compilation optimization - local decision - unified call," achieves decoupling of business logic from the underlying implementation, dynamic and agile adjustment of policies, and low-cost integration and intelligent optimization across service providers.
[0041] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit, the scope of which is defined by the appended claims and their equivalents.
Claims
1. A compilation and unified runtime method for game acceleration strategies, characterized in that, Includes the following steps: Step S1: Define acceleration strategies based on the intent-driven acceleration strategy language ID-ASL: Use the declarative domain-specific language ID-ASL to write strategy files that are independent of business code to describe the intent and rules for accelerating business; the strategy files include service provider selection conditions, switching trigger conditions, and execution actions; Step S2: Compile and optimize the ID-ASL policy file based on the world model: Input the policy file and a dynamically updated world model into the policy compiler; The world model stores the API interface signatures of each service provider, supported regional nodes, historical performance indicators, and billing model information; The policy compiler performs semantic verification on the policy file according to the world model and compiles it to generate a runtime decision graph; The runtime decision graph is a deterministic finite state machine (DFA), where state nodes represent execution phases and edges represent transitions based on input conditions; Step S3, Execute the runtime decision graph on the client: Integrate the compiled runtime decision graph into the client's general SDK, and through its built-in decision graph execution engine, receive real-time environmental input signals, drive the decision graph state transition, and output a specific service call instruction when the termination state is reached; the environmental input signals include network latency, packet loss rate, and user geographical location; Step S4: Call the underlying service through the unified adapter layer: According to the service call instruction, select the corresponding service provider adapter through the unified adapter layer, convert the standardized instruction into the call format of the specific service provider API and execute it to complete the transparent call of the game acceleration service.
2. The compilation and unified runtime method for the game acceleration strategy according to claim 1, characterized in that, The ID-ASL policy file is a declarative configuration file, and its contents include: Service provider selection criteria are used to define the rules for selecting service providers based on region, performance indicators, and cost preferences; Switching trigger conditions are used to define rules for triggering service switching based on real-time network performance metrics and changes in service provider status; The execution action specifies the standardized service instruction to be invoked when certain conditions are met.
3. The compilation and unified runtime method for the game acceleration strategy according to claim 1, characterized in that, In step S2, the world model is a versioned knowledge base, the structure of which includes a set of service providers. ; For each service provider p i Define its capability vector Where reg is the set of regions, end represents the list of nodes, lat represents historical delay data, and cos represents billing information; During compilation, the strategy compiler queries C... pi Parse the abstract intent in ID-ASL and bind it to a concrete implementation.
4. The compilation and unified runtime method for the game acceleration strategy according to claim 1, characterized in that: In step S2, the compilation process includes an optimization step: performing static analysis and reorganization on the multi-condition branches in the strategy file, merging redundant judgments, and generating a decision graph with the fewest number of states and the shortest average transition path. The objective function is to minimize the average decision cost T. avg The calculation formula is as follows: ； Where S is the set of states, P(s) is the access probability of state s, and t(s) is the processing time in state s.
5. The compilation and unified runtime method for the game acceleration strategy according to claim 1, characterized in that: In step S3, the state transition process of the decision graph execution engine is formally described as follows: given the current state and input vector x t Where Q is the state set, x t Including real-time environmental signals, the transfer function δ is executed, as shown in the following formula: ； Until the output state is reached ; And execute the associated output action, namely the service invocation instruction.
6. The compilation and unified runtime method for the game acceleration strategy according to claim 1, characterized in that, In step S4, the unified adapter layer maintains an adapter registry, and each service provider adapter implements a unified interface execute(instruction), where instruction is a standardized calling command; The adapter internally encapsulates the service provider's SDK initialization, authentication, parameter assembly, and asynchronous callback processing logic.
7. The compilation and unified runtime method for the game acceleration strategy according to claim 1, characterized in that, The method is implemented based on the following modules: The policy definition module provides an environment for editing and validating the ID-ASL language and generating policy files; The policy compiler connects to the world model database and is used to compile and optimize policy files into runtime decision graphs. The client SDK has an embedded decision graph execution engine, which is used to load and execute the runtime decision graph and generate service call instructions based on real-time input. The unified adapter layer, deployed on the client, is used to receive the service call instructions and call the corresponding service provider adapter to execute the specific API call.
8. The compilation and unified runtime method for the game acceleration strategy according to claim 7, characterized in that: The world model database is a cloud service that supports dynamic updates; the policy compiler is an offline and online service that receives policy files and current world model snapshots and outputs compiled decision graph binary packages.
9. The compilation and unified runtime method for the game acceleration strategy according to claim 1, characterized in that, It also includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it is able to control the electronic device to perform the following functions: Obtain strategy files and world model data; The execution strategy compilation logic is used to generate a runtime decision graph. During game execution, the runtime decision graph is executed based on real-time environmental parameters to generate service call instructions; The service call instruction is executed through a unified adapter interface to invoke the corresponding third-party game acceleration service.
10. The compilation and unified runtime method for the game acceleration strategy according to claim 9, characterized in that: When the computer program is executed by the processor, the instructions stored in the storage medium include compilation instructions for processing policy files, state machine execution instructions for driving the decision graph, and service scheduling instructions for invoking the unified adapter layer.