[Paper Review] Perpetual Adaptation of Software to Hardware: An Extensible Architecture for Providing Code Optimization as a Central System Service

Thomas Kistler, Michael Franz|ArXiv.org|Mar 22, 1999

Parallel Computing and Optimization Techniques30 references3 citations

TL;DR

This paper proposes an extensible, architecture-centric system for just-in-time code generation and dynamic optimization, treating code optimization as a central, pluggable system service. By decoupling optimization logic from the core system and enabling runtime adaptation to diverse hardware, it enables perpetual software adaptation to evolving processor architectures, with demonstrated flexibility and performance benefits in prototype evaluation.

ABSTRACT

We present an open architecture for just-in-time code generation and dynamic code optimization that is flexible, customizable, and extensible. While previous research has primarily investigated functional aspects of such a system, architectural aspects have so far remained unexplored. In this paper, we argue that these properties are important to generate optimal code for a variety of hardware architectures and different processor generations within processor families. These properties are also important to make system-level code generation useful in practice.

Motivation & Objective

• To address the lack of architectural support for dynamic code optimization in operating systems.
• To enable software to continuously adapt to new processor generations and hardware variants without recompilation.
• To design a system where code optimization is a first-class, extensible service integrated at the OS level.
• To support flexible, customizable optimization strategies across diverse hardware platforms.
• To make system-level code generation practical and efficient in real-world deployments.

Proposed method

• Designing a modular, extensible architecture that exposes code generation and optimization as a central system service.
• Integrating just-in-time (JIT) code generation directly into the operating system kernel or runtime environment.
• Allowing runtime plug-in of optimization modules tailored to specific processor families or instruction sets.
• Using a component-based design to decouple optimization logic from the core system, enabling runtime updates and customization.
• Supporting dynamic reconfiguration of optimization strategies based on hardware characteristics and workload demands.
• Leveraging existing compiler infrastructure to generate and optimize machine code on-the-fly during execution.

Experimental results

Research questions

• RQ1 How can code optimization be systematically integrated as a core, extensible service within an operating system?
• RQ2 What architectural principles enable perpetual adaptation of software to evolving hardware without recompilation?
• RQ3 How can optimization strategies be dynamically customized and plugged in at runtime for different processor families?
• RQ4 What performance and flexibility trade-offs arise when treating optimization as a system-level service?
• RQ5 Can such an architecture support practical, efficient, and extensible code generation across diverse hardware platforms?

Key findings

• The proposed architecture successfully decouples optimization logic from the core system, enabling runtime extensibility and customization.
• The system supports dynamic adaptation to new processor generations within a family, reducing the need for application recompilation.
• By treating optimization as a central system service, the approach enables consistent, policy-driven code generation across diverse workloads.
• The prototype demonstrates that system-level JIT compilation can be efficiently integrated into the OS with minimal runtime overhead.
• The extensible design allows for the addition of new optimization plugins without modifying the core system, enhancing maintainability.
• The architecture enables both functional correctness and performance improvements through runtime code adaptation.