// --- Pipeline d'execution de V8 : parse -> Ignition (interpreteur) -> TurboFan (JIT) ---
// 1. Le code source est parse en AST (Abstract Syntax Tree)
// 2. Ignition genere et execute un bytecode interprete (demarrage rapide)
// 3. Le code "chaud" (execute frequemment) est compile a la volee par TurboFan (JIT)
//    en code machine optimise -- bien plus rapide que le bytecode interprete
// 4. Si les hypotheses d'optimisation sont violees, TurboFan "deoptimise" (retour a Ignition)

// --- Hidden Classes (Shapes) : comment V8 optimise l'acces aux proprietes d'objet ---
function Point(x, y) {
    this.x = x;      // cree la hidden class C0 -> C1 (ajout de "x")
    this.y = y;       // C1 -> C2 (ajout de "y")
}
const p1 = new Point(1, 2);      // suit le chemin C0 -> C1 -> C2
const p2 = new Point(3, 4);       // suit le MEME chemin -> partage la hidden class C2 avec p1
// V8 peut alors generer du code machine SPECIALISE pour cette forme d'objet precise

// PIEGE : ajouter des proprietes dans un ordre different cree des hidden classes DIFFERENTES
function creerPointIncoherent(x, y, ajouterZAvant) {
    const p = {};
    if (ajouterZAvant) {
        p.z = 0;
        p.x = x;
        p.y = y;
    } else {
        p.x = x;
        p.y = y;
    }
    return p;
    // p.z avant p.x/p.y VS p.x/p.y seuls -> deux hidden classes DIFFERENTES
    // -> V8 ne peut plus reutiliser le meme code optimise -> "megamorphic" -> plus lent
}

// --- Inline Caches (IC) : cache par site d'appel pour accelerer les acces repetes ---
function obtenirX(objet) {
    return objet.x;      // ce SITE D'APPEL memorise la hidden class rencontree
}
// monomorphic (1 seule hidden class rencontree ici) : le plus rapide, V8 saute directement au bon offset
obtenirX(p1);
obtenirX(p2);
// polymorphic (2 a 4 hidden classes differentes) : toujours optimisable, mais plus lent
// megamorphic (5+ hidden classes) : V8 abandonne l'optimisation specifique, retombe sur une recherche generique

// --- Deoptimisation : quand TurboFan doit "annuler" une optimisation ---
function additionner(a, b) {
    return a + b;
}
for (let i = 0; i < 100_000; i++) additionner(1, 2);      // TurboFan optimise pour des NOMBRES

additionner("a", "b");
// L'hypothese "a et b sont toujours des nombres" est violee -> DEOPTIMISATION
// -> V8 retombe temporairement sur le bytecode interprete, plus lent, le temps de reoptimiser

// --- Arrays : "elements kinds" -- un autre systeme d'optimisation specifique aux tableaux ---
const tableauRapide = [1, 2, 3];              // PACKED_SMI_ELEMENTS : optimisation maximale
tableauRapide.push(4.5);                        // PACKED_DOUBLE_ELEMENTS : legerement moins optimal
tableauRapide.push("texte");                      // PACKED_ELEMENTS (generique) : encore moins optimal
tableauRapide[10] = 1;                              // HOLEY_ELEMENTS (tableau avec "trous") : le plus lent

// Bonne pratique : garder des tableaux homogenes en type, sans trous, pour rester dans le mode rapide
const tableauOptimal = new Array(1000).fill(0);     // pre-alloue, pas de "trous", type homogene

// --- Le tas (heap) et les generations : voir aussi la lecon "Performance et memoire" ---
// New Space (Scavenger, tres frequent, tres rapide) -> Old Space (Mark-Compact, moins frequent)

// --- Mesurer les optimisations reelles : --trace-opt / --trace-deopt (flags Node.js) ---
// node --trace-opt --trace-deopt script.js
// (affiche quand une fonction est optimisee/deoptimisee par TurboFan)

// --- Monomorphisme en pratique : conseil de conception d'API ---
class Vecteur {
    constructor(x, y) {
        this.x = x;       // TOUJOURS le meme ordre d'initialisation
        this.y = y;        // -> toutes les instances partagent la meme hidden class
    }
}
// Preferer des classes/constructeurs a des objets litteraux construits dynamiquement
// avec des proprietes conditionnelles, pour rester "monomorphic" et laisser V8 optimiser au maximum