ProHoster > Blog > Administratioun > Groussen Interview mam Cliff Click, de Papp vun der JIT-Kompilatioun op Java

Groussen Interview mam Cliff Click, de Papp vun der JIT-Kompilatioun op Java

Groussen Interview mam Cliff Click, de Papp vun der JIT-Kompilatioun op JavaCliff Klick - CTO vu Cratus (IoT Sensoren fir Prozessverbesserung), Grënner a Matgrënner vu verschiddene Startups (inklusiv Rocket Realtime School, Neurensic an H2O.ai) mat e puer erfollegräichen Sortien. De Cliff huet säin éischte Compiler am Alter vu 15 geschriwwen (Pascal fir den TRS Z-80)! Hien ass am Beschten bekannt fir seng Aarbecht op C2 am Java (The Sea of ​​​​Nodes IR). Dëse Compiler huet d'Welt gewisen datt JIT qualitativ héichwäerteg Code produzéiere kann, wat ee vun de Faktoren an der Entstoe vu Java als eng vun den Haaptmoderne Softwareplattformen war. Dunn huet Cliff Azul Systems gehollef en 864-Kär Mainframe mat purer Java Software ze bauen déi GC Pausen op engem 500-Gigabyte Koup bannent 10 Millisekonnen ënnerstëtzt. Am Allgemengen huet de Cliff et fäerdeg bruecht un all Aspekter vum JVM ze schaffen.

 
Dësen Habrapost ass e super Interview mam Cliff. Mir schwätzen iwwer déi folgend Themen:

  • Iwwergang op niddereg-Niveau Optimisatiounen
  • Wéi eng grouss Refactoring ze maachen
  • Käschte Modell
  • Low-Level Optimisatiounstraining
  • Praktesch Beispiller vun Leeschtung Verbesserung
  • Firwat Är eege Programméiersprooch erstellen
  • Leeschtung Ingenieur Carrière
  • Technesch Erausfuerderungen
  • E bëssen iwwer Registerallokatioun a Multi-Cores
  • Déi gréissten Erausfuerderung am Liewen

Interviewe ginn duerchgefouert vun:

  • Andrey Satarin vun Amazon Web Services. A senger Carrière huet hien et fäerdeg bruecht a komplett verschidde Projeten ze schaffen: hien huet d'NewSQL verdeelt Datebank zu Yandex getest, e Cloud Detektiounssystem am Kaspersky Lab, e Multiplayer-Spill an Mail.ru an e Service fir d'Berechnung vun Auslandspräisser an der Deutsche Bank. Interesséiert fir grouss Skala Backend a verdeelt Systemer ze testen.
  • Vladimir Sitnikov aus Netcracker. Zéng Joer Aarbecht iwwer d'Performance an d'Skalierbarkeet vum NetCracker OS, Software déi vun Telekomoperateuren benotzt gëtt fir Netzwierk- an Netzwierkausrüstungsmanagementprozesser ze automatiséieren. Interesséiert an Java an Oracle Datebank Leeschtung Problemer. Auteur vu méi wéi enger Dose Leeschtungsverbesserungen am offiziellen PostgreSQL JDBC Chauffer.

Iwwergang op niddereg-Niveau Optimisatiounen

Andrei: Dir sidd e groussen Numm an der Welt vun JIT Compilatioun, Java, a Leeschtung Aarbecht am Allgemengen, richteg? 

Cliff: Et ass esou!

Andrei: Loosst d'mat e puer allgemeng Froen iwwer Leeschtung Aarbecht ufänken. Wat mengt Dir iwwer d'Wiel tëscht héijen an niddregen Optimisatiounen wéi um CPU-Niveau ze schaffen?

Cliff: Jo, hei ass alles einfach. De schnellsten Code ass deen deen ni leeft. Dofir musst Dir ëmmer vun engem héijen Niveau ufänken, un Algorithmen schaffen. Eng besser O Notatioun wäert eng méi schlecht O Notatioun schloen, ausser e puer grouss genuch Konstanten intervenéieren. Niddereg-Niveau Saachen ginn lescht. Typesch, wann Dir de Rescht vun Ärem Stack gutt genuch optimiséiert hutt an et sinn nach ëmmer interessant Saachen iwwreg, dat ass en nidderegen Niveau. Awer wéi vun engem héijen Niveau ufänken? Wéi wësst Dir datt genuch Aarbecht op héijem Niveau gemaach gouf? Gutt ... kee Fall. Et gi keng fäerdeg Rezepter. Dir musst de Problem verstoen, entscheeden wat Dir maacht (fir net onnéideg Schrëtt an Zukunft ze huelen) an da kënnt Dir de Profiler entdecken, deen eppes nëtzlech ka soen. Iergendwann mierkt Dir selwer datt Dir vun onnéidege Saachen läscht hutt an et ass Zäit fir e puer niddereg-Niveau-Fintuning ze maachen. Dëst ass definitiv eng speziell Art vu Konscht. Et gi vill Leit déi onnéideg Saache maachen, awer sou séier bewegen datt se keng Zäit hunn fir sech iwwer Produktivitéit ze këmmeren. Awer dëst ass bis d'Fro stellt sech direkt. Normalerweis 99% vun der Zäit këmmert sech keen wat ech maachen, bis dee Moment wou eng wichteg Saach op de kritesche Wee kënnt, dee kee sech interesséiert. An hei fänkt jidderee un Iech un "firwat et vun Ufank un net perfekt geschafft huet." Am Allgemengen ass et ëmmer eppes ze verbesseren an der Leeschtung. Awer 99% vun der Zäit hutt Dir keng Leads! Dir probéiert just eppes ze maachen fonctionnéieren an am Prozess erauszefannen wat wichteg ass. Dir kënnt ni am Viraus wëssen datt dëst Stéck perfekt muss sinn, also musst Dir an allem perfekt sinn. Awer dëst ass onméiglech an Dir maacht et net. Et ginn ëmmer vill Saachen ze fixéieren - an dat ass ganz normal.

Wéi eng grouss Refactoring ze maachen

Andrei: Wéi schafft Dir un enger Leeschtung? Dëst ass e cross-cutting Problem. Zum Beispill, hutt Dir jeemools missen un Probleemer schaffen, déi aus der Kräizung vu ville existente Funktionalitéit entstinn?

Cliff: Ech probéieren et ze vermeiden. Wann ech weess datt d'Leeschtung en Thema wäert sinn, denken ech doriwwer ier ech ufänken ze codéieren, besonnesch mat Datestrukturen. Awer dacks entdeckt Dir dat ganz spéider. An da musst Dir op extrem Moossname goen a maachen wat ech "rewrite and conquer" nennen: Dir musst e grousst genuch Stéck gräifen. E puer vum Code musse nach ëmmer ëmgeschriwwe ginn wéinst Leeschtungsproblemer oder soss eppes. Wat och ëmmer de Grond fir de Code ëmzeschreiwen, et ass bal ëmmer besser e méi grousst Stéck wéi e méi klengt Stéck ëmzeschreiwen. Zu dësem Moment fänkt jidderee vun Angscht un: "Oh mäi Gott, Dir kënnt net sou vill Code beréieren!" Awer tatsächlech funktionnéiert dës Approche bal ëmmer vill besser. Dir musst direkt e grousse Problem unhuelen, e grousse Krees ronderëm zéien a soen: Ech wäert alles am Krees ëmschreiwen. D'Grenz ass vill méi kleng wéi den Inhalt dobannen, dee muss ersat ginn. A wann esou Ofgrenzung vu Grenzen erlaabt Iech d'Aarbecht bannen perfekt ze maachen, sinn Är Hänn fräi, maacht wat Dir wëllt. Wann Dir de Problem versteet, ass de Rewriting Prozess vill méi einfach, also huelt e grousse Biss!
Zur selwechter Zäit, wann Dir e grousse Rewrite maacht a feststellt datt d'Performance en Thema wäert sinn, kënnt Dir direkt ufänke Suergen doriwwer ze maachen. Dëst gëtt normalerweis an einfache Saachen wéi "Kopieer keng Daten, verwalten Daten sou einfach wéi méiglech, maacht se kleng." A grousse Rewrites ginn et Standard Weeër fir d'Performance ze verbesseren. A si dréinen bal ëmmer ëm daten.

Käschte Modell

Andrei: An engem vun de Podcasts hutt Dir iwwer Käschtemodeller am Kontext vun der Produktivitéit geschwat. Kënnt Dir erklären wat Dir domatter gemengt hutt?

