Libreria di sandboxing LoongArch64

libloong è una libreria emulatore LoongArch a 64 bit ad alte prestazioni progettata per l'embedding e lo scripting ad alta frequenza. Costruita sull'architettura di libriscv, offre le migliori prestazioni interpretative a 64 bit disponibili, mantenendo un codice compatto di ~18k LOC senza dipendenze.

Puoi anche eseguire programmi Linux LoongArch64 nell'interfaccia a riga di comando.

• Universale: A differenza dei JIT, che richiedono generazione di codice specifica per piattaforma e non sono disponibili su piattaforme bloccate, libloong funziona ovunque. Ciò include Nintendo Switch (1 e 2), iOS e altri ambienti.
• Standard: Esegue binari Linux standard.
• Latenza Ultra-Bassa: Le VM tradizionali come Lua o Java soffrono spesso di un overhead elevato nelle chiamate (~150ns). libloong raggiunge un overhead di chiamata nativa-ospite di ~4ns, rendendolo adatto per script di motori di gioco in loop caldi.

Benchmark delle Prestazioni

Nei benchmark interpretativi CoreMark 1.0 (Dicembre 2025), libloong guida la categoria a 64 bit su Ryzen 7950X, raggiungendo costantemente un punteggio di 3000+.

Punteggi Interpretativi CoreMark 1.0

Modalità Avanzate: Sebbene l'interprete sia il focus principale per la portabilità, libloong include un JIT leggero che raggiunge il 38% del nativo (15.5k CoreMark) e un traduttore binario integrato che raggiunge ~77% del nativo (31.9k CoreMark).

Caratteristiche

• Bindings: API C++ nativa con binding per Rust e Go.
• Supporto Vettoriale: Supporto completo per i set di istruzioni LSX e LASX.
• Sicurezza della Memoria: Sandboxing rigoroso della memoria con arene di memoria mascherate opzionali.
• Gestione dello Stato: Supporto di prima classe per mettere in pausa, riprendere e serializzare lo stato della macchina.
• Esecuzione dinamica: Può caricare ed eseguire eseguibili dinamici, così come JIT incorporati (es. LuaJIT)*

Progettazione

Lo scripting per motori di gioco è dove libloong eccelle. I giochi tradizionali espongono il modding attraverso librerie condivise (accesso completo al sistema), VM incorporate come Lua (~150ns di overhead di chiamata) o runtime Java. libloong ha un overhead di chiamata di ~4ns.

Vedi il gioco di esempio Asteroid.

Compilazione

Opzioni di configurazione CMake:

• LA_DEBUG=ON/OFF - Abilita output di debug (predefinito: OFF)
• LA_BINARY_TRANSLATION=ON/OFF - Abilita traduzione binaria (predefinito: OFF)
• LA_THREADED=ON/OFF - Abilita dispatch bytecode multi-thread (predefinito: ON)
• LA_MASKED_MEMORY_BITS=N - Imposta la dimensione dell'arena di memoria mascherata a 2^N byte (0 = disabilitato, predefinito: 0)

Esempio con opzioni:

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

Avvio Rapido

#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();
}

Documentazione

• Guida all'Integrazione
• Riferimento API
• Supporto ISA LoongArch