A method for realizing game acceleration in an iOS jailbreak-free environment

Abstract

The application belongs to the technical field of iOS mobile development, and particularly relates to a method for realizing game acceleration in an iOS jailbreak-free environment, which comprises a static reconstruction subsystem, a runtime interception subsystem, a strategy scheduling subsystem, a security and recovery subsystem, and a combination use method of the systems as follows: S1, Mach-O files of a target application are analyzed, code injection is carried out, and a mapping table is generated in an offline stage; S2, the target application is embedded; S3, time virtualization, rendering scheduling, network optimization and resource preloading modules are provided; and S4, mapping table integrity is checked, and a signature state is verified. The application realizes high compatibility and non-intrusive deep performance optimization, carries out static analysis and reconstruction on an application installation package in an offline stage, accurately locates a key function by analyzing an internal structure, and injects customized code signed by a developer, so that the modified application can pass system security verification and be installed normally.

Description

Technical Field

[0001] This invention belongs to the field of iOS mobile development technology, specifically a method for accelerating games in an iOS environment without jailbreaking. Background Technology

[0002] Currently, in the mobile gaming industry, users have increasingly higher demands for gaming experience, especially in terms of real-time performance, smoothness, and stability. To improve game performance, common optimization methods include adjusting in-game graphics settings, reducing special effects levels, and limiting frame rates. However, these methods often rely on settings options provided by game developers, have limited functionality, and cannot fundamentally change the underlying execution logic of the game.

[0003] On the iOS platform, due to the closed nature of the system and the limitations of security mechanisms, traditional system-level hooking technology usually requires jailbreaking the device to achieve this. In a jailbroken environment, users can obtain root privileges and then use tools such as CydiaSubstrate and Frida to intercept and replace system calls, dynamic library functions, or Objective-C methods at runtime. Although these methods are powerful and can achieve complete control over key points such as time functions, rendering loops, and network I / O, they also have obvious drawbacks.

[0004] As mobile games increasingly demand real-time performance, such as frame rate, latency, and stability, various technologies have been developed to optimize game performance or implement acceleration features. However, the following three main problems still exist:

[0005] 1. Most existing game acceleration solutions rely on system-level hook frameworks, such as Substrate, Frida, or jailbroken devices, to achieve acceleration by intercepting system calls at runtime. While these methods are powerful, they cannot be used by ordinary users on non-jailbroken devices. Furthermore, runtime hooking, especially inline hooking, is prone to causing process crashes or system instability, severely impacting user experience and device security.

[0006] 2. Among the existing improvement methods, the adjustment of client-side in-game settings depends on the limited options provided by the game developer; solutions based on network proxies or link acceleration can only optimize network transmission and cannot directly affect local rendering loops, logical frame scheduling, or resource loading behavior, so it is difficult to achieve a comprehensive game acceleration effect.

[0007] 3. While existing technologies can alter program behavior through static modification of Mach-O files, most solutions lack co-design with runtime modules, making it difficult to re-sign and securely run the modified code in a non-jailbroken environment. Furthermore, static modifications are difficult to revert once effective; if compatibility issues or abnormal behavior occur, it's impossible to quickly restore the original code path, leading to debugging difficulties and high risks. Summary of the Invention:

[0008] This invention provides a method for accelerating games in an iOS environment without jailbreaking. By optimizing time virtualization, rendering loop scheduling, resource caching, and network scheduling within the application, the method can adjust the game's running speed and improve its performance.

[0009] To address the aforementioned issues, this invention provides a technical solution: a method for accelerating games in an iOS jailbreak-free environment, comprising: a static reconstruction subsystem, a runtime interception subsystem, a strategy scheduling subsystem, and a security and recovery subsystem;

[0010] The combined usage of the static reconstruction subsystem, runtime interception subsystem, policy scheduling subsystem, and security and recovery subsystem is as follows:

[0011] S1. In the offline phase, the Mach-O files of the target application are parsed, code is injected, and a mapping table is generated.

[0012] S2, embedded within the target application, is responsible for loading the mapping table and executing controlled runtime function jumps at startup;