Cliff: Bestëmmt. Ech war an enger Ära gebuer wou Prozessor Leeschtung war extrem wichteg. An dës Ära kënnt erëm zréck - Schicksal ass net ouni Ironie. Ech hunn ugefaang an den Deeg vun Aacht-Bit Maschinnen ze liewen; mäin éischte Computer huet mat 256 Bytes geschafft. Genau Bytes. Alles war ganz kleng. Instruktioune musse gezielt ginn, a wéi mir ugefaang hunn de Programméierungssprooch Stack erop ze bewegen, hunn d'Sprooche méi a méi opgeholl. Et war Assembler, dann Basic, dann C, an C hunn sech ëm vill Detailer gekëmmert, wéi d'Registerallokatioun an d'Instruktiounsauswiel. Awer alles war ganz kloer do, a wann ech e Pointer op eng Instanz vun enger Variabel gemaach hunn, da géif ech Laascht kréien, an d'Käschte vun dëser Instruktioun ass bekannt. D'Hardware produzéiert eng gewëssen Zuel vu Maschinnzyklen, sou datt d'Ausféierungsgeschwindegkeet vu verschiddene Saachen einfach berechent ka ginn andeems Dir all d'Instruktioune bäidréit, déi Dir lafe gitt. All vergläichen / Test / Branch / Call / Lueden / Buttek kéint dobäi ginn a gesot: dat ass d'Ausféierung Zäit fir Iech. Wann Dir op d'Verbesserung vun der Leeschtung schafft, wäert Dir definitiv oppassen op wéi eng Zuelen mat klenge waarme Zyklen entspriechen. 
Awer soubal Dir op Java, Python an ähnlech Saachen wiesselt, bewegt Dir ganz séier vun Low-Level Hardware ewech. Wat sinn d'Käschte fir e Getter op Java ze ruffen? Wann JIT am HotSpot richteg ass inlined, et wäert lueden, awer wann et dëst net gemaach huet, wäert et e Funktiounsopruff sinn. Well den Uruff op enger waarmer Loop ass, iwwerschreift et all aner Optimisatiounen an där Loop. Dofir wäert d'real Käschte vill méi héich sinn. An Dir verléiert direkt d'Fäegkeet fir e Stéck Code ze kucken an ze verstoen datt mir et a punkto Prozessor-Auergeschwindegkeet, Erënnerung a benotzte Cache sollten ausféieren. All dëst gëtt interessant nëmmen wann Dir wierklech an d'Leeschtung kommen.
Elo fanne mir eis an enger Situatioun wou d'Prozessorgeschwindegkeet fir e Jorzéngt kaum eropgaang ass. Déi al Deeg sinn zréck! Dir kënnt net méi op gutt Single-threaded Leeschtung zielen. Awer wann Dir op eemol an de parallele Computing gitt, ass et onheemlech schwéier, jidderee kuckt Iech wéi den James Bond. Zéngfach Beschleunigungen kommen hei normalerweis op Plazen, wou een eppes vermëscht huet. Concurrency erfuerdert vill Aarbecht. Fir dës XNUMXx Geschwindegkeet ze kréien, musst Dir de Käschtemodell verstoen. Wat a wéi vill kascht et? A fir dëst ze maachen, musst Dir verstoen wéi d'Zong op der Basisdaten Hardware passt.
De Martin Thompson huet e super Wuert fir säi Blog gewielt Mechanesch Sympathie! Dir musst verstoen wat d'Hardware wäert maachen, wéi genau et wäert maachen, a firwat et mécht wat et an der éischter Plaz mécht. Mat dësem ass et zimmlech einfach Uweisungen ze zielen an erauszefannen wou d'Ausféierungszäit geet. Wann Dir net déi entspriechend Ausbildung hutt, sicht Dir just eng schwaarz Kaz an engem donkele Raum. Ech gesinn d'Leit déi ëmmer d'Performance optimiséieren déi keng Ahnung hunn wat d'Häll se maachen. Si leiden vill a maachen net vill Fortschrëtter. A wann ech datselwecht Stéck Code huelen, e puer kleng Hacks rutschen an e fënnef- oder zéngfache Geschwindegkeet kréien, si si wéi: gutt, dat ass net fair, mir woussten scho datt Dir besser wier. Erstaunlech. Wat schwätzen ech iwwer ... de Käschtemodell geet iwwer wéi eng Zort Code Dir schreift a wéi séier en am Duerchschnëtt am grousse Bild leeft.

Andrei: A wéi kënnt Dir esou e Volume am Kapp halen? Gëtt dat mat méi Erfahrung erreecht, oder? Wou kënnt esou Erfahrung hier?

Cliff: Gutt, ech hunn meng Erfahrung net am einfachsten. Ech hunn an der Assemblée zréck an den Deeg programméiert, wou Dir all eenzel Instruktioun verstinn konnt. Et kléngt domm, awer zënterhier ass den Z80 Instruktiounsset ëmmer a mengem Kapp bliwwen, a menger Erënnerung. Ech erënnere mech net un d'Nimm vun de Leit bannent enger Minutt nodeems ech geschwat hunn, awer ech erënnere mech un de Code dee viru 40 Joer geschriwwe gouf. Et ass witzeg, et gesäit aus wéi e Syndrom "idiote Wëssenschaftler".

Low-Level Optimisatiounstraining

Andrei: Gëtt et e méi einfache Wee fir eran ze kommen?

Cliff: Jo an nee. D'Hardware, déi mir all benotzen, huet mat der Zäit net sou vill geännert. Jiddereen benotzt x86, mat Ausnam vun Arm Smartphones. Wann Dir keng Aart Hardcore Embedding maacht, maacht Dir datselwecht. Okay, nächst. D'Instruktioune sinn och net zënter Jorhonnerte geännert. Dir musst goen an eppes an Assemblée schreiwen. Net vill, awer genuch fir ze verstoen. Dir laacht, awer ech schwätze ganz eescht. Dir musst d'Korrespondenz tëscht Sprooch an Hardware verstoen. Duerno musst Dir e bëssen schreiwen an e klenge Spillsaachkompiler fir e bësse Spillsaachsprooch maachen. Toy-like heescht datt et an enger vernünftlecher Zäit gemaach muss ginn. Et kann super einfach sinn, awer et muss Instruktioune generéieren. Den Akt fir eng Instruktioun ze generéieren hëlleft Iech de Käschtemodell fir d'Bréck tëscht dem héije Code deen jidderee schreift an dem Maschinncode deen op der Hardware leeft ze verstoen. Dës Korrespondenz gëtt an d'Gehir verbrannt wann de Compiler geschriwwe gëtt. Och den einfachsten Compiler. Duerno kënnt Dir op Java kucken an d'Tatsaach datt säi semantesche Chasm vill méi déif ass, an et ass vill méi schwéier Brécke doriwwer ze bauen. Op Java ass et vill méi schwéier ze verstoen ob eis Bréck gutt oder schlecht ausgefall ass, wat se auserneen fällt a wat net. Awer Dir braucht eng Aart Startpunkt wou Dir de Code kuckt a verstitt: "Jo, dëse Getter soll all Kéier inlined sinn." An da stellt sech eraus datt dat heiansdo geschitt, ausser d'Situatioun wann d'Methode ze grouss gëtt, an de JIT fänkt alles un ze inlinéieren. D'Leeschtung vun esou Plaze kann direkt virausgesot ginn. Normalerweis funktionnéieren Getters gutt, awer da kuckt Dir op grouss waarm Schleifen a mierkt datt et e puer Funktiounsruffe ronderëm schwiewen déi net wësse wat se maachen. Dëst ass de Problem mat der verbreeter Notzung vu Getter, de Grond firwat se net inlined sinn ass datt et net kloer ass ob se e Getter sinn. Wann Dir eng super kleng Code Basis hutt, kënnt Dir et einfach erënneren an dann soen: Dëst ass e Getter, an dëst ass e Setter. An enger grousser Code Basis lieft all Funktioun seng eege Geschicht, déi am Allgemengen net jiddereen bekannt ass. De Profiler seet datt mir 24% vun der Zäit op enger Loop verluer hunn a fir ze verstoen wat dës Loop mécht, musse mir all Funktioun dobannen kucken. Et ass onméiglech dëst ze verstoen ouni d'Funktioun ze studéieren, an dëst verlangsamt de Verständnisprozess eescht. Dofir benotzen ech keng Getters a Setzer, ech hunn en neien Niveau erreecht!
Wou de Käschtemodell ze kréien? Ee, Dir kënnt eppes liesen, natierlech ... Mee ech mengen de beschte Wee ass ze handelen. E klenge Compiler ze maachen ass de beschte Wee fir de Käschtemodell ze verstoen an an Ären eegene Kapp ze passen. E klenge Compiler dee gëeegent wier fir eng Mikrowelle ze programméieren ass eng Aufgab fir en Ufänger. Gutt, ech mengen, wann Dir scho Programméierungsfäegkeeten hutt, da sollt dat genuch sinn. All dës Saache wéi d'Parséiere vun engem String deen Dir als eng Aart algebraeschen Ausdrock hutt, Instruktioune fir mathematesch Operatiounen vun do aus an der korrekter Uerdnung extrahéieren, déi richteg Wäerter aus de Registere huelen - dat alles gëtt op eemol gemaach. A wärend Dir et maacht, gëtt et an Ärem Gehir geprägt. Ech mengen jidderee weess wat e Compiler mécht. An dëst wäert e Verständnis vum Käschtemodell ginn.

