Home /Modules/cpu/memory-tiers-dispatch.sleela

memory-tiers-dispatch.sleela

lib/cpu/examples/memory-tiers-dispatch.sleela · 123 line(s) · sleela

<< lib/cpu/examples/memory-tiers-dispatch.sleela
   A runnable SLeeLa document proving memory tiers end to end:
     1. a PHYSICAL two-tier build — DDR2 (usual) + DDR5 (accurate) both mounted;
     2. a WHOLE-DOCUMENT default tier flag on the program;
     3. PER-METHOD tier flags (usualmem/accuratemem) overriding the default; and
     4. per-function DISPATCH — each method resolves to the real memory module
        it binds to, via SLMemoryTierRouter.
   
   It models the modifier bits the frontend emits for:
       < document default: accurate (DDR5) >
       accuratemem class OrderPipeline {
         < overrides -> usual (DDR2) >
         usualmem    void logActivity()  {...}
         < -> accurate (DDR5) >
         accuratemem int  settleLedger() {...}
         < inherits document default (DDR5) >
         int main()                      {...}
       } >>
#sleela 2.5
material;
class MemoryTiersDispatchExample {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
     or catalog can read and (where appropriate) override this record.
     Values are faithful to the subject's real origin where publicly known. >>
  String metaVersion = "1.0.0";
  int metaId = 11127;
  String metaAuthor = "Kiro Agent";
  String metaDate = "2026-10-16";
  String metaCopyright = "SLeeLa project";
  String metaTrademark = "none";
  String metaCorporation = "none";
  < metaOrigin: National | <nation> | International | Galactic >
  String metaOrigin = "International";
  String metaBirthDate = "2026-10-16";
  < metaScienceRating: maturity/robustness on a 1..10 scale >
  int metaScienceRating = 7;
  < metaNationalSchedule: a real, citable instrument or "none" >
  String metaNationalSchedule = "none";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }

  void main() {
    SLComponentCatalog parts = new SLComponentCatalog();
    SLMemoryTierPolicy policy = new SLMemoryTierPolicy();

    < 1. PHYSICAL two-tier build: DDR2 usual + DDR5 accurate on an EPYC. >
    SLAMDEPYC9575F cpu = new SLAMDEPYC9575F();
    cpu.configure();
    SLExecutorBuild build = new SLExecutorBuild();
    build.configure("tiered-epyc");
    build.installCpu(cpu);
    < DDR2 -> usual >
    build.installUsualTier(parts.ddr2_800(4096));
    < DDR5 -> accurate (base) >
    build.installAccurateTier(parts.ddr5_6400(65536));
    < document default = DDR5 >
    build.setMainTier(policy.TIER_ACCURATE);
    build.installBus(parts.pcieGen5x16());
    build.assemble();
    print("two-tier memory = " + build.twoTierMemory() +
          ", main tier = " + build.tierRouter().tierName(policy.TIER_INHERIT));

    < 2. WHOLE-DOCUMENT default, as the top-level class modifier would set it. >
    < accuratemem on the class -> document default accurate (DDR5). >
    int classMods = policy.MOD_ACCURATEMEM;
    SLProgram prog = new SLProgram();
    prog.configure("order-pipeline", 256);
    prog.setDocumentTier(policy.documentTierFromModifiers(classMods));
    print("document default tier = " + policy.tierName(prog.documentTier()) + " (whole program)");

    < 3. PER-METHOD flags (the modifier bits the frontend emits per method). >
    < logActivity: usualmem ; settleLedger: accuratemem ; mainFn: unflagged. >
    SLVMMethod logActivity = new SLVMMethod();
    logActivity.configure("logActivity", "()V", 0, 3, 0, 1, true, false);
    logActivity.setMemTier(policy.methodTierFromModifiers(policy.MOD_USUALMEM));
    SLVMMethod settleLedger = new SLVMMethod();
    settleLedger.configure("settleLedger", "()I", 3, 5, 0, 2, true, false);
    settleLedger.setMemTier(policy.methodTierFromModifiers(policy.MOD_ACCURATEMEM));
    SLVMMethod mainFn = new SLVMMethod();
    < no tier modifier >
    mainFn.configure("main", "()I", 8, 6, 0, 2, true, false);
    mainFn.setMemTier(policy.methodTierFromModifiers(0));

    < 4. DISPATCH: resolve each method's effective tier against the document >
    < default, then bind it to the real physical module. >
    dispatch(build, prog, policy, logActivity);
    dispatch(build, prog, policy, settleLedger);
    dispatch(build, prog, policy, mainFn);
  }

  void dispatch(SLExecutorBuild build, SLProgram prog, SLMemoryTierPolicy policy, SLVMMethod m) {
    < method tier else document default >
    int effective = prog.effectiveTier(m.tier());
    < the PHYSICAL module >
    SLMemoryModule mod = build.memoryForTier(effective);
    print("  " + m.methodName() + ": declared=" + policy.tierName(m.tier()) +
          " -> effective=" + policy.tierName(effective) +
          " -> binds " + mod.name() + " (" + mod.technologyName() + ")");
  }
}