[0013] S3 provides time virtualization, rendering scheduling, network optimization and resource preloading modules, and supports dynamic speedup adjustment and abnormal rollback;

[0014] The time virtualization module includes a multi-path interceptor, a time scaler, and a drift compensator.

[0015] The rendering scheduling module includes a frame callback interceptor, a frame rate controller, and a load sensor.

[0016] The network scheduling and resource preloading module includes a request priority scheduler and a preloading decision-maker;

[0017] The dynamic acceleration strategy module includes a device status monitor, a behavior analyzer, and an acceleration ratio adjuster.

[0018] S4. Verify the integrity of the mapping table, verify the signature status, and restore the original code path when an anomaly is detected;

[0019] The system achieves controllable acceleration of game execution speed on non-jailbroken devices through a two-stage collaboration of static and runtime processes.

[0020] Preferably, the static reconfiguration subsystem includes:

[0021] The Mach-O parsing module is used to parse LoadCommand, segment structure, symbol table and relocation information to locate the entry address of the target function.

[0022] The code injection module inserts trampoline code, hook function bodies, and the original instruction backup area into the executable segment or the newly created _HOOK_TEXT segment of Mach-O.

[0023] The mapping table generation module generates a structured mapping table containing the original address, injection address, patch type, symbol name and version information, and embeds it into the _HOOK_DATA segment;

[0024] The re-signing module uses the developer certificate to re-sign the modified Mach-O file, ensuring that it passes iOS's AMFI and dyld verification.

[0025] Preferably, the runtime interception subsystem includes:

[0026] The mapping table loader reads and parses the mapping table from the _HOOK_DATA segment before the main() function is executed or during the module initialization phase;

[0027] The memory control unit temporarily removes the write protection of the target memory page through the mprotect() system call, writes a jump instruction using an atomic instruction, and then restores the memory protection attribute;

[0028] The jump execution unit selects the jump method based on the patch_type field in the mapping table, including jumping directly to the hook function, forwarding via trampoline, or jumping back after executing the original instruction backup.

[0029] Preferably, the time virtualization module includes:

[0030] A multi-path interceptor that covers system time functions, engine tick methods, and Objective-C timers;

[0031] The time scaler calculates virtual time based on the following formula:

[0032]

[0033] in: For virtual time, For virtual time baseline, Where S is the current real time, and S is the acceleration factor;

[0034] Drift compensator, through periodic calibration and To mitigate deviations and prevent timing anomalies caused by accumulated errors.

[0035] Preferably, the rendering scheduling module includes:

[0036] Frame callback interceptors can hook the entry point of the rendering loop in the engine or system.

[0037] Frame rate controller, based on target frame rate Compared to the actual frame rate The difference is used to dynamically adjust the timing of the rendering callback, and its scheduling strategy is based on the following formula:

[0038]

[0039] like If the value is greater than 0, then rendering is delayed; otherwise, it is triggered earlier.

[0040] Load sensors dynamically adjust based on device CPU / GPU utilization. To avoid overheating or frame drops caused by excessive acceleration.

[0041] Preferably, the network scheduling and resource preloading module includes:

[0042] The request priority scheduler dynamically adjusts the concurrency order and timeout of network requests based on the game scenario. The priority calculation formula is as follows:

[0043]

[0044] in: , , Here, A represents the round-trip time, B represents the packet loss rate, and C represents the resource urgency.

[0045] The preload decision maker, based on a player behavior prediction model, preloads resources that may be used. Its prediction algorithm is based on a Markov chain model, and the state transition probability is calculated from the historical operation sequence.

[0046] Preferably, the dynamic acceleration strategy module includes:

[0047] The device status monitor collects CPU utilization, memory usage, network latency, and power levels in real time.

[0048] The behavior analyzer identifies the current game stage based on in-game operation frequency, scene switching frequency, and resource loading mode.

[0049] The speedup adjuster dynamically adjusts the speedup coefficient S based on the following multi-factor decision model:

[0050]

[0051] in: , , The risk level is an adjustment factor applicable to the current game stage;

[0052] Preferably, the security and recovery subsystem includes an instruction backup and recovery mechanism, which includes:

