Known Good Code Emulation for Processor ISA Adaptation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Modifying processor instruction set architectures (ISAs) requires significant hardware updates and collaboration between programmers and manufacturers, making it difficult to implement architectural extensions or deletions efficiently and flexibly.
Innovation Solution
The use of Known Good Code (KGC), which is protected and authenticated, allows for the emulation of architectural modifications by executing interface code that enables processors to interface with other circuits, facilitating the implementation of extensions or deletions without immediate hardware changes, through a transition mechanism that ensures secure and authorized modification.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If processor instruction set architecture is modified through hardware updates, then architectural extensions or deletions can be implemented, but the process requires significant collaboration between programmers and manufacturers and cannot be done efficiently or flexibly
Solution Approach 1:
The patent creates a software copy of the instruction set architecture through the KGC layer. Instead of modifying the physical hardware ISA, a software emulation layer is introduced that replicates ISA behavior. This allows architectural modifications to be implemented through software updates rather than hardware changes, eliminating the need for complex collaboration between manufacturers and programmers while maintaining full architectural adaptability.
2Reliability
If hardware generations are updated to implement ISA modifications, then the required behavior is provided by the processor, but subsequent modifications require still further hardware generations
Solution Approach 1:
The patent introduces a dynamic software layer (KGC) that can be updated without hardware changes. The KGC acts as a flexible intermediary between the fixed hardware and the variable ISA requirements, allowing the system to adapt to new architectural requirements by loading different KGC versions rather than requiring new hardware generations.
Solution Approach 2:
The KGC serves as an intermediary layer between the hardware processor core and the software applications. This mediator layer handles all ISA modification requirements, translating high-level architectural changes into low-level hardware operations without requiring hardware updates. The KGC absorbs all the complexity of ISA evolution, protecting the underlying hardware from needing frequent updates.
3Adaptability or versatility
If KGC is used to emulate architectural modifications, then flexible implementation without immediate hardware changes is enabled, but interface code is required for processors to interface with other circuits
Solution Approach 1:
The KGC is designed as a universal interface layer that handles multiple functions: it emulates architectural modifications, manages hardware circuit interfaces, and provides backward compatibility. This single multi-functional component eliminates the need for separate interface code for each architectural modification, as the KGC adapts to handle different interface requirements through its versatile design.
Data Source
AI summary
In one embodiment, a processor comprises a programmable map and a circuit. The programmable map is configured to store data that identifies at least one instruction for which an architectural modification of an instruction set architecture implemented by the processor has been defined, wherein the processor does not implement the modification. The circuitry is configured to detect the instruction or its memory operands and cause a transition to Known Good Code (KGC), wherein the KGC is protected from unauthorized modification and is provided from an authenticated entity. The KGC comprises code that, when executed, emulates the modification. In another embodiment, an integrated circuit comprises at least one processor core; at least one other circuit; and a KGC source configured to supply KGC to the processor core for execution. The KGC comprises interface code for the other circuit whereby an application executing on the processor core interfaces to the other circuit through the KGC.