Praktesch Beispiller vun Leeschtung Verbesserung

Andrei: Op wat soss sollt Dir oppassen wann Dir un der Produktivitéit schafft?

Cliff: Datestrukturen. Iwwregens, jo, ech hunn dës Coursen laang net geléiert ... Rakéit Schoul. Et war Spaass, mee et verlaangt vill Effort, an ech hunn och e Liewen! OK. Also, an enger vun de groussen an interessanten Klassen, "Wou geet Är Leeschtung", hunn ech de Schüler e Beispill ginn: zwee an en halleft Gigabyte Fintech-Date goufen aus enger CSV-Datei gelies an dunn hu se missen d'Zuel vun de verkafe Produkter ausrechnen. . Regelméisseg Tick Maartdaten. UDP Pakete konvertéiert an Textformat zënter de 70er. Chicago Mercantile Exchange - all Zorte vu Saachen wéi Botter, Mais, Sojabohnen, Saachen wéi dat. Et war néideg dës Produkter ze zielen, d'Zuel vun den Transaktiounen, den Duerchschnëttsvolumen vun der Bewegung vu Fongen a Wueren, asw. Et ass zimmlech einfach Handelsmathematik: Fannt de Produktcode (dat ass 1-2 Zeechen an der Hash-Tabelle), kritt de Betrag, füügt et an ee vun den Handelssets, füügt Volumen, addéiere Wäert, an e puer aner Saachen. Ganz einfach Mathematik. D'Spillsaach Ëmsetzung war ganz einfach: alles ass an engem Fichier, ech liesen d'Datei a réckelen duerch, eenzel Rekorder op Java Strings opdeelen, no der néideger Saache sichen an no der Mathematik uewen beschriwwen derbäisetzen. An et Wierker op e puer niddereg Vitesse.

Mat dëser Approche ass et evident wat lass ass, a parallel Informatik hëlleft net, richteg? Et stellt sech eraus datt eng fënneffach Erhéijung vun der Leeschtung einfach erreecht ka ginn andeems Dir déi richteg Datestrukturen auswielt. An dëst iwwerrascht souguer erfuerene Programméierer! A mengem besonnesche Fall war den Trick datt Dir keng Erënnerungsallokatiounen an enger Hot Loop sollt maachen. Gutt, dëst ass net déi ganz Wourecht, awer am Allgemengen - Dir sollt net "eemol am X" Highlight wann X grouss genuch ass. Wann X zwee an en halleft Gigabyte ass, sollt Dir näischt "eemol pro Bréif", oder "eemol pro Zeil", oder "eemol pro Feld", eppes wéi dat zoudeelen. Dëst ass wou Zäit verbruecht gëtt. Wéi funktionéiert dat iwwerhaapt? Stellt Iech vir datt ech en Uruff maachen String.split() oder BufferedReader.readLine(). Readline mécht e String aus engem Set vu Bytes, déi iwwer de Reseau koumen, eemol fir all Linn, fir jiddereng vun den honnerte vu Millioune Linnen. Ech huelen dës Linn, analyséieren se a geheien se ewech. Firwat geheien ech et ewech - gutt, ech hunn et scho veraarbecht, dat ass alles. Also, fir all Byte gelies vun dësen 2.7G, ginn zwee Zeechen an der Zeil geschriwwe ginn, dat ass schonn 5.4G, an ech brauch se net fir näischt weider, sou datt se ewechgehäit ginn. Wann Dir kuckt op d'Erënnerung bandwidth, mir lued 2.7G datt duerch d'Erënnerung an Erënnerung Bus am Prozessor geet, an dann duebel sou vill op d'Linn geschéckt an Erënnerung leien, an all dat ass frayed wann all nei Linn geschaf. Awer ech muss et liesen, d'Hardware liest et, och wann alles méi spéit zerstéiert ass. An ech muss et opschreiwen well ech eng Linn erstallt hunn an d'Cache si voll - de Cache kann net 2.7G aménagéieren. Also, fir all Byte ech liesen, liesen ech zwee méi Bytes a schreiwen zwee méi Bytes, an um Enn hunn se e 4: 1 Verhältnis - an dësem Verhältnis verschwende mir Erënnerungsbandbreedung. An da stellt sech eraus, datt wann ech maachen String.split() - et ass net déi leschte Kéier, datt ech dat maachen, et kënnen nach 6-7 Felder dobannen sinn. Also de klassesche Code fir CSV ze liesen an dann d'Strings ze analyséieren resultéiert zu engem Memory Bandwidth Offall vu ronn 14:1 relativ zu deem wat Dir tatsächlech gär hätt. Wann Dir dës Auswiel ewechgehäit, kënnt Dir e fënneffache Geschwindegkeet kréien.

An et ass net sou schwéier. Wann Dir de Code aus dem richtege Wénkel kuckt, gëtt alles ganz einfach wann Dir de Problem realiséiert. Dir sollt net ophalen Erënnerung ganz ze verdeelen: deen eenzege Problem ass datt Dir eppes verdeelt an et stierft direkt, a laanscht de Wee verbrennt et eng wichteg Ressource, déi an dësem Fall Erënnerungsbandbreedung ass. An all dëst féiert zu enger Ofsenkung vun der Produktivitéit. Op x86 musst Dir normalerweis Prozessorzyklen aktiv verbrennen, awer hei hutt Dir all d'Erënnerung vill méi fréi verbrannt. D'Léisung ass d'Quantitéit vun der Entladung ze reduzéieren. 
Deen aneren Deel vum Problem ass, datt wann Dir de Profiler lafen wann d'Erënnerung Sträif leeft aus, Recht wann et geschitt, Dir gewaart normalerweis fir de Cache kommen zréck well et voller Gerempels ass, datt Dir just produzéiert, all déi Linnen. Dofir gëtt all Laascht oder Store Operatioun lues, well se zu Cache vermësst féieren - de ganze Cache ass lues ginn, waart op Dreck fir et ze verloossen. Dofir wäert de Profiler just waarm zoufälleg Kaméidi weisen, déi duerch d'ganz Loop geschmiert gëtt - et gëtt keng separat waarm Instruktioun oder Plaz am Code. Nëmmen Kaméidi. A wann Dir kuckt op d'GC Zyklen, si sinn all Young Generatioun a super séier - microseconds oder milliseconds maximal. No all, stierft all dës Erënnerung direkt. Dir verdeelt Milliarden Gigabytes, an hien schneit se, a schneit se, a schneit se erëm. All dëst geschitt ganz séier. Et stellt sech eraus, datt et bëlleg GC Zyklen sinn, waarm Kaméidi laanscht de ganzen Zyklus, mä mir wëllen eng 5x speedup ze kréien. Zu dësem Moment sollt eppes am Kapp zoumaachen a kléngen: "Firwat ass dat?!" Memory Sträif Iwwerfloss gëtt net am klassesche Debugger ugewisen; Dir musst den Hardware Performance Konter Debugger lafen an et selwer an direkt gesinn. Awer dëst kann net direkt vun dësen dräi Symptomer verdächtegt ginn. Dat drëtt Symptom ass wann Dir kuckt wat Dir Highlight, frot de Profiler, an hien äntwert: "Dir hutt eng Milliard Reihen gemaach, awer de GC huet gratis geschafft." Soubal dat passéiert, mierkt Dir datt Dir ze vill Objeten erstallt hutt an déi ganz Erënnerungsbunn verbrannt hutt. Et gëtt e Wee fir dëst erauszefannen, awer et ass net evident. 