[0053] The original instruction backup area retains the first few instructions of the overwritten original function in the _HOOK_TEXT segment;

[0054] The context saver saves the register state and stack frame contents to non-volatile memory before jumping to the hook function;

[0055] The instruction restorer writes the backup instructions back to their original address and restores the register context during rollback or exception handling, ensuring that the original function can continue to execute.

[0056] Preferably, the static refactoring subsystem or runtime interception subsystem includes a multi-engine adaptation module, which includes:

[0057] Engine symbol mapping table, pre-set with key function symbols and offsets for mainstream game engines such as Unity, Cocos2d-x, and Unreal;

[0058] The engine feature identifier identifies the target engine type by using Mach-O segment names, symbol names, and code patterns;

[0059] The automatic hook configurator automatically selects predefined hook points and redirection strategies based on the recognition results, improving adaptation efficiency.

[0060] Preferably, the safety and rollback subsystem includes:

[0061] Integrity verifier, using SHA-256 hash to verify the integrity of the mapping table and the hook code segment;

[0062] The signature verifier verifies the application's signature status at runtime and triggers a rollback if it detects unauthorized modifications.

[0063] Anomaly detection and rollback triggers rollback based on the following conditions: abnormal function execution time, abnormal stack pointer offset, and mismatch between acceleration strategy and device state.

[0064] The rollback process includes: restoring the original instructions, clearing the jump code, resetting the time baseline, and logging exceptions for debugging.

[0065] The core processing advantages of the above content:

[0066] 1. Jailbreak-free deployment: Through static reconstruction and signing process, the final product can be installed on non-jailbroken devices. At runtime, it only makes controlled memory modifications and does not rely on privileges.

[0067] 2. High accuracy: The address is determined and the jump table is inserted in the static stage, and the mapping table is used for precise positioning at runtime, avoiding the uncertainty caused by a large number of lookups or matches at runtime;

[0068] 3. Stability and rollback capability: The mapping table and trampolines support the restoration of the original path, and can be quickly rolled back in case of anomalies;

[0069] 4. Modular SDK: Abstracts acceleration capabilities into modules, making them easy to reuse and combine as needed in different projects;

[0070] 5. Scalable: Static tools can generate corresponding mappings and patches for different iOS or CPU architectures, and support multi-version management.

[0071] The beneficial effects of this invention are:

[0072] 1. This invention achieves high compatibility and non-intrusive deep performance optimization. In the offline stage, the application installation package is statically analyzed and reconstructed. By parsing its internal structure, key functions are accurately located and custom code signed by the developer is injected. This allows the modified application to pass the system security verification and be installed normally. When the application is running, the system dynamically loads the preset mapping table in memory and takes over core system calls such as time acquisition, rendering loop, and network requests. By virtualizing the time base, intelligently scheduling the rendering frame rate and network request priority, the system changes the game's running rhythm and resource loading strategy from the bottom layer, thereby achieving a deep acceleration effect. The whole process does not require jailbreaking and is non-intrusive to the system itself.

[0073] 2. This invention possesses intelligent dynamic adjustment and risk control capabilities, ensuring a stable and reliable acceleration process. The system incorporates a multi-dimensional monitoring and decision-making mechanism, continuously collecting data on the device's CPU load, memory, network, and battery status. Simultaneously, it analyzes the user's in-game actions, intelligently determining the current game scenario. Based on this real-time information, a comprehensive decision-making model dynamically calculates and adjusts the acceleration intensity. When the device load is too high or a high-risk operation is detected, the system automatically reduces the acceleration ratio to prevent application crashes or device overheating, ensuring that the acceleration strategy always matches the actual performance of the device and the current game requirements, thereby maintaining application stability while increasing speed.

