Dynamic recompilation

In computer science, dynamic recompilation is a feature of some emulators and virtual machines, where the system may recompile some part of a program during execution. By compiling during execution, the system can tailor the generated code to reflect the program's run-time environment, and potentially produce more efficient code by exploiting information that is not available to a traditional static compiler. Most dynamic recompilers are used to convert machine code between architectures at runtime. This is a task often needed in the emulation of legacy gaming platforms. In other cases, a system may employ dynamic recompilation as part of an adaptive optimization strategy to execute a portable program representation such as Java or .NET Common Language Runtime bytecodes. Full-speed debuggers also utilize dynamic recompilation to reduce the space overhead incurred in most deoptimization techniques, and other features such as dynamic thread migration. The main tasks a dynamic recompiler has to perform are: Reading in machine code from the source platform Emitting machine code for the target platform A dynamic recompiler may also perform some auxiliary tasks: Managing a cache of recompiled code Updating of elapsed cycle counts on platforms with cycle count registers Management of interrupt checking Providing an interface to virtualized support hardware, for example a GPU Optimizing higher-level code structures to run efficiently on the target hardware (see below) Many Java virtual machines feature dynamic recompilation. Apple's Rosetta for Mac OS X on x86, allows PowerPC code to be run on the x86 architecture. Later versions of the Mac 68K emulator used in classic Mac OS to run 680x0 code on the PowerPC hardware. Psyco, a specializing compiler for Python. The HP Dynamo project, an example of a transparent binary dynamic optimizer. DynamoRIO, an open-source successor to Dynamo that works with the ARM, x86-64 and IA-64 (Itanium) instruction sets. The Vx32 virtual machine employs dynamic recompilation to create OS-independent x86 architecture sandboxes for safe application plugins.

À propos de ce résultat

Cette page est générée automatiquement et peut contenir des informations qui ne sont pas correctes, complètes, à jour ou pertinentes par rapport à votre recherche. Il en va de même pour toutes les autres pages de ce site. Veillez à vérifier les informations auprès des sources officielles de l'EPFL.

Concepts associés (8)

Cours associés (1)

Séances de cours associées (3)

QEMU

QEMU est un logiciel libre de machine virtuelle, pouvant émuler un processeur et, plus généralement, une architecture différente si besoin. Il permet d'exécuter un ou plusieurs systèmes d'exploitation via les hyperviseurs KVM et Xen, ou seulement des binaires, dans l'environnement d'un système d'exploitation déjà installé sur la machine.

Dynamic recompilation

Translation de code

En informatique, la translation de code est une technique d'émulation consistant à traduire (de l'anglais « to translate », traduire) le jeu d'instructions d'une architecture source vers le jeu d'instructions d'une architecture destination. On distingue deux types de translation de code : la translation statique, dans ce cas un fichier exécutable de la machine source est intégralement traduit en un fichier exécutable de la machine destination ; la translation dynamique (ou compilation à la volée), dans ce cas les instructions de la machine source sont traduites en instructions de la machine cible au moment même de leur exécution.

CS-470: Advanced computer architecture

The course studies techniques to exploit Instruction-Level Parallelism (ILP) statically and dynamically. It also addresses some aspects of the design of domain-specific accelerators. Finally, it explo

Explore les principes d'optimisation des requêtes, les défis liés à l'estimation de la cardinalité et l'impact des erreurs sur la sélection des plans.

Explore la programmation modulaire, en mettant l'accent sur la séparation de l'interface et de l'implémentation dans les modules et l'utilisation de make et Makefile pour gérer les dépendances.