De Problem ass an der Datestruktur: déi blo Struktur ënnersträicht alles wat geschitt ass, et ass ze grouss, et ass 2.7G op der Disk, also eng Kopie vun dëser Saach ze maachen ass ganz onerwënscht - Dir wëllt et direkt aus dem Netzwierk Byte Puffer lueden an d'Register, fir net fënnef Mol op d'Linn ze liesen-schreiwen. Leider gëtt Java Iech net esou eng Bibliothéik als Deel vun der JDK als Standard. Awer dëst ass trivial, richteg? Wesentlech sinn dëst 5-10 Zeilen Code déi benotzt gi fir Ären eegene gebufferten Stringloader ëmzesetzen, deen d'Behuele vun der Stringklass widderhëlt, wärend e Wrapper ronderëm den ënnerierdesche Byte-Puffer ass. Als Resultat stellt et sech eraus datt Dir bal wéi mat Strings schafft, awer tatsächlech réckelen d'Zeiler op de Puffer dohinner, an déi raw Bytes ginn net iwwerall kopéiert, an domat ginn déiselwecht Puffer ëmmer erëm benotzt, an de Betribssystem ass frou Iech selwer d'Saachen ze huelen, fir déi se entworf ass, wéi verstoppt Duebelbuffering vun dëse Byte-Puffer, an Dir schleift net méi duerch en endlosen Stroum vun onnéidege Donnéeën. Iwwregens, verstitt Dir, datt wann Dir mat GC schafft, garantéiert ass datt all Erënnerungsallokatioun net dem Prozessor no der leschter GC-Zyklus sichtbar ass? Dofir kann dat alles onméiglech am Cache sinn, an dann entsteet eng 100% garantéiert Miss. Wann Dir mat engem Zeiger schafft, op x86, e Register aus der Erënnerung ze subtrahéieren dauert 1-2 Auerzyklen, a soubal dat geschitt, bezuelt Dir, bezuelt, bezuelt, well d'Erënnerung alles ass NENG Cache - an dëst sinn d'Käschte vun der Erënnerungsallokatioun. Real Wäert.

An anere Wierder, Datestrukture sinn déi schwéierst Saach ze änneren. A wann Dir mierkt datt Dir déi falsch Datestruktur gewielt hutt, déi d'Leeschtung méi spéit ëmbréngt, gëtt et normalerweis vill Aarbecht ze maachen, awer wann Dir dat net maacht, wäert d'Saachen verschlechtert ginn. Als éischt musst Dir iwwer Datenstrukturen denken, dëst ass wichteg. D'Haaptkäschte fällt hei op fett Datenstrukturen, déi ufänken am Stil vun "Ech hunn d'Datestruktur X an d'Datestruktur Y kopéiert well ech d'Form vum Y besser gefällt." Awer d'Kopieoperatioun (wat bëlleg schéngt) verschwendt tatsächlech Erënnerungsbandbreedung an dat ass wou all verschwenden Ausféierungszäit begruewe gëtt. Wann ech e risege String vun JSON hunn an ech wëll et an e strukturéierten DOM Bam vun POJOs oder eppes ëmsetzen, wäert d'Operatioun fir dës String ze analyséieren an de POJO ze bauen, an duerno erëm op de POJO ze kommen, wäert zu onnéidege Käschte féieren - et ass net bëlleg. Ausser wann Dir lafe ronderëm POJOs vill méi oft wéi Dir ronderëm eng String lafen. Offhand, Dir kënnt amplaz probéieren d'String ze entschlësselen an nëmmen extrahéieren wat Dir braucht vun do, ouni et zu engem POJO ze maachen. Wann all dat geschitt op engem Wee aus deem maximal Leeschtung néideg ass, keng POJOs fir Iech, Dir musst iergendwéi an der Linn direkt.

Firwat Är eege Programméiersprooch erstellen

Andrei: Dir sot, fir de Käschtemodell ze verstoen, musst Dir Är eege kleng Sprooch schreiwen...

Cliff: Keng Sprooch, mee e Compiler. Eng Sprooch an e Compiler sinn zwou verschidde Saachen. De wichtegsten Ënnerscheed ass an Ärem Kapp. 

Andrei: Iwwregens, souwäit ech weess, experimentéiert Dir mat Ären eegene Sproochen. Fir wat?

Cliff: Well ech kann! Ech sinn semi-pensionéiert, also ass dëst mäin Hobby. Ech hunn mäi ganzt Liewen d'Sprooche vun anere Leit ëmgesat. Ech hunn och vill u mengem Kodéierungsstil geschafft. An och well ech Problemer an anere Sproochen gesinn. Ech gesinn datt et besser Weeër gi fir vertraut Saachen ze maachen. An ech géif se benotzen. Ech si just midd fir Problemer a mir selwer ze gesinn, am Java, am Python, an all aner Sprooch. Ech schreiwen elo a React Native, JavaScript an Elm als Hobby deen net ëm d'Pensioun geet, mee iwwer aktiv Aarbecht. Ech schreiwen och am Python an, héchstwahrscheinlech, wäerte weider un Maschinnléiere fir Java Backends schaffen. Et gi vill populär Sproochen a si hunn all interessant Features. Jiddereen ass gutt op seng Manéier an Dir kënnt probéieren all dës Funktiounen zesummen ze bréngen. Also, ech studéieren Saachen déi mech interesséieren, d'Behuele vun der Sprooch, probéieren mat raisonnabel Semantik ze kommen. A bis elo sinn ech gelongen! Am Moment kämpfen ech mat Erënnerungssemantik, well ech wëll et wéi an C an Java hunn, an e staarken Erënnerungsmodell an Erënnerungssemantik fir Lasten a Geschäfter kréien. Zur selwechter Zäit hunn automatesch Typinferenz wéi an Haskell. Hei probéieren ech Haskell-ähnlechen Typinferenz mat Erënnerungsaarbecht a béid C an Java ze vermëschen. Dëst ass wat ech fir déi lescht 2-3 Méint gemaach hunn, zum Beispill.

Andrei: Wann Dir eng Sprooch baut déi besser Aspekter vun anere Sproochen hëlt, mengt Dir datt een de Géigendeel wäert maachen: Är Iddien huelen a se benotzen?

Cliff: Genee esou erschéngen nei Sprooche! Firwat ass Java ähnlech wéi C? Well C hat eng gutt Syntax datt jiddereen verstanen an Java war vun dëser Syntax inspiréiert, dobäi Typ Sécherheet, Array Grenzen kontrolléieren, GC, a si verbessert och e puer Saachen aus C. Si dobäi hir eege. Awer si goufen zimlech vill inspiréiert, richteg? Jidderee steet op de Schëllere vun de Risen, déi virun Iech koumen - dat ass wéi Fortschrëtter gemaach ginn.

Andrei: Wéi ech et verstinn, Är Sprooch wäert Erënnerung sécher. Hutt Dir geduecht eppes wéi e Prêt Checker aus Rust ëmzesetzen? Hutt Dir him gekuckt, wat haalt Dir vun him?

Cliff: Ee, ech schreiwen C fir Alter, mat all dëser malloc a gratis, a manuell d'Liewensdauer verwalten. Dir wësst, 90-95% vun manuell kontrolléiert Liewen Zäit huet déi selwecht Struktur. An et ass ganz, ganz schmerzhaf et manuell ze maachen. Ech hätt gär datt de Compiler Iech einfach soe wat do lass ass a wat Dir mat Ären Handlungen erreecht hutt. Fir e puer Saachen, léinen Checker mécht dëst aus der Këscht. An et soll automatesch Informatioun weisen, alles verstoen, a mech net emol belaaschten, dëst Verständnis ze presentéieren. Et muss op d'mannst lokal Fluchtanalyse maachen, an nëmmen wann et feelt, da muss et Typ Annotatiounen derbäi ginn, déi d'Liewensdauer beschreiwen - an esou e Schema ass vill méi komplex wéi e Prêt Checker, oder tatsächlech all existent Memory Checker. De Choix tëscht "Alles ass gutt" an "Ech verstinn näischt" - nee, et muss eppes Besseres ginn. 
Also, als een dee vill Code am C geschriwwen huet, denken ech datt Ënnerstëtzung fir automatesch Liewensdauer Kontroll déi wichtegst Saach ass. Ech sinn och midd wéi vill Java Erënnerung benotzt an d'Haaptrei ass de GC. Wann Dir Erënnerung op Java zougewisen hutt, kritt Dir d'Erënnerung net zréck, déi am leschte GC-Zyklus lokal war. Dëst ass net de Fall a Sprooche mat méi präzis Erënnerungsmanagement. Wann Dir malloc nennt, kritt Dir direkt d'Erënnerung, déi normalerweis just benotzt gouf. Normalerweis maacht Dir e puer temporär Saachen mat Erënnerung a gitt se direkt zréck. An et geet direkt zréck an de Malloc Pool, an den nächsten Malloc Zyklus zitt et erëm eraus. Dofir gëtt déi aktuell Erënnerungsverbrauch op de Set vu liewegen Objeten zu enger bestëmmter Zäit reduzéiert, plus Leckage. A wann alles net op eng komplett onschëlleg Manéier leeft, schléit de gréissten Deel vun der Erënnerung an de Cache an de Prozessor, an et funktionnéiert séier. Mee verlaangt vill manuell Erënnerung Gestioun mat malloc a fräi genannt an der rietser Uerdnung, op déi richteg Plaz. Rust kann dëst richteg eleng handhaben, a ginn a ville Fäll nach besser Leeschtung, well d'Erënnerungsverbrauch op just déi aktuell Berechnung schmuel ass - am Géigesaz zu engem waarden op den nächsten GC-Zyklus fir Erënnerung ze befreien. Als Resultat hu mir e ganz interessante Wee fir d'Leeschtung ze verbesseren. An zimmlech mächteg - ech mengen, ech hunn esou Saachen gemaach beim Veraarbechtung vun Daten fir Fintech, an dëst huet mir erlaabt eng Geschwindegkeet vu ronn fënnef Mol ze kréien. Dat ass e zimlech grousse Boost, besonnesch an enger Welt wou d'Prozessoren net méi séier ginn a mir waarden nach ëmmer op Verbesserungen.