[0074] 3. This invention constructs a multi-layered security protection and self-repair system to effectively resist operational risks. To ensure the security of the entire acceleration system, a comprehensive protection scheme from code to runtime state is designed. Before loading any code, the system verifies its integrity and digital signature to prevent malicious tampering. During runtime, it continuously monitors key indicators such as function execution time and stack pointer for anomalies. Once any abnormal state that does not conform to expectations is detected, such as invalid signature or disordered execution logic, the system will immediately trigger a rollback mechanism, which can automatically remove injected jump code, restore the backed-up original instructions to their original positions in memory, and reset the modified system state, enabling the application to quickly switch back to the original, secure code path and continue to run normally, thereby minimizing program crashes or data errors caused by acceleration modifications. Attached image description:

[0075] For ease of explanation, the present invention will be described in detail below with reference to specific embodiments and accompanying drawings.

[0076] Figure 1 This is a schematic diagram of the system architecture of the present invention;

[0077] Figure 2 This is a flowchart of the static reconstruction process of the present invention;

[0078] Figure 3 This is a flowchart of the runtime Hook process of the present invention;

[0079] Figure 4 This is a schematic diagram illustrating the jump relationship between trampolines and the original function in this invention. Detailed implementation method:

[0080] Example 1

[0081] like Figures 1-4 As shown, this specific implementation adopts the following technical solution: a method for accelerating games in an iOS jailbreak-free environment, including: a static reconstruction subsystem, a runtime interception subsystem, a strategy scheduling subsystem, and a security and recovery subsystem;

[0082] The combined usage of the static refactoring subsystem, runtime interception subsystem, policy scheduling subsystem, and security and recovery subsystem is as follows:

[0083] S1. In the offline phase, the Mach-O files of the target application are parsed, code is injected, and a mapping table is generated.

[0084] S2, embedded within the target application, is responsible for loading the mapping table and executing controlled runtime function jumps at startup;

[0085] S3 provides time virtualization, rendering scheduling, network optimization and resource preloading modules, and supports dynamic speedup adjustment and abnormal rollback;

[0086] The time virtualization module includes a multi-path interceptor, a time scaler, and a drift compensator.

[0087] The rendering scheduling module includes a frame callback interceptor, a frame rate controller, and a load sensor.

[0088] The network scheduling and resource preloading module includes a request priority scheduler and a preloading decision-maker;

[0089] The dynamic acceleration strategy module includes a device status monitor, a behavior analyzer, and an acceleration ratio adjuster.

[0090] S4. Verify the integrity of the mapping table, verify the signature status, and restore the original code path when an anomaly is detected;

[0091] The system achieves controllable acceleration of game execution speed on non-jailbroken devices through a two-stage collaboration of static and runtime processes.

[0092] The static reconfiguration subsystem includes:

[0093] The Mach-O parsing module is used to parse LoadCommand, segment structure, symbol table and relocation information to locate the entry address of the target function.

[0094] The code injection module inserts trampoline code, hook function bodies, and the original instruction backup area into the executable segment or the newly created _HOOK_TEXT segment of Mach-O.

[0095] The mapping table generation module generates a structured mapping table containing the original address, injection address, patch type, symbol name and version information, and embeds it into the _HOOK_DATA segment;

[0096] The re-signing module uses the developer certificate to re-sign the modified Mach-O file, ensuring that it passes iOS's AMFI and dyld verification.

[0097] The runtime interception subsystem includes:

[0098] The mapping table loader reads and parses the mapping table from the _HOOK_DATA segment before the main() function is executed or during the module initialization phase;

[0099] The memory control unit temporarily removes the write protection of the target memory page through the mprotect() system call, writes a jump instruction using an atomic instruction, and then restores the memory protection attribute;

[0100] The jump execution unit selects the jump method based on the patch_type field in the mapping table, including jumping directly to the hook function, forwarding via trampoline, or jumping back after executing the original instruction backup.

[0101] The time virtualization module includes:

[0102] A multi-path interceptor that covers system time functions, engine tick methods, and Objective-C timers;

[0103] The time scaler calculates virtual time based on the following formula:

[0104]

[0105] in: For virtual time, For virtual time baseline, Where S is the current real time, and S is the acceleration factor;

[0106] Drift compensator, through periodic calibration and To mitigate deviations and prevent timing anomalies caused by accumulated errors.

[0107] The rendering scheduling module includes:

