Kera ja langetamise töö
Veateade, mis polnud tegelikult viga
Lugu algab tavaliselt numbriga, mis on peaaegu õige. Mitte täiesti vale. Mitte sellisel moel katki, et armatuurlaud punaseks muutuks. Peaaegu õige kallil moel: selline viga, mis laseb ühel meeskonnal toote välja anda, teisel kõhkleda ja audiitoril küsida, miks tulemus muutus, kui sama mudel liikus ühelt masinalt teisele.
Üks build jookseb x86-serveril ja annab väärtuse. Järgmine build jookseb ARM-sülearvutil ja annab väärtuse, mis on piisavalt lähedal, et demo ellu jääks. GPU-tee on kiirem, kuid ümardab arvutuskäigu jooksul teistmoodi. FPGA-tee on aja mõttes ahvatlev, kuid järsku peab tarkvarameeskond riistvarast rääkima. Igaüks oskab seletada väikest osa erinevusest. Keegi ei oma tervet teed lähtekoodist tulemuseni.
Just selle ruumi jaoks on Kera loodud. Mitte mudeli idee, mitte turundusslaid, mitte paber tuleviku kompilaatorist, vaid kompilaatoritöö, mis algab siis, kui meeskond ütleb, et sama arvutus peab jooksma erinevatel masinatel ja tähendama ikkagi sama asja. See kohustus vajab omanikku. Kompilaatori lubadus pole see, et lowering on elegantne. Lubadus on see, et loweringut koheldakse tööna.
Lowering on kompilaatori osa, kus ilus keelekavatsus muutub juhisteks, mida sihtplatvorm suudab täita. See on ka koht, kus ebamäärased väited nähtavaks muutuvad. Kui tulemus peaks olema bitihaaval identne CPU, GPU, FPGA ja WebAssembly vahel, siis ei saa kompilaator sihtplatvormide erinevuste ees õlgu kehitada. See peab kandma piisavalt struktuuri, et otsustada, mis võib muutuda ja mis ei tohi muutuda. See peab teadma mäluruume, efekte, opkoode, andmeliikumist, sihtplatvormi piiranguid ja tõendeid, mis tõestavad, et kaks buildi on sama arvutus.
Ahvatlev versioon loost on nimetada seda teisaldatavuskihiks. See on liiga väike. Teisaldatavus ütleb, et programm jookseb mujal. Kera sihib raskemat väidet: programm on esitatud sisupõhise aadressiga graafina, kompileeritud .keg-artefaktiks, langetatud mitmele backendile ja annab ikkagi sama vastuse. Köök muutub. Retsept mitte.
Keskmine osa, mida keegi müüa ei taha
Esimene vestlus tõsise ostjaga algab harva süntaksist. See algab segadusest. On mudel, mis loeb. On simulatsioon, mis oli kunagi teadustöö ja on muutunud operatiivseks. On riskiarvutus, mille tulemus ei tohi enam masinati erineda. On servaseade, mis ei suuda kanda täit pilveruntime’i. On meeskond, kes tahab kiirendit, kuid ei saa endale lubada ümberkirjutust iga kord, kui kiirendi muutub.
Enamik tööriistu teeb selle välja nagu juurutamisprobleemi. Vali sihtplatvorm, ekspordi mudel, paika runtime, lepi mõne variatsiooniga, siis kirjuta dokument, mis erandeid selgitab. Dokument kasvab. Testimaatriks kasvab. Spetsialistide arv kasvab. Lõpuks maksab organisatsioon heterogeensuse eest kaks korda: üks kord, kui riistvara ostetakse, ja teine kord, kui püütakse tõestada, et riistvara tegi sama töö.
Kera alustab vastupidisest otsast. Kera leht nimetab seda staatiliselt tüpiseeritud süsteemikeeleks, millel on graafipõhine, sisupõhise aadressiga IR. See fraas on oluline, sest graaf pole dekoratiivne kompilaatoriskeem. See on käivitatav objekt. Lähtekood langetatakse operatsioonide suunatud atsüklilisteks graafideks, mis salvestatakse .keg-failidena. Iga sõlm kannab määratletud struktuuri. Dubleerivat tööd saab struktuurselt kõrvaldada. Sama graafi saab langetada CPU-le, GPU-le, FPGA-le ja WASM-ile, ilma et iga sihtplatvormi koheldaks eraldi väikese universumina.
Seepärast peab Kera käituma nagu tõsine kompilaatori infrastruktuur, mitte nagu diagramm. Ebamugav vahepealne ala on see, kus klient elab. Tokeniseerimine peab säilitama baidipositsioonid. Parsimine peab toitma nii tööriistu kui ka kompileerimist. Tüübikontroll peab lükkama tagasi kuju ja servade mittevastavused enne, kui neist saavad käitusaja sündmused. Laenukontroll peab mõistma omandust host-, seadme-, kinnitatud ja ühtse mälu vahel. Optimeerimine peab olema korratav. Serialiseerimine peab organisatsioonile andma eseme, mida saab säilitada.
Ükski sellest ei tee dramaatilist pealkirja. See on palju kasulikum kui pealkiri. See tähendab, et kui töökoormus liigub arendusest tootmisse või CPU baasjoonega GPU rajale, on kompilaatoril stabiilne asi, millega võrrelda: graafi sõrmejälg. Kui sõrmejälg ühtib, on töö sama töö. See on ühine kontrollpunkt, millest saavad aru insener, ostja ja audiitor.
Graaf on kviitung, mitte pilt
Vana viis programmi selgitamiseks on näidata lähtekoodi ja paluda lugejal kompilaatorit usaldada. Kera leht pöördub pidevalt tagasi teistsuguse objekti juurde: graafi. Iga operatsioon on sõlm. Servad väljendavad sõltuvusi. Graafil on sisu. Sisu on räsi. Räsi muutub sõrmejäljeks, mis liigub läbi ehituse.
See kõlab nagu sisemine mehhanism, kuni seisate kõrvuti vastavusmeeskonnaga. Vastavusmeeskond ei taha teada, et müüjal on kena kompilaatori arhitektuur. Ta tahab teada, kas eelmisel kuul heaks kiidetud arvutus on see, mis täna töötab. Graafi sõrmejälg on sild nende maailmade vahel. See ei ole kompilaatori ekraanipilt. See on kompaktne viis öelda: see operatsioonide hulk, need tüübid, need sisendid, need atribuudid, see sõltuvuste struktuur.
Sõlmemudel on tahtlikult range. Sõlm on skeemi versioon, opkood, väljundikirjeldused, sisendräsid ja atribuutide kaardid, mis on paigutatud kanoonilises järjekorras. Baidid räsitakse SHA3-256 abil domeenipõhiste prefiksite all, nii et sõlme-, piirkonna- ja graafiräsid elavad eraldi nimeruumides. Kui kahel sõlmel on sama opkood, sisendid ja atribuudid, on neil sama räsi. Duplikaadi sisestamine tagastab olemasoleva kirje. Ühise alamavaldise elimineerimine muutub esituse tagajärjeks, mitte hiljem lisatud kangelaslikuks läbimiseks.
Selline detail muudab insenerisüsteemi millekski, millele inimesed saavad loota. Ostja ei osta kompilaatori diagrammi. Ostja ostab vähem vaidlusi selle üle, kas arvutus muutus. Arendaja ei osta loosungit deterministlikust tehisintellektist. Arendaja ostab graafivormingut, kus samasust saab kontrollida, salvestada ja tööriistadega kasutada. Seetõttu ei ole .keg-fail järelmõte rakendamisel. See on tehtud töö kaasaskantav rekord.
Kaheksa väikest ust enne sihtmärgi ilmumist
Kui inimesed kujutlevad kompilaatorit, hüppavad nad sageli otse tagumisse otsa. Nad näevad hetke, mil kood muutub AVX-iks, PTX-iks, Verilogiks või WASM-iks. See hetk on oluline, kuid see on loo hilises osas. Suurem osa kompilaatori tööst on selleks ajaks juba toimunud, vaiksetes etappides, mis otsustavad, kas tagumist ossa saab usaldada.
Kera algab UTF-8-teadliku lekseriga, mis muudab lähtekoodi tokeniteks, jälgides täielikult trivia ja taastades vigu. See kõlab nagu redaktori torustik, ja seda see on. See on ka tööriistaahela usaldusväärsus. Kui iga baidi positsioon on säilinud, saavad diagnostika, vormindamine, inkrementaalne uuesti parsimine ja keeleserveri käitumine ühtida sellega, mida kasutaja tegelikult kirjutas. Kompilaator, mis kaotab lähtekuju varakult, maksab selle kaotuse eest kõikjal mujal.
Parser on sündmuspõhine: rekursiivne laskumine koos Pratti avaldiste parsimisega väljastab Start, Token, Finish ja Error sündmused, selle asemel et ehitada ühte AST-i, mida kõik peavad jagama. Sündmuste voog toidab puuehitajat, vormindajat ja keeleserverit sõltumatult. Roheline puu on kadudeta, säilitades tokenid ja trivia. Seejärel kõnnib graafiehitaja sellest puust läbi, haldab nimede lahendamist ja loob iga funktsiooni jaoks Region-sõlme.
Alles pärast seda muutub lähtekood graafiks, mida kompilaator kannab. Struktuurne tüübikontroll valideerib ühilduvust operatsiooniservade ja tensorikuju piirangute vahel. Tüübid ühtivad ainult siis, kui nende kanoonilised räsid on identsed. Laenukontrollija nõuab ühte omanikku väärtuse kohta, ei luba aliastega muutujaid viiteid ja rakendab omandiõiguse reegleid mäluruumide vahel. Efektiannotatsioone kontrollitakse järjepidevuse suhtes. Kõrvalmõjud ei jää maitse või kokkuleppe hooleks.
Optimeerimise passihaldur teeb seejärel äratuntava kompilaatoritöö: konstantide voltimine, ühiste alamavaldiste elimineerimine, surnud koodi elimineerimine, inlining, vektoriseerimine ja silmusfusion fikseeritud punkti tsüklis. Oluline fraas ei ole passide loend. See on see, mis juhtub pärast iga passi: graafi invariandi valideerija kontrollib räsi konsistentsi ja sõltuvuse terviklikkust. Optimeerimine tohib graafi parandada, mitte muuta seda mõistatuseks.
Lõpuks väljastavad sihtspetsiifilised koodigeneraatorid natiivkoodi, PTX-i, Verilogi või WASM-i, ja optimeeritud graaf serialiseeritakse .keg-faili koos sektsioonitabeliga. Fail algab maagiliste baitidega KEG\0 ja kannab sektsioone stringide, tüüpide, atribuutide, sõlmede, piirkondade ja eksportide jaoks. See on tee, mille meeskond peab omama, enne kui saab ausalt sihtidest rääkida.
Sihtid ei ole kleebised slaidil
Sihtide loendit on lihtne kirjutada ja raske ära teenida. CPU, GPU, FPGA ja WASM mahuvad kenasti tootekaardile. Nendeni alandamine on koht, kus arve peitub. Igal sihtil on oma harjumused, tugevused ja rikkerežiimid. Kompilaator, mis tahab deterministlikku heterogeenset täitmist, ei saa neid harjumusi käsitleda kellegi teise probleemina.
Protsessoritel (CPU) genereerib Kera masinakoodi x86-64 ja ARM64 arhitektuuridele, RISC-V Vector on tehnilises lehes. x86-tee valib SSE2, AVX2 või AVX-512; ARM-tee kasutab NEON-i; registrijaotur ja planeerija on ühised. Toote väide ei ole pelgalt see, et binaarfail eksisteerib. Väide on, et sihtspetsiifilised SIMD-tuumad valitakse, samal ajal kui graaf jääb samaks arvutuseks.
GPU-del nimetab lähtematerjal PTX-i genereerimist CUDA ja ROCm jaoks, kusjuures tensor-tuumasid kasutatakse siis, kui tuuma kuju seda võimaldab. See viimane lause teeb tööd. Riistvaraline kiirendus ei ole võlupulber. Tuuma kuju kas sobib tensor-tuuma rajale või ei sobi. Kompilaator peab seda ausalt näitama, liigutama vajadusel andmeid hosti ja seadme vahel ning hoidma graafi sõrmejälge tõendina selle kohta, mida täidetakse.
FPGA-l muutub alandamistee riistvaraliseks vestluseks: Verilog-i süntees, ressursihinnang, ajastusanalüüs ja torustiku planeerimine etteaimatava, tsüklitäpse käitumise jaoks. See on selline sihtmärk, kus käteviibutamine on eriti kallis. Kui ostja vajab ranget reaalajas tööd, peab kompilaatori pind rääkima tsüklites, ressurssides ja torustikes, mitte ainult kiiruses. Kera lugu teeb FPGA-st sama graafi tagumise otsa, mitte teise meeskonna ümberkirjutuse.
WASM-i puhul nimetab leht 128-bitist SIMD-i serva- ja brauserikasutuseks. See on oluline, sest serv on koht, kus kasutuselevõtu reaalsus põrkub sageli puhtusega. Brauser, väike seade või piiratud käituskeskkond ei suuda alati majutada sama virna nagu server. Graafipõhine alandamistee annab meeskonnale võimaluse kanda sama arvutus sellesse keskkonda, ilma et serv muutuks teiseks tooteks.
Determinism peab ellu jääma ka edu korral
Determinismi on väikeses ruumis lihtne lubada. See muutub raskemaks, kui toode õnnestub. Kasutajaid tuleb juurde. Riistvara ilmub juurde. Mudel liigub ühelt kiibilt teisele. Ühele keskkonnale kirjutatud testibaas peab katma teist. Kahjutu näiv optimeerimine muudab redutseerimise järjekorda. Kiire tee ilmub ühes käituskeskkonnas, kuid mitte teises.
The Kera page frames determinism as bit for bit across platforms. That is not a cosmetic claim. It changes product obligations. Primitive arithmetic has defined precision semantics across all targets. Reductions have defined tie-breaking so scheduling and hardware do not change the result. Neural network primitives have deterministic implementations on CPU, GPU, FPGA, and WASM. The graph means the same thing wherever it runs.
This is why undefined behaviour, garbage collector pauses, and implicit side effects are not small language preferences. They are cracks in the execution surface. Kera’s page says no LLVM dependency, no garbage collector, no undefined behaviour. Explicit types, explicit effects, and ownership across memory spaces are product controls. They reduce the number of places a result can change while everyone is looking somewhere else.
There is a human side to this too. When a robotics controller changes behaviour across devices, when a finance workflow rounds one cent differently, when a scientific result cannot be repeated by a reviewer, or when a game simulation diverges between targets, the argument is not really about compiler theory. It is about institutional confidence. Kera’s consumer copy uses simple stories because the underlying problem is simple to feel: same instructions, same answer, on any computer you own.
That confidence must survive acceleration. If performance requires teams to abandon determinism, the product has only moved the risk. Kera tries to keep performance and determinism in the same contract by making the graph the unit of meaning and the target path the unit of execution.
Security is part of lowering
Compiler discussions often isolate security as runtime work. Kera’s source material does not. It talks about capability-based security, a SecurityManager, a default-deny gate, a PolicyBuilder, seccomp BPF, Linux namespaces, and a thread-safe tamper-evident audit log in a fixed-capacity ring buffer. Those words belong in the engineering story because lowering does not end when instructions are emitted. The emitted work still has to run with boundaries.
Capability tokens are granted at startup. Privileged actions require an explicit capability. Access rules are declared up front. A BPF filter restricts syscalls. Namespace isolation separates process, mount, and network views. Security-relevant events land in an audit log. The short sentenceis: nothing is permitted by default.
That matters for heterogeneous execution because targets create surfaces. A CPU process, GPU transfer, FPGA path, browser runtime, and distributed job do not fail in identical ways. A product has to keep policy attached to the work as it moves. If the graph says what the computation is, the runtime controls say what the computation may do.
There is also an operations reason to bring security into the compiler story. Teams do not want one product for compilation, anotherfor policy, another for logging, and another for explanation if the seams between them become the place where incidents hide. Kera’s page does not claim to solve all security. It does something narrower and more useful: it makes permissions explicit and auditedin the execution environment the compiler feeds.
Distributed work is still lowering
The technical sheet names distributed execution, ring allreduce, and checkpoint recovery. In another product, those might be brochure items. In Kera, they belong to the same lowering conversation because parallelism changes the shape of a computation. Data, model, and pipeline parallelism are not just ways to go faster. They are ways to split work without losing the meaning of the original graph.
Kui suur töö jookseb üle paljude masinate ja üks sõlm ebaõnnestub, ei ole kontrollpunktist taastumine mugavus. See on osa arvutuse operatiivseks muutmisest. Kui tulemusi koondatakse usaldusväärselt, tuleb koondamise semantika määratleda. Kui graaf on sisupõhise aadressiga, peab hajutatud tee säilitama graafi identiteedi, mitte looma teist reaalsust, kui töö lahkub ühelt masinalt.
Siin muutub toote tõlgendus selgeks. Kera ei ole süntaksikiht hajutatud lisandmooduliga. See püüab muuta arvutuse teisaldatavaks nii kuju kui ka riistvara lõikes: üks programm, üks graaf, mitu täitmise sihtmärki ja kontrollitav kirje. Hajutatud täitmine on veel üks koht, kus alandamine peab kandma täitmise lepingut.
See muudab ka personaliloos. Ilma ühise kompileerimisteea võib viga, mis ilmneb ainult ühel platvormil, nõuda inimesi, kes tunnevad korraga nii kiipi, tööriistaahelat kui ka käitusaega. Ühe graafi ja ühise teega on küsimus teravam: kas graaf muutus, kas alandamise tee muutus või rikkus sihtmärk määratletud semantikat? Paremad küsimused ei eemalda rasket tööd. Need peatavad raske töö juhusliku leviku.
Miks peab keegi teed omama
Alandamine ei saa jääda omanikuta, kui see kannab tulemusi, millele inimesed toetuvad. Graaf, mis töötab CPU-l, GPU-l, FPGA-l ja WASM-is, vajab enamat kui nutikat esitust. See vajab dokumentatsiooni, diagnostikat, sihtmärgi väiteid, redaktori käitumist, koodigeneratsiooni, turvakontrolle, tugivestlusi ja võimalust öelda ostjale täpselt, mis muutus, kui tulemus muutub.
See ei muuda tööd vähem tehniliseks. See muudab tehnilise töö siduvamaks. Kera on praegu kaubanduslik Dweve toode, mitte avatud lähtekoodiga väljalase: kõik õigused kaitstud, saadaval kaubandusliku litsentsi all, valmistatud Hollandis ja mõeldud organisatsioonidele, mis vajavad graafitee toetamist, mitte ainult avaldamist. Kui lehel on kirjas Rust 2021, graafi IR, kohandatud JIT, mitte LLVM, CPU/GPU/FPGA/WASM, efektide jälgimine, omand mäluruumide lõikes, võimekuspõhine turve, hajutatud täitmine, C ja Pythoni manustamine, CLI töövood, redaktori tugi ja LSP tööriistad, ei ole need dekoratiivsed sisemused. Need on kohustused, mis peavad üle elama reaalsete töökoormuste hindamise.
Võimekuste leht on selles osas hoolikas. See kirjeldab disaini eesmärke ja ütleb, et tuleb kontrollida oma töökoormuse vastu. See vaoshoitus on oluline. See on palju tervislikum kui teeselda, et iga benchmarki number kandub edasi. Süsteem peaks andma meeskondadele võimaluse mõõta, kontrollida ja võrrelda oma keskkonnas, mitte nõudma, et nad aktsepteeriksid universaalset kiiruslugu.
Keegi peab seda teed omama, sest iga sihtmärk püüab muuta allika vähem universaalseks. Kera on koht, kus need sihtmärgi erinevused muutuvad selgesõnaliseks kompilaatoritööks, mitte folklooriks, mida veateate järel edasi antakse.
Päev, mil graaf muutub lepinguks
Kujutage uuesti ette algset veateadet, kuid Kera on juba töövoos. Finantsmeeskond kiidab heaks riskiarvutuse. Graafi sõrmejälg salvestatakse. Esimene juurutamine töötab CPU-l. Hiljem lisatakse portfellianalüüsiks GPU tee. Veel hiljem kasutatakse madalama latentsusega hinnastamiseks FPGA teed. Küsimus igal sammul ei ole see, kas uus riistvara kõlab muljetavaldavalt. Küsimus on, kas sama graafi alandatakse ja kas sihtmärgi semantika hoiab tulemuse identsena.
Vestlus muutub. Platvormimeeskond saab rääkida ajastamisest ja kuludest. Kompilaatorimeeskond saab rääkida tagumistest otsadest. Vastavusmeeskond saab rääkida sõrmejäljest. Ettevõtte omanik saab küsida, kas riistvara vahetamine on operatiivne otsus või ümberkirjutamine. Toode annab neile kõigile ühe objekti, millele osutada.
Sisupõhiste IR-ide vaikne väärtus seisneb selles. See muudab platvormiülese täitmise veenvate selgituste jadast arvestuseks. See muudab graafi kviitungiks. See võimaldab samal .keg-failil toita kõiki taustsüsteeme. See annab organisatsioonile lähtetaseme, mis kuulub arvutusele, mitte ühele masinale.
Ükski kompilaator ei saa kõrvaldada inseneritarkuse vajadust. Meeskonnad peavad siiski sihtmärke hoolikalt valima, töökoormusi ausalt testima, sihtmärkide piiranguid mõistma ja otsustama, millised valdkonnad nõuavad bititäpset identsust. Kuid Kera saab need otsused läbipaistvaks muuta. See suudab ära hoida jõudluse migratsiooni muutumist kogemata semantiliseks migratsiooniks.
Alandamise õppetund
Kera on oluline, sest raske osa ei ole nutika alandamise idee olemasolu. Raske osa on selle idee läbiviimine läbi kõigi igavate kohtade, kus inseneritöö muutub kas usaldusväärseks või folklooriks: diagnostika, rohelised puud, tüübi räsid, laenukontroll, fikseeritud punkti optimeerimine, invariantside valideerimine, .keg-serialiseerimine, taustsüsteemi emissioon, turvapoliitika, auditilogid, redaktori tugi ja sihtmärgipõhine täitmine.
Alandamine on töö, sest iga sihtmärk püüab muuta allika vähem universaalseks. Deterministlik kompilaatoritehnika on distsipliin, mis keeldub lubamast sellel vaikselt juhtuda. CPU tahab vektoreid. GPU tahab kerneliid. FPGA tahab tsükleid. WASM tahab piiranguid. Organisatsioon tahab ühte vastust. Kera ülesanne on säilitada arvutuse tähendus, lastes samal ajal igal sihtmärgil teha seda, milles see on hea.
See on inseneri kuju, mitte paberi abstraktsioon. Sellel on ostja, rikkerežiim, failivorming, kompilaatori tee ja operatiivsed tagajärjed. Lubadus ei ole see, et riistvara muutub lihtsaks. Lubadus on see, et keerukus on esindatud, alandatud, kontrollitud ja omatud.
Kui järgmine peaaegu õige number saabub, ei peaks meeskond alustama folkloorist selle kohta, milline masin mida käitas. See peaks algama graafist. Kas sõrmejälg klappis? Milline taustsüsteem koodi emiteeris? Millised võimalused anti? Milliseid sihtmärgi semantikaid rakendati? Milline artefakt salvestati? Need on tooteküsimused. Kera on olemas, sest need on ka kompilaatori küsimused.