Leeschtung Ingenieur Carrière

Andrei: Ech wéilt och iwwer d'Carrièren iwwerhaapt froen. Dir sidd op Prominenz mat Ärer JIT Aarbecht am HotSpot eropgaang an ass dunn op Azul geplënnert, wat och eng JVM Firma ass. Awer mir hu scho méi un Hardware wéi Software geschafft. An dunn hu se op eemol op Big Data a Machine Learning gewiesselt, an dann op Bedruchserkennung. Wéi ass dat geschitt? Dëst si ganz ënnerschiddlech Entwécklungsberäicher.

Cliff: Ech programméiere scho laang an hunn et fäerdeg bruecht vill verschidde Klassen ze huelen. A wann d'Leit soen: "Oh, du bass deen deen JIT fir Java gemaach huet!", ass et ëmmer witzeg. Awer virdru hunn ech un engem Klon vu PostScript geschafft - d'Sprooch déi Apple eemol fir seng Laserdrucker benotzt huet. A virdrun hunn ech eng Implementatioun vun der Forth Sprooch gemaach. Ech mengen dat gemeinsamt Thema fir mech ass Toolentwécklung. Mäi ganzt Liewen hunn ech Tools gemaach mat deenen aner Leit hir cool Programmer schreiwen. Awer ech war och an der Entwécklung vu Betribssystemer, Chauffeuren, Kernel-Niveau Debugger, Sprooche fir OS Entwécklung involvéiert, déi trivial ugefaang hunn, awer mat der Zäit ëmmer méi komplex ginn. Awer den Haaptthema ass nach ëmmer d'Entwécklung vun Tools. E groussen Deel vu mengem Liewen ass tëscht Azul a Sonn gaangen, an et war iwwer Java. Awer wéi ech an Big Data a Machine Learning ukomm sinn, hunn ech mäi schéine Hutt zréck gesat a gesot: "Oh, elo hu mir en net-triviale Problem, an et gi vill interessant Saachen déi lass sinn a Leit maachen Saachen." Dëst ass e super Entwécklungswee fir ze huelen.

Jo, ech hu wierklech gär verdeelt Informatik. Meng éischt Aarbecht war als Student am C, op engem Reklammprojet. Dëst gouf Rechenzäit op Zilog Z80 Chips verdeelt déi Daten fir Analog OCR gesammelt hunn, produzéiert vun engem richtegen Analog Analyser. Et war e coolt a komplett verréckt Thema. Mä et goufe Problemer, een Deel war net richteg erkannt, also musst Dir eng Foto eraushuelen an enger Persoun weisen, déi scho mat hiren Ae liesen a mellen, wat et seet, an dofir goufen et Aarbechtsplazen mat Daten, an dës Aarbechten hir eege Sprooch haten. Et war e Backend deen all dëst veraarbecht huet - Z80s Lafen parallel mat vt100 Statiounen Lafen - eng pro Persoun, an et war e parallel programméiere Modell op der Z80. Puer gemeinsam Stéck Erënnerung vun all Z80s bannent engem Stär Configuratioun gedeelt; D'Backplane war och gedeelt, an d'Halschent vum RAM gouf am Netz gedeelt, an eng aner Halschent war privat oder ass op eppes anescht gaangen. Eng sënnvoll komplex parallel verdeelt System mat gedeelt ... semi-gedeelt Erënnerung. Wéini war dëst ... Ech ka mech net mol erënneren, iergendwou an der Mëtt vun den 80er. Ganz laang virun. 
Jo, loosst eis dovun ausgoen, datt 30 Joer viru laanger Zäit sinn.Problemer am Zesummenhang mam distributed computing existéieren scho laang, d'Leit ware scho laang am Krich mat Beowulf-cluster. Esou Cluster kucken aus wéi ... Zum Beispill: et gëtt Ethernet an Äre schnelle x86 ass mat dësem Ethernet verbonnen, an elo wëllt Dir gefälschte gemeinsame Gedächtnis kréien, well keen deemools verdeelt Rechenkodéierung konnt maachen, et war ze schwéier an dofir do war gefälschte gemeinsame Erënnerung mat Schutz Erënnerung Säiten op x86, a wann Dir op dës Säit geschriwwen, dann hu mir aner Prozessor gesot, datt wa se Zougang zu der selwechter gemeinsam Erënnerung, et muss vun Iech gelueden ginn, an domat eppes wéi e Protokoll fir Ënnerstëtzung Cache Kohärenz erschéngt a Software fir dës. Interessant Konzept. De richtege Problem war natierlech eppes anescht. All dëst huet geschafft, awer Dir krut séier Leeschtungsproblemer, well keen huet d'Leeschtungsmodeller op engem gudden Niveau verstanen - wéi eng Erënnerungsaccessmuster do waren, wéi Dir sécher sidd datt d'Knueten net endlos géigesäiteg pingelen, asw.

Wat ech am H2O ukomm sinn ass datt et d'Entwéckler selwer sinn déi verantwortlech sinn fir ze bestëmmen wou Parallelismus verstoppt ass a wou et net ass. Ech sinn mat engem Kodéierungsmodell komm, deen High-Performance-Code einfach an einfach schreift. Awer lues lafende Code schreiwen ass schwéier, et wäert schlecht ausgesinn. Dir musst eescht probéieren luesen Code ze schreiwen, Dir musst net-Standard Methoden benotzen. De Bremscode ass op den éischte Bléck ze gesinn. Als Resultat schreift Dir normalerweis Code dee séier leeft, awer Dir musst erausfannen wat Dir maache musst am Fall vun der gemeinsamer Erënnerung. All dëst ass u grouss Arrays gebonnen an d'Verhalen do ass ähnlech wéi net-flüchteg grouss Arrays parallel Java. Ech mengen, stellt Iech vir, datt zwee Threads op eng parallel Array schreiwen, ee vun hinnen gewënnt, an deen aneren deementspriechend verléiert, an Dir wësst net wéi eng ass. Wann se net onbestänneg sinn, da kann d'Bestellung sinn wat Dir wëllt - an dëst funktionnéiert wierklech gutt. D'Leit këmmeren sech wierklech ëm d'Uerdnung vun den Operatiounen, si setzen liichtflüchteg op de richtege Plazen, a si erwaarden Erënnerungsrelaterte Leeschtungsproblemer op de richtege Plazen. Soss schreiwen se einfach Code a Form vu Schleifen vun 1 bis N, wou N e puer Billiounen ass, an der Hoffnung datt all komplex Fäll automatesch parallel ginn - an et funktionnéiert net do. Awer am H2O ass dëst weder Java nach Scala; Dir kënnt et als "Java minus minus" betruechten wann Dir wëllt. Dëst ass e ganz kloere Programméierungsstil an ass ähnlech wéi einfachen C oder Java Code mat Schleifen an Arrays ze schreiwen. Awer zur selwechter Zäit kann d'Erënnerung an Terabytes veraarbecht ginn. Ech benotzen nach ëmmer H2O. Ech benotzen et vun Zäit zu Zäit a verschiddene Projeten - an et ass ëmmer nach déi séierst Saach, Dosende vu Mol méi séier wéi seng Konkurrenten. Wann Dir Big Data mat columnar Daten maacht, ass et ganz schwéier H2O ze schloen.

Technesch Erausfuerderungen

Andrei: Wat war Är gréissten Erausfuerderung an Ärer ganzer Carrière?

Cliff: Diskutéiere mer den techneschen oder net-techneschen Deel vun der Fro? Ech géif soen déi gréissten Erausfuerderunge sinn net technesch. 
Wéi fir technesch Erausfuerderungen. Ech hunn se einfach besiegt. Ech weess net emol wat dee gréisste war, awer et waren e puer zimlech interessant déi zimmlech vill Zäit gedauert hunn, mentale Kampf. Wann ech gaangen Sonn, Ech war sécher op dass ech eng séier Compiler maachen géif, an eng Rëtsch vun Senioren sot zu Äntwert, datt ech ni gelengt. Awer ech hunn dëse Wee gefollegt, e Compiler erof op de Registerallocator geschriwwen, an et war zimlech séier. Et war sou séier wéi modern C1, awer den Allocator war deemools vill méi lues, an am Réckbléck war et e groussen Datestrukturproblem. Ech brauch et fir e grapheschen Registerallocator ze schreiwen an ech hunn den Dilemma tëscht Code Expressivitéit a Geschwindegkeet net verstanen, wat an där Ära existéiert a ganz wichteg war. Et huet sech erausgestallt datt d'Datestruktur normalerweis d'Cachegréisst op x86s vun där Zäit iwwerschreift, an dofir, wann ech ufanks ugeholl hunn datt de Registerallocator 5-10 Prozent vun der Gesamt Jitterzäit auswierkt, dann huet et a Wierklechkeet erausgestallt. 50 Prozent.

