Bibliothèque de sandboxing LoongArch64

libloong est une bibliothèque d'émulation LoongArch 64 bits haute performance conçue pour l'intégration et le scripting à haute fréquence. Construite sur l'architecture de libriscv, elle offre les performances d'interpréteur 64 bits les plus rapides disponibles, tout en maintenant une base de code compacte d'environ 18 000 lignes avec zéro dépendance.

Vous pouvez également exécuter des programmes Linux LoongArch64 dans l'interface en ligne de commande.

• Universel : Contrairement aux JIT, qui nécessitent une génération de code spécifique à la plateforme et sont indisponibles sur les plateformes verrouillées, libloong fonctionne partout. Cela inclut Nintendo Switch (1 et 2), iOS, et autres environnements.
• Standard : Exécute des binaires Linux standard.
• Ultra-faible latence : Les VM traditionnelles comme Lua ou Java souffrent souvent d'un surcoût d'appel élevé (~150ns). libloong atteint un surcoût d'appel natif-à-invité d'environ 4ns, ce qui le rend adapté au scripting de moteurs de jeu dans des boucles chaudes.

Benchmarks de performance

Dans les benchmarks d'interpréteur CoreMark 1.0 (décembre 2025), libloong est en tête de la catégorie 64 bits sur le Ryzen 7950X, atteignant régulièrement un score de 3000+.

Scores d'interpréteur CoreMark 1.0

Modes avancés : Bien que l'interpréteur soit le principal objectif pour la portabilité, libloong inclut un JIT léger atteignant 38% du natif (15.5k CoreMark) et un traducteur binaire embarqué atteignant ~77% du natif (31.9k CoreMark).

Fonctionnalités

• Liaisons : API C++ native avec des liaisons Rust et Go.
• Support vectoriel : Prise en charge complète des jeux d'instructions LSX et LASX.
• Sécurité mémoire : Sandboxing mémoire strict avec arènes mémoire masquées optionnelles.
• Gestion d'état : Prise en charge de premier ordre pour la pause, la reprise et la sérialisation de l'état de la machine.
• Exécution dynamique : Peut charger et exécuter des exécutables dynamiques, ainsi que des JIT embarqués (par exemple LuaJIT)*

Conception

Le scripting de moteurs de jeu est le domaine où libloong excelle. Les jeux traditionnels exposent le modding via des bibliothèques partagées (accès complet au système), des VM embarquées comme Lua (surcoût d'appel ~150ns), ou des environnements d'exécution Java. libloong a un surcoût d'appel d'environ 4ns.

Voir l'exemple de jeu Astéroïdes.

Compilation

Options de configuration CMake :

• LA_DEBUG=ON/OFF - Activer les sorties de débogage (défaut : OFF)
• LA_BINARY_TRANSLATION=ON/OFF - Activer la traduction binaire (défaut : OFF)
• LA_THREADED=ON/OFF - Activer le dispatch de bytecode multithreadé (défaut : ON)
• LA_MASKED_MEMORY_BITS=N - Définir la taille de l'arène mémoire masquée à 2^N octets (0 = désactivé, défaut : 0)

Exemple avec options :

cmake .. -DCMAKE_BUILD_TYPE=Release \
         -DLA_MASKED_MEMORY_BITS=32 \
         -DLA_BINARY_TRANSLATION=ON
make -j6

Démarrage rapide

#include <libloong/machine.hpp>

int main() {
    // Load a LoongArch ELF binary
    std::vector<uint8_t> binary = load_file("program.elf");

    // Create a machine with 64MB memory
    loongarch::Machine machine { binary, {
        .memory_max = 64 * 1024 * 1024
    }};

    // Setup program arguments
    machine.setup_linux({"program"}, {"LC_ALL=C"});

    // Run the program
    machine.simulate();
}

Documentation

• Guide d'intégration
• Référence de l'API
• Prise en charge de l'ISA LoongArch