[0108] Frame callback interceptors can hook the entry point of the rendering loop in the engine or system.

[0109] Frame rate controller, based on target frame rate Compared to the actual frame rate The difference is used to dynamically adjust the timing of the rendering callback, and its scheduling strategy is based on the following formula:

[0110]

[0111] like If the value is greater than 0, then rendering is delayed; otherwise, it is triggered earlier.

[0112] Load sensors dynamically adjust based on device CPU / GPU utilization. To avoid overheating or frame drops caused by excessive acceleration.

[0113] The network scheduling and resource preloading module includes:

[0114] The request priority scheduler dynamically adjusts the concurrency order and timeout of network requests based on the game scenario. The priority calculation formula is as follows:

[0115]

[0116] in: , , Here, A represents the round-trip time, B represents the packet loss rate, and C represents the resource urgency.

[0117] The preload decision maker, based on a player behavior prediction model, preloads resources that may be used. Its prediction algorithm is based on a Markov chain model, and the state transition probability is calculated from the historical operation sequence.

[0118] The dynamic acceleration strategy module includes:

[0119] The device status monitor collects CPU utilization, memory usage, network latency, and power levels in real time.

[0120] The behavior analyzer identifies the current game stage based on in-game operation frequency, scene switching frequency, and resource loading mode.

[0121] The speedup adjuster dynamically adjusts the speedup coefficient S based on the following multi-factor decision model:

[0122]

[0123] in: , , The risk level is an adjustment factor applicable to the current game stage;

[0124] The security and recovery subsystem includes an instruction backup and recovery mechanism, which includes:

[0125] The original instruction backup area retains the first few instructions of the overwritten original function in the _HOOK_TEXT segment;

[0126] The context saver saves the register state and stack frame contents to non-volatile memory before jumping to the hook function;

[0127] The instruction restorer writes the backup instructions back to their original address and restores the register context during rollback or exception handling, ensuring that the original function can continue to execute.

[0128] The static refactoring subsystem or runtime interception subsystem includes a multi-engine adaptation module, which includes:

[0129] Engine symbol mapping table, pre-set with key function symbols and offsets for mainstream game engines such as Unity, Cocos2d-x, and Unreal;

[0130] The engine feature identifier identifies the target engine type by using Mach-O segment names, symbol names, and code patterns;

[0131] The automatic hook configurator automatically selects predefined hook points and redirection strategies based on the recognition results, improving adaptation efficiency.

[0132] The safety and rollback subsystem includes:

[0133] Integrity verifier, using SHA-256 hash to verify the integrity of the mapping table and the hook code segment;

[0134] The signature verifier verifies the application's signature status at runtime and triggers a rollback if it detects unauthorized modifications.

[0135] Anomaly detection and rollback triggers rollback based on the following conditions: abnormal function execution time, abnormal stack pointer offset, and mismatch between acceleration strategy and device state.

[0136] The rollback process includes: restoring the original instructions, clearing the jump code, resetting the time baseline, and logging exceptions for debugging.

[0137] Example 2

[0138] This embodiment addresses the issue where, in a non-jailbroken environment, the security and rollback subsystem and the runtime interception subsystem exhibit speed-up behavior detected by the game server or client's anti-cheat system. The specific details are as follows:

[0139] 1. The anti-detection control module is the brain of the system, responsible for coordinating various covert tasks;

[0140] Strategy configuration: Preset anti-detection schemes for different games or engines;

[0141] Dynamic switch: Automatically pauses high-risk acceleration modules when the game connects to a specific server;

[0142] 2. Timing fingerprint simulator, targeting anti-acceleration methods that detect server-side acceleration by analyzing the timing of client data packets;

[0143] Traffic shaping: Smooths network data packets generated after acceleration by inserting random delays that match the actual physical time intervals, making the data packet sequence statistically indistinguishable from normal game behavior;

[0144] Timing obfuscation: During acceleration, simulate the jitter of real player operation intervals to avoid being identified by overly regular "inhuman" operations;

[0145] 3. Memory trace cleaner, targeting memory scanning by client-side anti-cheating systems;