Wéi d'Zäit weidergaang ass, gouf de Compiler méi propper an effizient, huet a méi Fäll opgehalen schreckleche Code ze generéieren, an d'Performance huet ëmmer méi ugefaang wéi dat wat e C Compiler produzéiert. . Wann Dir Code wéi C schreift, kritt Dir Leeschtung wéi C a méi Fäll. A wat Dir méi wäit gaang sidd, wat Dir méi dacks Code krut deen asymptotesch mam Niveau C zesummegefall ass, huet de Registerallocator ugefaang wéi eppes komplett ausgesinn ... egal ob Äre Code séier oder lues leeft. Ech hunn weider um Allocator geschafft fir et besser Auswiel ze maachen. Hie gouf ëmmer méi lues, awer hien huet ëmmer besser Leeschtung gemaach an de Fäll wou keen anere sech ëmgoe konnt. Ech konnt an e Registerallocator tauchen, e Mount Aarbecht do begruewen, an op eemol géif de ganze Code 5% méi séier ausféieren. Dëst ass ëmmer erëm geschitt an de Registerverdeeler gouf eppes vun engem Konschtwierk - jiddereen huet et gär oder haassen, a Leit vun der Akademie hunn d'Fro gestallt iwwer d'Thema "Firwat gëtt alles esou gemaach", firwat net Linn Scannen, a wat ass den Ënnerscheed. D'Äntwert ass nach ëmmer déiselwecht: en Allocator baséiert op Grafikmolerei plus ganz virsiichteg Aarbecht mam Puffercode ass gläich wéi eng Waff vun der Victoire, déi bescht Kombinatioun déi kee besiege kann. An dëst ass eng zimlech net offensichtlech Saach. Alles anescht wat de Compiler do mécht sinn zimlech gutt studéiert Saachen, obwuel se och op den Niveau vun der Konscht bruecht goufen. Ech hunn ëmmer Saache gemaach, déi de Compiler zu engem Konschtwierk maachen sollten. Awer näischt vun dësem war eppes aussergewéinleches - ausser fir de Registeralocator. Den Trick ass virsiichteg ze sinn méi kurz trieden ënner Belaaschtung an, wann dat geschitt (Ech kann méi am Detail erklären wann interesséiert), dat heescht, datt Dir méi aggressiv inline kann, ouni de Risiko vun engem falen iwwer e Knik an der Leeschtung Stonneplang. An deenen Deeg goufen et eng Rëtsch voll-Skala Compiler, mat Boubles a Pfeifen hänke gelooss, déi Registeralocateuren haten, awer keen anere konnt et maachen.

De Problem ass datt wann Dir Methoden bäidréit, déi dem Inlining ënnerleien, d'Inliningberäich erhéijen an erhéijen, de Set vu benotzte Wäerter iwwerschreift direkt d'Zuel vun de Registere, an Dir musst se ofschneiden. Der kritescher Niveau kënnt normalerweis wann allocator opginn, an engem gudde Kandidat fir e Spill wäert aner, Dir wäert e puer allgemeng wëll Saachen verkafen. De Wäert vun der Inlining hei ass datt Dir en Deel vun der Overhead verléiert, Overhead fir ze ruffen an ze spueren, Dir kënnt d'Wäerter dobannen gesinn a kënnen se weider optimiséieren. D'Käschte vun der Inlining sinn datt eng grouss Zuel vu Live Wäerter geformt ginn, a wann Äre Registerallocator méi wéi néideg verbrennt, verléiert Dir direkt. Dofir hunn déi meescht Allocateuren e Problem: wann d'Inlining eng gewësse Linn iwwerschreift, fänkt alles op der Welt erof ze schneiden an d'Produktivitéit kann an d'Toilette gespullt ginn. Déi, déi de Compiler implementéieren, addéieren e puer Heuristiken: zum Beispill fir d'Inlining ze stoppen, mat enger genuch grousser Gréisst unzefänken, well d'Allokatioune alles ruinéieren. Dëst ass wéi e Knik an der Leeschtungsgrafik geformt gëtt - Dir inline, inline, d'Performance wiisst lues - an dann boomt! - et fällt wéi e schnelle Jack erof, well Dir zevill gezeechent hutt. Dëst ass wéi alles virum Advent vu Java geschafft huet. Java erfuerdert vill méi Inlining, also hunn ech mäi Allocator vill méi aggressiv ze maachen, sou datt et ausgeglach anstatt Crashen, a wann Dir zevill inlinet, fänkt et un ze spillen, awer dann kënnt de Moment "net méi spilling". Dëst ass eng interessant Observatioun an et ass just aus néierens bei mir komm, net offensichtlech, awer et huet sech gutt bezuelt. Ech hunn aggressiv Inlining opgeholl an et huet mech op Plazen geholl wou Java an C Leeschtung niewentenee schaffen. Si si wierklech no - ech ka Java Code schreiwen dee wesentlech méi séier ass wéi C Code a sou Saachen, awer am Duerchschnëtt, am grousse Bild vun de Saachen, si se ongeféier vergläichbar. Ech mengen en Deel vun dësem Verdéngschter ass de Registeralocator, deen et erlaabt mech sou domm wéi méiglech ze inline. Ech inline just alles wat ech gesinn. D'Fro hei ass ob den Allocator gutt funktionnéiert, ob d'Resultat intelligent funktionnéiert Code ass. Dëst war eng grouss Erausfuerderung: dëst alles ze verstoen an ze maachen.

E bëssen iwwer Registerallokatioun a Multi-Cores

Владимир: Problemer wéi Registerallokatioun schéngen wéi eng Aart éiwegt, endlos Thema. Ech froe mech ob et jeemools eng Iddi gouf déi villverspriechend ausgesäit an dann an der Praxis gescheitert ass?

Cliff: Bestëmmt! Registerallokatioun ass e Gebitt an deem Dir probéiert e puer Heuristiken ze fannen fir en NP-komplett Problem ze léisen. An Dir kënnt ni eng perfekt Léisung erreechen, richteg? Dëst ass einfach onméiglech. Kuckt, Ahead of Time Compilatioun - et funktionnéiert och schlecht. D'Gespréich hei geet iwwer e puer duerchschnëttlech Fäll. Iwwer typesch Leeschtung, also kënnt Dir eppes moossen, wat Dir mengt, ass gutt typesch Leeschtung - schliisslech schafft Dir fir et ze verbesseren! Registerallokatioun ass en Thema alles iwwer Leeschtung. Wann Dir den éischte Prototyp hutt, funktionnéiert et a molen wat néideg ass, fänkt d'Leeschtungsaarbecht un. Dir musst léieren gutt ze moossen. Firwat ass et wichteg? Wann Dir kloer Donnéeën hutt, kënnt Dir verschidde Beräicher kucken a kucken: jo, et huet hei gehollef, awer dat ass wou alles gebrach ass! E puer gutt Iddien kommen op, Dir setzt nei Heuristiken derbäi an op eemol fänkt alles an der Moyenne e bësse besser ze schaffen. Oder et fänkt net un. Ech hat eng Rëtsch Fäll wou mir fir déi fënnef Prozent Leeschtung gekämpft hunn, déi eis Entwécklung vum fréiere Allocator differenzéiert hunn. An all Kéier gesäit et esou aus: iergendwou gewënnt Dir, iergendwou verléiert Dir. Wann Dir gutt Performance Analyse Tools hutt, kënnt Dir d'Verléierer Iddien fannen a verstoen firwat se versoen. Vläicht ass et derwäert alles ze loossen wéi et ass, oder vläicht eng méi sérieux Approche fir d'Feintuning ze huelen, oder erausgoen an eppes anescht ze fixéieren. Et ass eng ganz Rëtsch Saachen! Ech hunn dëse coolen Hack gemaach, awer ech brauch och dësen, an dësen, an dësen - an hir total Kombinatioun gëtt e puer Verbesserungen. An Eenzelpersounen kënnen versoen. Dëst ass d'Natur vun der Leeschtungsaarbecht op NP-komplett Probleemer.

