Legacy Game Code Emulation via Dynamic Caching and Compilation

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Legacy games are not compatible with modern gaming systems due to architectural differences between legacy and updated machines, preventing the execution of legacy code on updated machines without permission and requiring recompilation, which is time-consuming and inefficient.

Innovation Solution

A system and method for emulating graphical and audio parameters by caching and compiling legacy game code, allowing user inputs to be processed using an updated hand-held controller, and generating virtual environments with improved resolution and sound quality without the need for recompilation on each machine.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If legacy game code is executed on updated machines, then compatibility is improved, but execution permission and security constraints worsen

Engineering Contradiction:
ImprovecompatibilityVSAvoidexecution permission
Core Design Contradiction:
Adaptability or versatilityVSReliability

Solution Approach 1:

The patent introduces an emulation layer as an intermediary between the legacy game code and the updated machine hardware. This emulation layer translates legacy instructions into instructions that the updated machine can execute, thereby enabling compatibility while maintaining security constraints through controlled permission management.

Inventive Principle:
Principle #24Intermediary (Mediator)

Solution Approach 2:

The patent creates a virtualized copy of the legacy game environment within the updated machine. By copying the necessary system calls, hardware interfaces, and execution context, the system allows legacy code to run without direct access to the underlying hardware, thus improving compatibility while maintaining security through the copy isolation barrier.

Inventive Principle:
Principle #26Copying

2Adaptability or versatility

If legacy code is recompiled for each machine, then compatibility is improved, but processing time and efficiency worsen

Engineering Contradiction:
ImprovecompatibilityVSAvoidprocessing time
Core Design Contradiction:
Adaptability or versatilityVSLoss of time

Solution Approach 1:

The patent performs preliminary compilation of legacy game code into a universal intermediate representation that can be executed on multiple updated machine architectures. This pre-compilation step eliminates the need for recompilation on each specific machine, significantly reducing processing time while maintaining broad compatibility.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

The patent develops a universal emulation framework that can execute the same compiled legacy code across different updated machine architectures. This multi-functionality allows a single compilation to serve multiple platforms, eliminating redundant compilation time and improving overall efficiency.

Inventive Principle:
Principle #6Universality (Multi-functionality)

3Manufacturing precision

If graphical and audio parameters are emulated, then quality is improved, but processing power requirements worsen

Engineering Contradiction:
Improvegraphical and audio qualityVSAvoidprocessing power usage
Core Design Contradiction:
Manufacturing precisionVSPower

Solution Approach 1:

The patent segments the emulation process into dedicated graphical and audio processing modules that handle parameter translation independently. By dividing the processing workload into separate segments, the system can optimize each module for specific quality requirements while managing overall processing power consumption more efficiently.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent dynamically adjusts graphical and audio parameters during execution based on the capabilities of the updated machine and the requirements of the legacy game. By changing parameters such as resolution, frame rate, and audio fidelity on a per-demand basis, the system achieves high quality when needed while reducing processing power usage during less demanding periods.

Inventive Principle:
Principle #35Parameter changes

4Speed

If code is compiled and cached, then execution speed is improved, but memory storage requirements worsen

Engineering Contradiction:
Improveexecution speedVSAvoidmemory storage
Core Design Contradiction:
SpeedVSQuantity of substance

Solution Approach 1:

The patent implements a dynamic caching mechanism that adjusts the size and content of the code cache based on runtime conditions. The system can expand or shrink the cache capacity dynamically, prioritizing frequently executed code segments while discarding less critical code, thereby optimizing execution speed without requiring fixed large memory allocations.

Inventive Principle:
Principle #15Dynamics

Solution Approach 2:

The patent employs partial compilation and caching of only the necessary code segments required for current gameplay rather than compiling the entire legacy game. This partial action approach reduces immediate memory storage requirements while still providing fast execution for the active code portions, balancing speed and storage trade-offs.

Inventive Principle:
Principle #16Partial or excessive action

Data Source

PatentUS12017140B2Systems and methods for emulation of graphical and audio parameters during a play of a legacy game
Publication Date: 2024.06.25 SONY INTERACTIVE ENTERTAINMENT LLC
  • US12017140B2 patent drawing
  • US12017140B2 patent drawing
  • US12017140B2 patent drawing

AI summary

A method for emulation of graphical parameters during a play of a legacy game is described. The method includes receiving a user input from a hand-held controller and determining whether one or more basic blocks of code for servicing the user input are stored in a cache. The method further includes compiling the one or more basic blocks of code from one or more emulated processing unit (PU) code instructions upon determining that the one or more basic blocks are not stored in the cache. The method includes executing the one or more basic blocks of code to generate one or more legacy graphical parameters. The method includes emulating the one or more legacy graphical parameters to generate one or more image frames having one or more updated graphical parameters for display of one or more images of the legacy game on a display device.