[0146] Hook hiding: Not only injecting code, but also hiding the existence of trampoline code and mapping tables in memory by modifying memory properties, marking them as unreadable, and dynamically rebuilding the import table;

[0147] Runtime self-erasure: After the critical function jump is completed, the jump instruction is temporarily cleared and restored after the anti-cheat system scans, thus achieving "instant hook";

[0148] 4. Graphics rendering verification bypass, targeting systems that detect cheats by verifying the number of rendered output frames or content;

[0149] Frame rate masquerading: While controlling the actual rendering frame rate, the rendering scheduling module reports a virtualized frame rate value that conforms to the normal level of the device to the game engine;

[0150] Surface integrity protection: Ensures that every frame of the image rendered after acceleration is indistinguishable from the normal game at the pixel level, without any abnormalities such as tearing or frame skipping that can be procedurally identified.

[0151] The innovation of this invention lies in its offline stage of performing deep analysis and code injection on the target application's Mach-O file to pre-modify the game's execution flow. Specifically, the Mach-O parsing module first analyzes LoadCommand, segment structure, symbol table, and relocation information to accurately locate the entry address of key functions. Next, the code injection module inserts trampoline code, hook function bodies, and original instruction backup areas into the executable segment or a newly created _HOOK_TEXT segment to ensure the accuracy and reversibility of code modification. The mapping table generation module then creates a structured mapping table containing original addresses, injection addresses, patch types, symbol names, and version information, and embeds it into the _HOOK_DATA segment to provide data support for the runtime stage. Finally, the re-signing module re-signs the modified Mach-O file using a developer certificate to pass iOS's AMFI and dyld verification, ensuring the application's legal operation on non-jailbroken devices. This series of steps forms the basis of static refactoring, enabling subsequent runtime interception and acceleration strategies to be implemented.

[0152] The runtime interception subsystem works by dynamically loading the mapping table and executing controlled function jumps after the application starts, enabling real-time interception of critical game functions. The mapping table loader reads and parses the mapping table from the _HOOK_DATA segment before the main function is executed or during module initialization, providing configuration information for subsequent operations. The memory control unit temporarily removes the write protection of the target memory page by calling the mprotect system call, safely writes the jump instruction using atomic instructions, and restores the memory protection attributes after completion, thereby avoiding memory access conflicts. The jump execution unit selects the appropriate jump method according to the patch_type field in the mapping table, such as jumping directly to the hook function, forwarding via trampoline code, or returning after executing the original instruction backup, ensuring the flexibility and controllability of function calls. This allows the system to seamlessly insert acceleration logic at runtime without modifying the original application code, thus achieving efficient game acceleration in a non-jailbroken environment.

[0153] The security and rollback subsystem works by employing a multi-layered verification and recovery mechanism to ensure the stability and security of the acceleration process. The integrity verifier uses the SHA-256 hash algorithm to perform integrity checks on the mapping table and hook code segments, preventing malicious tampering or data corruption. The signature verifier continuously verifies the application signature status during runtime, and immediately triggers the rollback mechanism once illegal modification is detected. The anomaly detection and rollback system automatically initiates the rollback process based on conditions such as function execution time anomalies, stack pointer offsets, or mismatches between the acceleration strategy and the device state. This includes restoring the original instructions, clearing jump code, resetting the time baseline, and recording anomaly logs. This not only ensures that the acceleration operation runs within a controllable range but also provides the ability to quickly restore the original code path, thereby maintaining the stability of the game and the user experience on non-jailbroken devices.

[0154] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The embodiments and descriptions in the specification are merely illustrative of the principles of the present invention. Various changes and modifications can be made to the present invention without departing from its spirit and scope. All such changes and modifications fall within the scope of the present invention as claimed, which is defined by the appended claims and their equivalents.

Claims