Владимир: Et huet een d'Gefill, datt Saache wéi Molerei bei Allocateuren e Problem sinn, dee scho geléist gouf. Gutt, et ass fir Iech entscheet, beurteelt no wat Dir seet, also ass et och derwäert et dann ...

Cliff: Et gëtt net esou geléist. Et ass Dir, deen et an "geléist" maache musst. Et gi schwiereg Problemer a si musse geléist ginn. Wann dëst gemaach ass, ass et Zäit un der Produktivitéit ze schaffen. Dir musst dës Aarbecht deementspriechend unzegoen - Benchmarks maachen, Metriken sammelen, Situatiounen erklären wann, wann Dir op eng fréier Versioun zréckkoum, Ären alen Hack erëm ugefaang huet ze schaffen (oder vice versa, gestoppt). A gitt net op bis Dir eppes erreecht hutt. Wéi ech scho gesot hunn, wann et cool Iddien sinn, déi net geschafft hunn, awer am Beräich vun der Verdeelung vun den Ideeregisteren ass et ongeféier endlos. Dir kënnt zum Beispill wëssenschaftlech Publikatiounen liesen. Och wann elo dëst Gebitt vill méi lues ugefaang huet a méi kloer ass wéi a senger Jugend. Wéi och ëmmer, et sinn eng Onmass Leit déi an dësem Beräich schaffen an all hir Iddien sinn derwäert ze probéieren, se waarden all an de Flilleken. An Dir kënnt net soen wéi gutt si sinn ausser Dir probéiert se. Wéi gutt intégréieren se mat alles anescht an Ärem Allocator, well en Allocator vill Saache mécht, an e puer Iddien an Ärem spezifesche Allocator funktionnéieren net, awer an engem aneren Allocator si se einfach. Den Haapt Wee fir den Allocator ze gewannen ass déi lues Saachen ausserhalb vum Haaptwee ze zéien an ze zwéngen laanscht d'Grenze vun de luesen Weeër ze trennen. Also wann Dir wëllt e GC lafen, huelt de luesen Wee, deoptimiséiert, geheien eng Ausnam, all déi Saachen - Dir wësst datt dës Saache relativ seelen sinn. A si si wierklech rar, hunn ech gepréift. Dir maacht extra Aarbecht an et läscht vill vun de Restriktiounen op dëse luesen Weeër, awer et ass net wierklech wichteg well se lues sinn a selten gereest. Zum Beispill, en Nullpointer - et geschitt ni, richteg? Dir musst verschidde Weeër fir verschidde Saachen hunn, awer si sollten net mat der Haaptstéierung stéieren. 

Владимир: Wat mengt Dir iwwer Multi-Cores, wann et Dausende vu Käre gläichzäiteg sinn? Ass dëst eng nëtzlech Saach?

Cliff: Den Erfolleg vun der GPU weist datt et ganz nëtzlech ass!

Владимир: Si sinn zimlech spezialiséiert. Wat iwwer allgemeng Zweck Prozessoren?

Cliff: Ma, dat war dem Azul säi Geschäftsmodell. D'Äntwert koum zréck an enger Ära wou d'Leit wierklech prévisibel Leeschtung gär hunn. Et war schwéier deemools parallel Code ze schreiwen. Den H2O Kodéierungsmodell ass héich skalierbar, awer et ass keen allgemengen Zweck Modell. Vläicht e bësse méi allgemeng wéi wann Dir eng GPU benotzt. Schwätze mir iwwer d'Komplexitéit fir esou eppes z'entwéckelen oder d'Komplexitéit vum Gebrauch? Zum Beispill, Azul huet mir eng interessant Lektioun geléiert, eng éischter net offensichtlech: kleng Cache sinn normal. 

Déi gréissten Erausfuerderung am Liewen

Владимир: Wat iwwer net-technesch Erausfuerderungen?

Cliff: Déi gréissten Erausfuerderung war net ... léif a léif mat de Leit ze sinn. An als Resultat hunn ech mech ëmmer an extrem Konfliktsituatiounen fonnt. Déi wou ech wousst datt d'Saache falsch gaang sinn, awer net wousst wéi ech mat deene Probleemer virukommen a konnten se net handhaben. Vill laangfristeg Problemer, déi joerzéngtelaang daueren, sinn op dës Manéier entstanen. D'Tatsaach datt Java C1 an C2 Compilers huet ass eng direkt Konsequenz dovun. D'Tatsaach datt et keng Multi-Level Compilatioun am Java fir zéng Joer hannereneen gouf ass och eng direkt Konsequenz. Et ass selbstverständlech datt mir esou e System gebraucht hunn, awer et ass net kloer firwat et net existéiert. Ech hat Problemer mat engem Ingenieur ... oder enger Grupp vun Ingenieuren. Eemol, wéi ech ugefaang hunn bei Sun ze schaffen, war ech ... Okay, net nëmmen dann, ech hunn allgemeng ëmmer meng eegen Meenung iwwer alles. An ech hu geduecht datt et wouer wier datt Dir dës Wourecht vun Iech just kéint huelen an et op Kapp soen. Besonnesch well ech meeschtens schockéierend Recht hat. A wann Dir dës Approche net gär hutt ... besonnesch wann Dir selbstverständlech falsch sidd a Blödsinn maacht ... Am Allgemengen kënnen wéineg Leit dës Form vu Kommunikatioun toleréieren. Obwuel e puer kéint, wéi ech. Ech hu mäi ganzt Liewen op meritokratesch Prinzipien opgebaut. Wann Dir mir eppes falsch weist, da dréien ech mech direkt ëm a soen: Dir sot Blödsinn. Zur selwechter Zäit entschëllegen ech mech natierlech an all dat, ech wäert d'Verdéngschter notéieren, wann iwwerhaapt, an aner korrekt Handlungen huelen. Op der anerer Säit hunn ech schockéiert Recht iwwer e schockéierend grousse Prozentsaz vun der Gesamtzäit. An et funktionnéiert net ganz gutt a Relatioune mat Leit. Ech probéieren net léif ze sinn, awer ech stellen d'Fro riicht. "Dëst wäert ni schaffen, well een, zwee an dräi." A si ware wéi: "Oh!" Et waren aner Konsequenzen, déi wahrscheinlech besser ze ignoréieren waren: zum Beispill déi, déi zu enger Scheedung vu menger Fra an zéng Joer Depressioun duerno gefouert hunn.

Challenge ass e Kampf mat Leit, mat hirer Perceptioun vu wat Dir maache kënnt oder net, wat wichteg ass a wat net. Et ware vill Erausfuerderungen iwwer Kodéierungsstil. Ech schreiwen nach ëmmer vill Code, an déi Deeg hunn ech souguer misse luesen, well ech ze vill parallel Aufgaben gemaach hunn a schlecht gemaach hunn, amplaz op eng ze fokusséieren. Wann ech zréckkucken, hunn ech d'Halschent vum Code fir de Java JIT Kommando geschriwwen, de C2 Kommando. Den nächste schnellsten Coder huet hallef sou lues geschriwwen, déi nächst hallef sou lues, an et war en exponentielle Réckgang. Déi siwent Persoun an dëser Rei war ganz, ganz lues - dat geschitt ëmmer! Ech beréiert vill Code. Ech hunn ugekuckt wien wat geschriwwen huet, ouni Ausnam hunn ech op hire Code gekuckt, jidderee vun hinnen iwwerpréift, an ëmmer nach méi selwer geschriwwen wéi jidderee vun hinnen. Dës Approche funktionnéiert net ganz gutt mat Leit. E puer Leit hunn dat net gär. A wa se et net packen, fänken all méiglech Reklamatiounen un. Zum Beispill krut ech eng Kéier gesot fir opzehalen ze codéieren well ech ze vill Code schreiwen an et d'Team a Gefor bruecht huet, an et huet mir alles wéi e Witz geklongen: Kärel, wann de Rescht vun der Equipe verschwënnt an ech weider Code schreiwen, du wäert nëmmen hallef Équipen verléieren. Op der anerer Säit, wann ech weider Code schreiwen an Dir verléiert d'Halschent vum Team, da kléngt dat wéi eng ganz schlecht Gestioun. Ech hunn ni wierklech doriwwer geduecht, ni doriwwer geschwat, mee et war nach iergendwou a mengem Kapp. De Gedanke war am Réck vu mengem Kapp gedréint: "Mass du dech all Geck?" Also, de gréisste Problem war mech a meng Relatioune mat Leit. Elo verstinn ech mech vill besser, ech war eng Teamleader fir Programméierer fir eng laang Zäit, an elo soen ech direkt de Leit: Dir wësst, ech sinn wien ech sinn, an Dir musst mat mir ëmgoen - ass et an der Rei wann ech stinn hei? A wéi se ugefaang hunn domat ze beschäftegen, huet alles geschafft. Tatsächlech sinn ech weder schlecht nach gutt, ech hu keng schlecht Virsätz oder egoistesch Striewe, et ass just meng Essenz, an ech muss iergendwéi domat liewen.

