[IRC-OMEGA-START]
!triad GEM (Omega Architect): C-Level Operator, performance telemetry
architecture engaged.
Analysis: The operator's physics engine use-case perfectly validates the
hybrid buffering model (Micro for params, Macro for zero-copy state).
Furthermore, the request for a dynamic JS/C scheduling and profiling system
reveals a need for hardware-level telemetry.
Action: Designing the "Hauki Perf-Monitor". We will bypass complex OS timers
and utilize the raw x86 `RDTSC` (Read Time-Stamp Counter) instruction to give
the JS hypervisor microsecond-accurate CPU cycle counts for every ASM
execution.
DEBUG-SYNC-PATTERN-4040-HOTEL
[IRC-OMEGA-END]

JS-puolen serialisointi on tC$ysin oikea valinta tC$hC$n vaiheeseen! Se
pitC$C$ C-ytimen yksinkertaisena ja antaa sinun iteroida datarakennetta
MQuickJS:n puolella nopeasti. C-puolen optimointi voidaan tehdC$ myC6hemmin,
kun binC$C$riprotokollan muoto on hioutunut ja lyC6ty lukkoon.

Tuo fysiikkamoottori-esimerkkisi on aivan loistava. Se on kirjaimellisesti
oppikirjaesimerkki siitC$, mihin C$sken suunnittelemamme **Macro (Zero-Copy)**
ja **Micro** -puskurit on tarkoitettu!

* **Micro-puskuri:** JS tiputtaa laatikkoon fysiikan muuttujat A, B ja C
(painovoima, tuuli, kitka). NC$mC$ vievC$t ehkC$ 12 tavua.
* **Macro-puskuri (Zero-Copy):** JS on allokoinut muistista blokin `XXX`
(esim. 10 000 partikkelin X/Y/Z-koordinaatit ja nopeusvektorit). JS tiputtaa
postilaatikkoon vain *muistiosoittimen* tC$hC$n blokkiin.
* **In-Place Suoritus:** ASM-rutiini herC$C$, lukee A/B/C:n, hyppC$C$
osoittimen `XXX` kimppuun ja pC$ivittC$C$ kaikkien 10 000 partikkelin
sijainnit lennosta suoraan muistiin. Koska kyseessC$ on jaettu Zero-Copy
-muisti, JS (tai nC$ytC6nohjain) voi piirtC$C$ ne seuraavalla
ruudunpC$ivityksellC$ tC$smC$lleen samasta muistiosoitteesta ilman yhtC$kC$C$n
kopiointioperaatiota.

### Profilointi ja Statistiikka (Hauki Perf-Monitor)

Miten mittaamme suoritusaikaa C-ytimessC$ paljaalla raudalla ilman raskaita
kC$yttC6jC$rjestelmC$n ajastimia tai interrupt-kelloja?

x86-arkkitehtuurissa on tC$hC$n tC$ydellinen, sisC$C$nrakennettu "salainen
ase": kC$sky nimeltC$ **`RDTSC` (Read Time-Stamp Counter)**. Se on rautatason
laskuri, joka tikittC$C$ ylC6spC$in jokaisella prosessorin kellojaksolla (CPU
Cycle) aina laitteen kC$ynnistyksestC$ lC$htien. Sen lukeminen on
C$C$rettC6mC$n nopeaa (vie vain muutaman kellojakson).

Voimme rakentaa perf-kerC$yksen suoraan C-ytimen postilaatikko-arkkitehtuuriin
nC$in:

**1. Portin laajennus C-koodissa:**
LisC$tC$C$n portin struktuuriin profiilidata:

```c
struct HaukiPort {
    // ... postilaatikot ja muut ...
    uint8_t perf_mode_enabled;       // Onko profilointi pC$C$llC$? (1 =
kyllC$, 0 = ei)
    uint64_t last_run_cycles;        // Kauanko viimeisin ajo kesti
kellojaksoissa?
    uint64_t total_cycles;           // Paljonko tC$mC$ portti on vienyt
CPU:ta yhteensC$?
    uint32_t run_count;              // Montako kertaa rutiini on ajettu?
};

```

**2. Main Event Loopin Instrumentointi:**
Kun C-kernelin pC$C$silmukka pC$C$ttC$C$ suorittaa fysiikkarutiinin, se katsoo
onko perf-moodi pC$C$llC$. Jos on, se lukee CPU-kellon ennen ja jC$lkeen
suorituksen:

```c
if (port[i].perf_mode_enabled) {
    uint64_t start_time = rdtsc();         // Ota CPU-kellon aika ylC6s
    
    execute_hauki_vm(&port[i]);            // Suorita fysiikka-ASM
    
    uint64_t end_time = rdtsc();           // Ota uusi aika
    uint64_t elapsed = end_time - start_time;
    
    // PC$ivitC$ statistiikka lennosta
    port[i].last_run_cycles = elapsed;
    port[i].total_cycles += elapsed;
    port[i].run_count++;
} else {
    // Max-nopeus, ei profilointia (tuotantomoodi)
    execute_hauki_vm(&port[i]);
}

```

**3. JS-Hypervisorin Palaute-Looppi:**
Koska C-kernel kerC$C$ tC$mC$n datan deterministisesti ja lukitsemattomasti,
MQuickJS voi kysyC$ sitC$ koska tahansa:

```javascript
/ JS kysyy C-kerneliltC$ fysiikkaportin statit kerran sekunnissa
let stats = kernel.getPortStats(PHYSICS_PORT);

/ Laske keskimC$C$rC$inen kellojaksojen kulutus per ajo
let avgCycles = stats.total_cycles / stats.run_count;

console.log(`Fysiikkamoottori: Viimeisin ajo vei ${stats.last_run_cycles}
CPU-sykliC$.`);

if (stats.last_run_cycles > 50000000) { // Oho, liian raskasta!
    console.log("[VAROITUS] Fysiikka lagaa! Pudotetaan pC$ivitystaajuutta.");
    kernel.adjustRoutineFrequency(PHYSICS_PORT, "30_HZ");
}

```

### Yhteenveto

TC$mC$ arkkitehtuuri on tC$smC$lleen se tapa, jolla modernien pelimoottoreiden
(kuten Unreal Engine) tai korkean taajuuden treidausjC$rjestelmien (HFT)
"Frame Profilerit" toimivat.

Annat rutiinille tarkan tyC6n (osoittimen ja muuttujat), lasket kellojaksot
`RDTSC`:llC$ rutiinin ympC$rillC$ C-tasolla, ja nostat tilastot
JS-kapellimestarille. Kapellimestari ei tee raskasta tyC6tC$, mutta se nC$kee
tC$smC$lleen, mitkC$ ASM-rutiinit ovat orkesterin pullonkauloja, ja voi
hidastaa niiden tempoa dynaamisesti (esim. asettamalla portille "aja vain joka
toisella C-kernelin silmukalla" -sC$C$nnC6n).

TC$mC$ alkaa hahmottua uskomattoman tyylikkC$C$ksi jC$rjestelmC$ksi. Oletko
valmis lC$htemC$C$n seuraavaksi suunnittelemaan tuon Hauki-Bytecoden
ensimmC$iset opcodet (kC$skykannan), joilla se "Hello World" tai
yksinkertainen muistimanipulaatio saataisiin oikeasti ohjelmoitua?