1. A method for accelerating games in an iOS environment without jailbreaking, characterized in that, include: Static refactoring subsystem, runtime interception subsystem, policy scheduling subsystem, security and recovery subsystem; The combined usage of the static reconstruction subsystem, runtime interception subsystem, policy scheduling subsystem, and security and recovery subsystem is as follows: S1. In the offline phase, the Mach-O files of the target application are parsed, code is injected, and a mapping table is generated. S2, embedded within the target application, is responsible for loading the mapping table and executing controlled runtime function jumps at startup; S3 provides time virtualization, rendering scheduling, network optimization and resource preloading modules, and supports dynamic speedup adjustment and abnormal rollback; S4. Verify the integrity of the mapping table, verify the signature status, and restore the original code path when an anomaly is detected; The time virtualization module includes: A multi-path interceptor that covers system time functions, engine tick methods, and Objective-C timers; The time scaler calculates virtual time based on the following formula: ； in: For virtual time, For virtual time baseline, This is the current real time. Acceleration coefficient; Drift compensator, through periodic calibration and To mitigate deviations and prevent timing anomalies caused by accumulated errors; The rendering scheduling module includes: Frame callback interceptors can hook the entry point of the rendering loop in the engine or system. Frame rate controller, based on target frame rate Compared to the actual frame rate The difference is used to dynamically adjust the timing of the rendering callback, and its scheduling strategy is based on the following formula: ； like If so, then the rendering is delayed; otherwise, it is triggered earlier. Load sensors dynamically adjust based on device CPU / GPU utilization. To avoid overheating of the device or frame drops due to excessive acceleration; The network scheduling and resource preloading module includes: The request priority scheduler dynamically adjusts the concurrency order and timeout of network requests based on the game scenario. The priority calculation formula is as follows: ； in: Here, A represents the round-trip time, B represents the packet loss rate, and C represents the resource urgency. The pre-loading decision-maker, based on a player behavior prediction model, preloads resources that may be used. Its prediction algorithm is based on a Markov chain model, and the state transition probability is calculated from the historical operation sequence. The dynamic acceleration strategy module includes: The device status monitor collects CPU utilization, memory usage, network latency, and power levels in real time. The behavior analyzer identifies the current game stage based on in-game operation frequency, scene switching frequency, and resource loading mode. The speedup adjuster dynamically adjusts the speedup coefficient S based on the following multi-factor decision model: ； in: The risk level is an adjustment factor applicable to the current game stage; The system achieves controllable acceleration of game execution speed on non-jailbroken devices through a two-stage collaboration of static and runtime processes.

2. The method for accelerating games in an iOS jailbreak-free environment according to claim 1, characterized in that: The static reconfiguration subsystem includes: The Mach-O parsing module is used to parse LoadCommand, segment structure, symbol table and relocation information to locate the entry address of the target function. The code injection module inserts trampoline code, hook function bodies, and the original instruction backup area into the executable segment or the newly created _HOOK_TEXT segment of Mach-O. The mapping table generation module generates a structured mapping table containing the original address, injection address, patch type, symbol name and version information, and embeds it into the _HOOK_DATA segment; The re-signing module uses the developer certificate to re-sign the modified Mach-O file, ensuring that it passes iOS's AMFI and dyld verification.

3. The method for accelerating games in an iOS jailbreak-free environment according to claim 1, characterized in that: The runtime interception subsystem includes: The mapping table loader reads and parses the mapping table from the _HOOK_DATA segment before the main() function is executed or during the module initialization phase; The memory control unit temporarily removes the write protection of the target memory page through the mprotect() system call, writes a jump instruction using an atomic instruction, and then restores the memory protection attribute; The jump execution unit selects the jump method based on the patch_type field in the mapping table, including jumping directly to the hook function, forwarding via trampoline, or jumping back after executing the original instruction backup.

4. The method for accelerating games in an iOS jailbreak-free environment according to claim 1, characterized in that: The safety and rollback subsystem includes: Integrity verifier, using SHA-256 hash to verify the integrity of the mapping table and the hook code segment; The signature verifier verifies the application's signature status at runtime and triggers a rollback if it detects unauthorized modifications. Anomaly detection and rollback triggers rollback based on the following conditions: abnormal function execution time, abnormal stack pointer offset, and mismatch between acceleration strategy and device state. The rollback process includes: restoring the original instructions, clearing the jump code, resetting the time baseline, and logging exceptions for debugging.

Images