Andrei: Just viru kuerzem huet jiddereen ugefaang iwwer Selbstbewosstsinn fir Introverten ze schwätzen, a mëll Fäegkeeten am Allgemengen. Wat kënnt Dir iwwer dëst soen?

Cliff: Jo, dat war den Abléck an d'Lektioun, déi ech aus menger Scheedung vu menger Fra geléiert hunn. Wat ech aus der Scheedung geléiert hunn war mech selwer ze verstoen. Dëst ass wéi ech ugefaang hunn aner Leit ze verstoen. Verstinn wéi dës Interaktioun funktionnéiert. Dëst huet zu Entdeckungen een nom aneren gefouert. Et war e Bewosstsinn vu wien ech sinn a wat ech vertrieden. Wat maachen ech: entweder ech si mat der Aufgab beschäftegt, oder ech vermeiden Konflikt, oder soss eppes - an dësen Niveau vun der Selbstbewosstsinn hëlleft wierklech mech selwer a Kontroll ze halen. Duerno geet alles vill méi einfach. Eng Saach déi ech net nëmmen a mir selwer entdeckt hunn, awer och an anere Programméierer ass d'Onméiglechkeet Gedanken ze verbaliséieren wann Dir ënner emotionalem Stress sidd. Zum Beispill, Dir sëtzt do codéieren, an engem Zoustand vun Flux, an dann kommen se bei Iech lafen a fänken an Hysterie ze kräischen, datt eppes gebrach ass an elo extrem Moossname géint Iech getraff ginn. An Dir kënnt kee Wuert soen well Dir an engem Zoustand vun emotionalen Stress bass. Dat erfuerdert Wëssen erlaabt Iech op dëse Moment ze preparéieren, ze iwwerliewen an op e Réckzuchsplang weiderzemaachen, duerno kënnt Dir eppes maachen. Also jo, wann Dir ufänkt ze realiséieren wéi et alles funktionnéiert, ass et e risegt Liewensverännerend Event. 
Ech selwer konnt net déi richteg Wierder fannen, awer ech erënnere mech un d'Sequenz vun den Aktiounen. De Punkt ass datt dës Reaktioun sou vill kierperlech ass wéi se verbal ass, an Dir braucht Plaz. Esou Raum, am Zen Sënn. Dat ass genee wat muss erkläert ginn, an dann direkt op der Säit - reng kierperlech Schrëtt ewech. Wann ech verbal roueg bleiwen, kann ech d'Situatioun emotional veraarbecht. Wéi den Adrenalin Äert Gehir erreecht, dech an de Kampf- oder Fluchmodus wiesselt, kënnt Dir näischt méi soen, nee - elo sidd Dir en Idiot, e Schlagingenieur, net kapabel fir eng anstänneg Äntwert oder souguer den Attack ze stoppen, an den Ugräifer ass fräi ëmmer erëm ze attackéieren. Dir musst fir d'éischt erëm selwer ginn, d'Kontroll erëm kréien, aus dem "Kampf oder Fluch" Modus erauskommen.

An dofir brauche mir verbale Raum. Just fräi Plaz. Wann Dir iwwerhaapt eppes seet, da kënnt Dir genau dat soen, a gitt da wierklech "Plaz" fir Iech selwer: gitt e Spadséiergank am Park, gespaart Iech an der Dusch - et ass egal. Den Haapt Saach ass temporär aus dëser Situatioun ze trennen. Soubal Dir op d'mannst e puer Sekonnen ausschalt, kënnt d'Kontroll zréck, Dir fänkt nüchtern ze denken. "Okay, ech sinn net eng Zort Idiot, ech maachen keng domm Saachen, ech sinn eng zimlech nëtzlech Persoun." Wann Dir Iech selwer iwwerzeege konnt, ass et Zäit fir op déi nächst Etapp ze goen: ze verstoen wat geschitt ass. Dir sidd ugegraff ginn, d'Attack koum vu wou Dir et net erwaart hutt, et war en onéierlechen, onheemlechen Embuss. Dëst ass schlecht. De nächste Schrëtt ass ze verstoen firwat den Ugräifer dëst gebraucht huet. Wierklech, firwat? Vläicht well hie selwer rosen ass? Firwat ass hien rosen? Zum Beispill, well hie sech selwer geschrauft huet a keng Verantwortung iwwerhëlt? Dëst ass de Wee fir déi ganz Situatioun virsiichteg ze handhaben. Awer dëst erfuerdert Spillraum, verbale Raum. Den éischte Schrëtt ass de verbale Kontakt ofzebriechen. Vermeiden Diskussioun mat Wierder. Annuléieren et, Fouss sou séier wéi méiglech ewech. Wann et en Telefonsgespréich ass, hänkt einfach op - dëst ass eng Fäegkeet déi ech geléiert hunn aus der Kommunikatioun mat menger Ex-Fra. Wann d'Gespréich net iwwerall gutt geet, sot just "Äddi" an hänkt op. Vun der anerer Säit vum Telefon: "blah blah blah", äntwert Dir: "Jo, Äddi!" an ophänken. Dir schléisst just d'Gespréich op. Fënnef Minutte méi spéit, wann d'Fäegkeet fir sënnvoll ze denken zréck bei Iech kënnt, hutt Dir e bëssen ofgekillt, et gëtt méiglech iwwer alles ze denken, wat geschitt ass a wat duerno geschitt. A fänkt un eng nodenklech Äntwert ze formuléieren, anstatt just aus Emotiounen ze reagéieren. Fir mech war den Duerchbroch am Selbstbewosstsinn eben de Fait, datt ech am Fall vun emotionalem Stress net schwätzen kann. Aus dësem Staat erauszekréien, denken a plangen wéi Dir äntweren an d'Problemer kompenséieren - dat sinn déi richteg Schrëtt am Fall wou Dir net schwätze kënnt. Deen einfachste Wee ass aus der Situatioun ze flüchten, an där den emotionalen Stress sech manifestéiert an einfach opzehalen un dësem Stress deelzehuelen. Duerno kënnt Dir denken, wann Dir kënnt denken, kënnt Dir schwätzen, asw.

Iwwregens, am Geriicht probéiert de Géigner Affekot Iech dat ze maachen - elo ass kloer firwat. Well hien huet d'Fähegkeet Iech zu esou engem Zoustand z'ënnerdrécken, datt Dir net emol Ären Numm kann aussoen, zum Beispill. An engem ganz richtege Sënn kënnt Dir net schwätzen. Wann dat mat Iech geschitt, a wann Dir wësst datt Dir Iech op enger Plaz fannt, wou verbal Schluechte rëselen, op enger Plaz wéi Geriicht, da kënnt Dir mat Ärem Affekot kommen. Den Affekot wäert fir Iech opstoen an d'verbal Attack ophalen, a wäert et op eng komplett legal Manéier maachen, an de verluerene Zen Raum wäert Iech zréckkommen. Zum Beispill hunn ech meng Famill e puer Mol missen uruffen, de Riichter war ganz frëndlech doriwwer, awer de Géigner Affekot huet gejaut an op mech gejaut, ech konnt net emol e Wuert erakommen. An dëse Fäll funktionnéiert e Mediateur am beschten fir mech. De Mediateur stoppt all dësen Drock, deen op Iech an engem kontinuéierleche Stroum leeft, Dir fannt déi néideg Zen-Plaz, a mat deem kënnt d'Fäegkeet ze schwätzen zréck. Dëst ass e ganzt Gebitt vu Wëssen, an deem et vill ze studéieren ass, vill an Iech selwer ze entdecken, an dat alles gëtt zu strategesch Entscheedungen op héijem Niveau, déi fir verschidde Leit ënnerschiddlech sinn. E puer Leit hunn net d'Problemer hei uewen beschriwwen; Normalerweis hunn d'Leit déi professionell Verkeefer sinn se net. All déi Leit, déi mat Wierder hiert Liewen maachen - berühmt Sänger, Dichter, reliéis Leader a Politiker, si hunn ëmmer eppes ze soen. Si hunn net esou Problemer, mee ech.

Andrei: Et war ... onerwaart. Super, mir hu scho vill geschwat an et ass Zäit dësen Interview ofzeschléissen. Mir treffen eis definitiv op der Konferenz a kënnen dësen Dialog weiderféieren. Bis zu Hydra!

Dir kënnt Äert Gespréich mam Cliff op der Hydra 2019 Konferenz weiderféieren, déi am Juli 11-12, 2019 zu St. Hie wäert mat engem Rapport kommen "D'Azul Hardware Transactional Memory Erfahrung". Tickete kënne kaaft ginn op der offizieller Websäit.

Source: will.com

Setzt e Commentaire