<< lib/xlt/SLXltSource.sleela SLeeLa Standard Library Definition. Definition: Defines SLXltSource — the canonical source-time representation of an XLT (.xlt) CPU-model sheet, the exact counterpart of SSTSource for the SST (.sst) layer. Where SST declaratively authors a SYSTEM of library symbols, XLT declaratively authors a CPU MODEL: a chosen CPU SKU plus the board, memory, cadence, storage, and bus parts that assemble it. The format needs no new keyword and no setters — the document's ORTHOGONALITY (each part declared once, in order, non-overlapping) is itself what guarantees the model's integrity and a clear compilation. An .xlt sheet reads: #xlt 1.0 model Name { < a real CPU SKU class > cpu "SLAMDEPYC9575F"; < a real SLMotherboard preset (optional) > board "wrx90"; < a real SLMemoryModule preset + capacity > memory "ddr2_800" 4096; < SLCadenceConnector cadence to present > cadence "DDR2"; < optional > storage "nvmeGen4"; < optional > bus "pcieGen5x16"; < optional capability: native GPU > gpu; < optional capability: DMA engine > dma; < optional capability: NATIVE_RAM bit > nativeram; < optional: run this program on the build > program "app.sleela" sleela; < optional: memory words + cycle budget > grant 65536 1000000; target sleela; } When a `program` is declared, a congruent build is politely RUN: the compiler admits an SLWorkload (source + language) under an SLCPUResource grant and executes it on build.processor() via SleelaVMCreator — the sanctioned path (admission-checked, through the model's fetch-decode-execute loop), never reaching around the CPU model. The compile path parallels SST's: .xlt -> SLXltCompiler -> SLExecutorBuild (real parts) -> SLProgram/VM Family: xlt. Source-time contract; resolved by SLXltCompiler into a real SLExecutorBuild. Mirrors lib/sst/SSTSource. >> #sleela 2.5 material; class SLXltSource { < ---- 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 = 11280; String metaAuthor = "Kiro Agent"; String metaDate = "2026-10-16"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-10-16"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 9; < 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; } < the .xlt file path > String path; < the `model Name { ... }` identifier > String modelName; < `target sleela;` > String target; < the /lib root parts resolve against > String libraryRoot; < The declared parts, one per orthogonal slot (each may be set at most once). > < CPU SKU class name, e.g. "SLAMDEPYC9575F" > String cpuRef; < SLMotherboard preset, e.g. "wrx90" (empty = none) > String boardRef; < SLMemoryModule preset, e.g. "ddr2_800" > String memoryRef; < capacity argument for the memory preset > int memoryCapMiB; < cadence to present, e.g. "DDR2" (empty = native) > String cadenceRef; < SLStorageDevice preset (empty = none) > String storageRef; < SLSystemBus preset (empty = none) > String busRef; < Capability directives: bare orthogonal flags (declared at most once each). > < `gpu;` -> build.enableGPU() > int gpuFlag; < `dma;` -> build.enableDMA() > int dmaFlag; < `nativeram;` -> declare the NATIVE_RAM feature bit > int nativeRamFlag; < Memory-tier designation: the model may split memory into a "usual" tier > < (for usual activities) and an "accurate" tier (for competency/accuracy), > < and name which is the default (main) tier. Each memory preset slot below. > < memory preset for the usual tier, e.g. "ddr2_800" > String usualTierRef; < memory preset for the accurate tier, e.g. "ddr5_6400" > String accurateTierRef; < "usual" or "accurate" — which the main program uses > String mainTier; < Optional workload: the program this model should politely run on the built > < CPU (source path + language), and the resource grant it is admitted under. > < e.g. "app.sleela" (empty = build hardware only) > String programPath; < "sleela" | "c" | "cpp" | "java" > String programLang; < memory words requested (0 = compiler default) > int grantWords; < cycle budget requested (0 = compiler default) > int grantBudget; int validated; void configure(String sourcePath, String root) { path = sourcePath; libraryRoot = root; modelName = ""; target = "sleela"; cpuRef = ""; boardRef = ""; memoryRef = ""; memoryCapMiB = 0; cadenceRef = ""; storageRef = ""; busRef = ""; gpuFlag = 0; dmaFlag = 0; nativeRamFlag = 0; usualTierRef = ""; accurateTierRef = ""; mainTier = ""; programPath = ""; programLang = ""; grantWords = 0; grantBudget = 0; validated = 0; } void setModelName(String name) { modelName = name; } void setTarget(String t) { target = t; } < Orthogonal part declarations: each returns false if the slot was already > < filled (a duplicate breaks document orthogonality and must be reported). > boolean declareCpu(String ref) { if (cpuRef != "") { return false; } cpuRef = ref; return true; } boolean declareBoard(String ref) { if (boardRef != "") { return false; } boardRef = ref; return true; } boolean declareMemory(String ref, int capMiB) { if (memoryRef != "") { return false; } memoryRef = ref; memoryCapMiB = capMiB; return true; } boolean declareCadence(String ref) { if (cadenceRef != "") { return false; } cadenceRef = ref; return true; } boolean declareStorage(String ref) { if (storageRef != "") { return false; } storageRef = ref; return true; } boolean declareBus(String ref) { if (busRef != "") { return false; } busRef = ref; return true; } < Capability directives: each may be declared at most once (orthogonal). > boolean declareGpu() { if (gpuFlag == 1) { return false; } gpuFlag = 1; return true; } boolean declareDma() { if (dmaFlag == 1) { return false; } dmaFlag = 1; return true; } boolean declareNativeRam() { if (nativeRamFlag == 1) { return false; } nativeRamFlag = 1; return true; } < Memory-tier designation (orthogonal: each tier declared at most once). > boolean declareUsualTier(String ref) { if (usualTierRef != "") { return false; } usualTierRef = ref; return true; } boolean declareAccurateTier(String ref) { if (accurateTierRef != "") { return false; } accurateTierRef = ref; return true; } boolean declareMainTier(String which) { if (mainTier != "") { return false; } mainTier = which; return true; } < Workload + grant (each declared at most once; orthogonal). > boolean declareProgram(String path, String lang) { if (programPath != "") { return false; } programPath = path; programLang = lang; return true; } boolean declareGrant(int words, int budget) { if (grantWords != 0 || grantBudget != 0) { return false; } grantWords = words; grantBudget = budget; return true; } boolean validate() { validated = 1; return 1 == 1; } String sourcePath() { return path; } String name() { return modelName; } String targetName() { return target; } String cpu() { return cpuRef; } String board() { return boardRef; } String memory() { return memoryRef; } int memoryCapacity() { return memoryCapMiB; } String cadence() { return cadenceRef; } String storage() { return storageRef; } String bus() { return busRef; } boolean hasBoard() { return boardRef != ""; } boolean hasCadence() { return cadenceRef != ""; } boolean hasStorage() { return storageRef != ""; } boolean hasBus() { return busRef != ""; } boolean wantsGpu() { return gpuFlag == 1; } boolean wantsDma() { return dmaFlag == 1; } boolean wantsNativeRam() { return nativeRamFlag == 1; } String usualTier() { return usualTierRef; } String accurateTier() { return accurateTierRef; } String main() { return mainTier; } boolean hasTiers() { return usualTierRef != "" || accurateTierRef != ""; } String program() { return programPath; } String programLanguage() { return programLang; } boolean hasProgram() { return programPath != ""; } int grantWordsRequested(){ return grantWords; } int grantBudgetRequested(){ return grantBudget; } }