okay, entreremo in questo modo il
preliminari I Charles nutter Io lavoro
attualmente a Red Hat vari open-source
cose ma principalmente sul linguaggio JRDM JDM
roba che rende più facile per le nuove lingue
per avvicinarsi alla piattaforma espandendo il
piattaforma per mettere una lingua madre e così
su così la struttura di questo discorso è gentile
di essere una storia una commedia in tre
agisce parlando del lavoro che stiamo facendo
su decadi di pastelli giovani e magri ora
le sfide che abbiamo dovuto affrontare
trattare con la JVM e alcuni dei suoi
limitazioni e come JVM e Jari
si stanno evolvendo insieme per farlo
più facile in futuro, quindi parleremo a
è un po ‘il primo cavallo jruby
fondamentalmente solo rubino sui prodotti JVM
è stato intorno per un po ‘ e nel 2001
era il primo impegno con JRuby
in pratica ho appena iniziato a implementare il
parser Penso che per lo più stavano guardando
a farlo per utensili e poi deciso
hey abbiamo un parser che possiamo interferire
possiamo iniziare a costruire un vero potrebbe essere
correre il tempo in cima alla giuria, sì, ma per
circa cinque anni o giù di lì non ha davvero
muoversi molto velocemente non potrebbe funzionare di più
Il codice rubino era basato su un vecchio
versione di Ruby la singolarità delle rotaie
è successo all’interno della comunità di Ruby
è stato durante quel periodo e così in giro
2005-2006 Sono stato coinvolto nel progetto
e abbiamo pensato bene perché non può essere è
c’è qualche ragione per cui non potremmo davvero
avere Jay Ruby sui binari Rails Ranji
correre sul jamie che sto prendendo
vantaggio delle librerie JVM con JDM così
e nel 2006 siamo stati in grado di farlo
così ci siamo presentati allo show di javaone in esecuzione
in cima alla Serie B in cima al GBM
c’è un pacco primitivo molto presto insieme
forma ma fu presto un inizio
questo è quello che stiamo facendo questo
e ora stiamo lavorando su JRuby 9000
è in realtà la nona major release di
JRuby che abbiamo avuto dal 10 così quando io
era il primo e ora siamo a
jruby che è più veloce di ordini di grandezza
rispetto a quello del 2006 che stiamo guardando
gestendo molto più binari di scorrimento radhika
applicazioni in produzione per reale
i clienti piacciono come è
SoundCloud su JRuby come parti chiave di
i loro membri hanno ragione è molto lavoro
per arrivare a questo punto questo è quello che ho corso
la scorsa notte solo per vedere dove il nostro maestro
ramo è che questo è 29.000 commit
che stanno per finire in JRuby
gli anni e questo non conta tutto
lavoro che abbiamo fatto sui rami di manutenzione
per ognuna di queste uscite anche in modo
c’è ovviamente molto lavoro, ma perché
potremmo soffrire con il
sfide di portare un linguaggio simile
Ruby to the JVM per 9 anni 10 anni
ma la linea di fondo è che eravamo tutti
Ragazzi Java conosci bene la JVM
i suoi toni della pelle in e out o a
almeno pensavamo di fare tutte le cose
e outs e si adatta proprio al nostro modo
voleva costruire Ruby vuole essere in grado di
concentrarsi sull’implementazione della funzionalità
di Ruby il linguaggio delle classi principali di Ruby
e non dobbiamo costruirci la nostra merda
il nostro GC tutti quegli altri pezzi che
la JVM ci offre gratuitamente così la JVM è
tipo di questa scatola nera magica che noi
possiamo semplicemente buttare le nostre cose per lanciare le nostre
codice a lanciare un interprete rubino fare
generazione di piccoli byte di codice, qualunque sia e
eseguirà il nostro codice alla grande e
tutto scorre veloce tranne mio fratello
e questo è ciò che la sfida del
parte interessante che lavora sul traditore
nove anni è in realtà quando JDM
non posso fare quello che dovevamo fare dopo
passo come attraversiamo quella linea di
impossibile il jvm non può farlo più
la gente si arrende, non abbiamo un
opzione in modo da trovare nuovi modi per farlo
siamo lasciati con questa sfida che vogliamo
far funzionare bene Java e Ruby
insieme e non solo funzionano bene insieme
come linguaggio JDM ma funziona bene come a
implementazione ruby così gli utenti di Ruby ottengono
l’esperienza che si aspettano da
in esecuzione JRuby che esegue Ruby in cima al
JVM quindi parleremo di tre
aree specifiche qui che sono state
sfide per noi e come è la JVM
evolvendosi per renderlo un po ‘più facile in
il futuro per gente come te e per noi
per continuare a lavorare qui così prima di tutto
parleremo solo di più
concetto primitivo di base in Ruby dove
generalmente tutte le prestazioni sono perse
tutte quelle chiamate di metodo che facciamo in a
tipica applicazione Ruby qui è una metrica
L’Iran è davvero veloce solo stamattina
per vedere quante chiamate semplici e questo è
Mi piace solo chiamare il metodo Foo o
chiamare un punto foo su qualche oggetto così
ci sono altri tipi di chiamate che fanno super
in vacanza e quant’altro non lo sono
elencato qui ma sai per fare
cose come gem installazione di binari e tutto
delle dipendenze di cui ha bisogno
315.000 chiamate che vengono fatte chiamate da Ruby
facendo generare un nuovo binario
applicazione 606 mila e questo è
generando l’app più l’installazione
dipendenze aggiuntive necessarie per a
esecuzione dell’applicazione ho fatto un po ‘veloce
applicazione cruda e appena finito
tutte e quattro le operazioni circa 16.000 da fare
tutte e quattro le operazioni crude, così sei tu
sapere approssimativamente sarà come un 4000
per richiesta solo per fare un veramente semplice
visualizzazione di alcuni dati quindi dobbiamo fare
questo metodo chiama velocemente e il problema
abbiamo sempre avuto in JRuby abbiamo un
semplice esempio qui foo calling bar
chiamando Baz e su Java cinque e sei
quello che stavamo costruendo jaber oltre la maggior parte
della maggior parte della sua vita che abbiamo
in mezzo questa logica di chiamata in più
questi dobbiamo andare a cercare il
tipo di metodo che dobbiamo accertarci di avere
ho la stessa classe in mano che noi
attesi l’ultima volta che dobbiamo farlo
e sfortunatamente la JVM è pessima
ottimizzando attraverso un pezzo generico di
codice e buy generic voglio dire che hai
un sacco di diversi percorsi di chiamata che sono
tutto questo attraverso questo stesso pezzo di
codice che diventa un nero di ottimizzazione
buco niente può superare questo
serie di chiamate che nulla può attraversare
quella logica chiamata intermedia che noi
hanno e così la maggior parte della grande JVM
ottimizzazioni che speriamo di poter uscire
costruire Ruby sulla JVM in realtà non lo è
materializzarsi e questo è dove invocare
dinamica viene in quante persone sono
familiarità con invocare la dinamica almeno su
la superficie va bene così tanti di voi
sentito almeno un po ‘su di esso
passeremo attraverso un po ‘di storia qui
di fatto gli autori della JVM ne hanno parlato
avere altri linguaggi non Java su
JVM e almeno non lo fece
escludere questa possibilità in futuro
e per questo molto e molto
gente di lingue prese di mira sulla JVM
alcuni dei primi erano in te
so 96 97 poco dopo Java in realtà
è stato rilasciato per la prima volta
ovvii più noti come Jai
thon erano in realtà prima del 2000 a secco ora
pensavo fosse prima del 2000 o agli inizi degli anni 2000 così
molto prima che la JVM fosse pari
considerato come un vm multilingue
la gente stava costruendo le lingue sopra
il problema è che nonostante la JVM
era sempre previsto che potesse funzionare
altri linguaggi non è mai stato progettato
per molte di queste altre lingue lì
sono trucchi come la spedizione dinamica
non ha funzionato molto bene con un staticamente
vm digitato ci sono ottimizzazioni
lingue dinamiche o altri nuovi tipi di
le lingue avrebbero bisogno di diversi tipi di
chiamate i modelli quindi siamo bloccati in questo
questo tipo di bolla questo mondo di JVM
opcode che è praticamente tutto quello che possiamo
lavorare con e e ci sono tre principali
aree di operazioni che è possibile eseguire
a livello JVM puoi effettuare chiamate
invocazione a cui è possibile accedere i campi
gli oggetti sono impostati e ottengono così i dati
lì per altri thread per vedere un array
accedere di nuovo a qualcosa di simile
mettere i dati in una struttura di dati
questo sarà passato in giro e
usati dal mondo sono belli
molte le uniche operazioni che lo faranno
potenzialmente hanno alcuni effetti collaterali alcuni
effetto collaterale visibile al di fuori di quello
operazione e poi c’è tutto questo
altro controllo di flusso e stack
manipolazione nuova
Operazioni di Eric che in realtà non hanno
qualsiasi effetto collaterale del loro tipo di funzionale
operazioni a livello di jvm ma loro
servono per spostare i dati nei posti giusti
per queste operazioni chiave come
invocazione e accesso ai dati e se
hai intenzione di costruire una lingua in cima
della JVM devi praticamente restare
dentro qui devi colorare dentro
queste linee e questo è dove invocare
la dinamica è arrivata davvero davvero
consente alla piattaforma di fare molto di più
di quanto non facesse prima che questo venga dalla JVM
questa è la citazione che ho citato in
il futuro considereremo limitato
estensioni alla Java Virtual Machine
per fornire un supporto migliore per gli altri
le lingue sono tornate nel 1997 a parlare
circa la possibilità di aggiungere
funzionalità aggiuntive solo per supportare
altri linguaggi non JVM non Java e
quello ci conduce il jsr 292 che era il
java 7 jsr per invocare il richiamo dinamico
la dinamica è fondamentalmente un utente definibile
bytecode quindi abbiamo i nostri invocati e
abbiamo i nostri accessi sul campo questo è un
codice byte speciale che programmiamo
internamente la JVM ci chiede cosa fare
piuttosto quando si imbatte in questo bytecode
di avere un insieme predeterminato di
operazioni che conosce già anche
viene fornito con una serie di puntatori veloci del metodo
chiamato metodo maniglie hai visto il
java.lang invoca il pacchetto di questi handle
ora stanno ottenendo il punto in cui sono
molto più veloce di chiamare
riflessione possono ottimizzare molto meglio
la JVM può effettivamente ottimizzare
quelle maniglie attraverso quei puntatori come
se fosse una chiamata diretta è molto
molto responsabilizzare modo phul per iniziare il cablaggio
cose insieme solo con semplicità
maniglie riflettenti che ottimizzano bene
e poi come materiale per il caching e
convalida l’idea generale era che noi
volevo creare un bytecode che terminasse
tutti i codici byte che potremmo avere
questa un’opportunità per fare un cambiamento
la specifica JVM che è davvero molto difficile
per fare abbiamo bisogno di farlo bene e così via
è stato reso molto personalizzabile molto
configurabile ed è in realtà
iniziando a suonare molto bene per
lingue diverse parlano di pochi
gli utenti ovviamente esistevano JRuby e Groovy
prima invochiamo dinamici e siamo cresciuti
in esso jruby è stato il primo ad adottare
invocando dinamico abbiamo effettivamente iniziato a usare
prima che fosse una qualsiasi versione interiore
prima ancora che fosse finalizzato come API
solo per provarlo
e aiutami a provare a tirare le gomme
credi che Groovy abbia una modalità che puoi trasformare
adesso che utilizza invocare dinamica a grande
effettuare nuove implementazioni e Diane
Diane Jas e nas horn costruito sopra
invoca dinamicamente fin dall’inizio
e così stanno ricevendo il
vantaggio di averlo dal giorno
uno e progettando l’intero sistema
intorno ad esso questo è un fatto poco conosciuto
quel Java 8 lambda e il sacco del
Anche le funzionalità di Java 9 stanno crescendo
di invocare dinamicamente tutti questi
posti di blocco che hanno mantenuto la JVM ragazzi
jdk ragazzi dall’aggiunta di funzionalità a java
ora iniziamo a essere spazzati via anche noi
possibile aggiungere funzionalità java basate su invoke
dinamico che era impossibile da fare
prima o almeno difficile da fare
roba efficacemente molto eccitante e lo farò
parla un po ‘di più di tutti quelli
lavoro più tardi quindi ora cosa è esattamente
nemici invocati in realtà sanno come
invoca opere dinamiche non impressionanti
questo significa che tutti avrebbero avuto
qualcosa di nuovo da questo va bene così invoca
abbiamo le nostre quattro invocazioni di base
tipi statici per te conoscono i metodi statici
abbastanza semplice virtuale quando al
compilare il tempo si conosce la classe concreta
che stai chiamando contro l’interfaccia
quando chiami contro un’interfaccia
non sai quale sia la classe concreta
JVM deve scoprirlo più tardi e
quindi costruttore e super chiama quale
si chiamano inviti speciali e questi
riassumere in quattro codici byte diversi
qui con alcuni dei confusi
pasticcio interno che rappresenta il metodo
in realtà chiameranno i loro e
se prendiamo queste quattro operazioni e
scomporli in ciò che effettivamente
succede a livello JVM a cui inizierai
vedi che questa è in gran parte la stessa cosa
per ognuno di loro c’è minore
cambia il modo in cui osserva i metodi come
guardie di ottimizzazione della cache che saranno presenti
posto in alcuni casi ma non in altri
sarebbe bello se potessimo prenderli
pezzi di quei singoli pezzi fuori
ognuno di questi invoca e ricama
insieme però vogliamo fare il nostro caching
proprio modo do metodo di guardare in alto la nostra strada
ed è qui che entra in gioco la dinamica
tutto il richiamo dinamico fa è richiamare a
il tuo codice hai impostato il caching del sito di chiamata
vai a cercare metodi in cui vai in piedi
I valori in memoria e poi danno che
torna alla JVM e dì ecco come te
fai questa operazione ecco come questo invoca
dinamico
dovrebbe funzionare lo fa da allora
con queste maniglie del metodo ottimizzate
con tutta la logica di caching che hai
ottenuto e idealmente lo ottimizza come se fosse
era diretto attraverso la chiamata statica che è
quello che stiamo cercando un po ‘di più
graficamente abbiamo ottenuto questo tipo di a
metafora del centralino qui così su
all’inizio chiamiamo e questo è un
invoca dinamicamente che abbiamo bisogno di qualcosa
là fuori qualche pezzo di dati che dobbiamo
ottenere un metodo che abbiamo bisogno di chiamare o
invoca inizia dinamiche proprio lì
va alla JVM della JVM, quindi guarderemo
per il nostro metodo di bootstrap lo farà
richiamare il nostro codice nel codice utente
dal metodo bootstrap a livello JVM
trova il giusto filo di destinazione tutto
e usa maniglie del metodo per farlo
questo è il tipo di cavi che si collegano qui
una chiamata a un altro le maniglie del metodo
poi finirà per risolverlo
metodo target o Target Field o alcuni
pezzo di dati e prima di Java 7 lo sai
è stato fatto un simile processo per
ogni chiamata in Ruby ogni jruby
chiama ma dovevamo farlo ogni volta che avremmo
tornare indietro attraverso questo processo
forse controllare una cache per fare in modo che la chiamata lo guardi
controllare che il denaro faccia call e così via
più e più volte e ha perso molto
tempo e poi ancora la JVM può ottimizzare
attraverso ciò la magia con invocazione
dinamico è quello dopo questo primo
processo di bootstrap tutto questo
scompare e ricevi chiamate dirette da
che invocano la dinamica nel metodo di destinazione
da quello in poi e quello è il vero
la magia accade così guardi JRuby
Java 7 quella logica intermedia
scompare o almeno fino alla JVM
è preoccupato che scompaia lo colleghiamo
in un certo senso la JVM comprende un po ‘
meglio arriviamo direttamente attraverso i call pad
per quanto riguarda il naso JVM va direttamente
dal cibo un bar a baz e tutti quelli
grandi ottimizzazioni che usciamo di
la JVM come inlining in realtà accade
e vediamo che questo succede a Ruby in linea
in linea con Ruby Java in linea con Ruby
viceversa, tutte queste cose in realtà
funziona e funziona davvero bene
le JVM attuali richiamano quindi la dinamica in JRuby
ovviamente lo stiamo usando per metodo
la spedizione è piuttosto semplice la nostra logica
guarda il metodo che abbiamo in contanti
dice quale era l’ ultimo tipo e se
esso può
partite invalidate se la classe cambia
o se arriva qualche nuovo tipo e noi
potrebbe incatenarli, quindi abbiamo due o
tre tipi che sono disponibili tre o
due o tre tipi di due o tre
metodi di pagamento li usiamo anche per i luoghi
come costante guardare in costanti di Ruby
sono definiti pigramente possono anche essere
modificato forzatamente in genere non lo è
fatto ma può essere fatto così abbiamo
logica di caching simile usciamo e guardiamo
la costante abbiamo un cache che
raramente è rotto raramente deve essere
invalidata la JVM quindi può vedere che come
una vera costante anche se in
Ruby può cambiare in qualsiasi momento e così
può ottimizzarlo come se fosse una costante
scritto nel codice direttamente tutto a posto
ora quanto bene funziona per noi questo è
un grafico che mostra in pratica quanto
più veloce siamo di Ruby 1.9 il
numeri di prestazione per 2 punto 0 2 2.2
non sono molto diversi qui
questi sono questo j di riferimento di Ruby
penso che jruby 1.7 o giù di lì su un Java
cinque o sei dove abbiamo questa logica
impedendo le ottimizzazioni da
accadendo e questo è quello che sembra
con invocare la dinamica solo cambiando
queste chiamate da utilizzare invocano dinamico e
cambiando nient’altro nel runtime noi
ottenere questo miglioramento molto significativo
miglioramento sul rosso nero lì così
molto però che volevamo davvero
esplorare questo un po ‘oltre così questo è
un punto di riferimento per costruire un grande rosso
albero nero che lo attraversa un po ‘ diverso
modi di cancellare gli elementi e poi sai
scaricarlo e riprovare
particolare benchmark Ruby 20 e un puro
l’implementazione rubino del nero rosso ha preso
circa 2 2,5 secondi o così e questo è
questo è un motivo riutilizzabile per cui le persone a
il mondo Ruby si girerà per vedere
le estensioni hanno un algoritmo
una cosa come questa è una struttura di dati pesante
pesantemente colpito struttura di dati che
bisogno di fare velocemente e così lo scrivono
e vedi invece c’è solo così tanto tu
può fare per ottenere lo standard
implementazione a Ruby per correre più velocemente vedere
è il solito go-to e questo aiuta
questo lo riduce di circa la metà a
secondo per ogni o ogni iterazione di
questo particolare punto di riferimento e ora questo
è la parte cool JRuby con lo stesso
implementazione di rubino puro che esegue il
stesso punto di riferimento siamo in realtà più veloci
di Ruby con una estensione di visualizzazione e noi siamo
vedendo questo di più in
più che piuttosto che dover andare a
mare per ottenere prestazioni dal codice Ruby
le persone possono semplicemente spostarlo su JRuby e ottenere
lo stesso tipo di spinta va bene così indietro
agli utenti che parlano un po ‘di
come stanno usando il corno dei neigh I
menzionato in precedenza costruito su invoke
dinamico fin dal primo istante
stanno facendo molto più avanzato
compilatore lavoro avanzato ottimizzazione loro
speculativamente dire va bene questo è probabilmente
sarà un metodo che usa intz o
polmoni e quindi usano invocare dinamici
come spirito come una valvola di sfogo quando
scopre che non lo stai facendo
l’algoritmo contro di esso balla via
invocare la dinamica genera del nuovo codice
e poi entra in quella versione modificata
roba molto bella guardando le prestazioni
iniziando a essere paragonabile alla v8 su a
molti benchmark solo un po ‘
di magia extra su entrambi
dinamico e là sono molto
interessati a trasformare il lavoro che hanno
fatto su nasrin in una lingua generale
quadro così tutti quelli che vogliono usare
invoca dinamici un tipo di linguaggio dinamico
specializzazione che ottimizza numerics e
non potremo collegarci a questo
e avere la stessa cosa così è davvero
fresco ho menzionato quel lambda in java 8
usa invoke dynamic se funziona molto
simile alle classi interne ma pigramente
genera quella classe che non ha bisogno di
avere quello sul comando sul
file system non ha bisogno di essere nel
jar non hai bisogno di questi dollari zero
dollaro uno e tutto ciò che invoca dinamici
è usato fondamentalmente per generarlo sul
vola se arrivi davvero a quel punto
e questo è un esempio di un bytecode così
abbiamo un tipo che stiamo facendo con a
semplice intero confronta che è il nostro che è
il nostro lambda là invoca la dinamica va
fuori e genera quel wrapping di classe
tutto questo codice che viene utilizzato per
le chiamate di lunghezza della stringa effettiva e il
confronta proprio qui e poi quella classe
viene restituito e inserito direttamente nel
invoca la dinamica in modo che non sia mai stata
essere generato di nuovo è come se quello
virtuale quella classe interiore anonima
sempre esistito, ma non si deve
averlo sulla riga di comando non lo fai
devo avere quel qualcosa in più
il fastidio di trattare con i file questo è
gli usi di invoke dynamic diventano più interessanti
ogni anno non ci sarà nessun java nove
sta andando a fare la specializzazione generica
reificazione per le collezioni che farai
avere un ArrayList di int che opera
come ti aspetti che sia una delle chiavi
caratteristiche che sta arrivando ed è
costruito molto pesantemente su invoke
dinamico di nuovo nel punto in cui tu
hai bisogno di un ArrayList di int hai bisogno di a
collezione primitiva che non siamo mai stati
in grado di avere prima senza specializzato
le biblioteche andranno via chiedono il dentro
invoca chiamate dinamiche in alcuni livelli JDK
codice genera ciò che un ArrayList di int
sarebbe simile e quindi collegarlo a destra
di nuovo nell’invoca dinamica, così possiamo
in realtà hanno queste collezioni reificate
senza generarli tutti in anticipo
tempo senza avere un evento ArrayList
e una ArrayList di char sarà tutto a posto
funziona e si collegherà tutti usando invoke
dinamico sotto le coperte molto cool e
hanno dei prototipi funzionanti di questo
già se vuoi provare il
il progetto valhalla branch di OpenJDK va bene
quindi penso che il metodo chiama a
prestazioni a cui ricevere le chiamate al metodo Ruby
ottimizzare il modo in cui vogliamo è una specie di a
problema risolto a questo punto c’è
ovviamente il tipo di specializzazione
dobbiamo ancora lavorare nella prossima area
che ci siamo davvero imbattuti e corriamo ancora
fino ad oggi è che Ruby è in gran parte
un wrapper su UNIX o un wrapper
in giro per POSIX vedere alcuni
esempi di questo è l’aria no
classe e tutte le classi definite
sotto per generare errori e
questi sono fondamentalmente solo tutta l’aria
sa che vedresti cose a livello del mare
che tu riconosceresti se lo sei
costruendo qualsiasi applicazione vedi un altro
esempio la libreria etsy in ruby ha un
numero di metodi per accedere a
file di password su un gruppo di sistemi unix
informazioni utente informazioni e così via
e non si sono nemmeno presi la briga di farlo
questi nomi carini sono solo il mare
funzioni raccolte direttamente nel rubino
quindi se vogliamo implementarlo e avere
tutto il codice rubino là fuori funziona di cui abbiamo bisogno
essere in grado di fare queste cose che dobbiamo
avere a disposizione queste operazioni a
il livello JVM come lo facciamo e
ecco dove avere un nativo migliore
Interopare alla JVM entra così guardiamo
nel mondo JVM qui abbiamo ottenuto il nostro bello
area felice quaternizzata dove non c’è
il codice nativo è scritto una volta eseguito ovunque
giusto e poi abbiamo questo nativo
mondo in cui abbiamo ottenuto tutti questi cool
biblioteca
è che abbiamo bisogno di chiamare abbiamo
caratteristiche del sistema operativo di cui abbiamo bisogno
per accedere alle nuove librerie nuove grafiche
sottosistemi e non c’è davvero niente di buono
modo di fare questo ora come parte del
JVM standard è una grande citazione di John
Rose se i programmatori non Java ne trovano
libreria utile e facile accedervi
dovrebbe essere allo stesso modo accessibile a Java
programmatori e questo non è stato il
filosofia della piattaforma Java per la maggior parte
della sua vita la filosofia di
la piattaforma Java è generalmente stata se
Alcuni programmatori di John su Java ne trovano
utilizzo della biblioteca facile e facile da usare
accesso dovremmo portarlo così a Java
che possiamo avere su Java e poi
quello che tutti quelli che hanno fatto un porto o un
la copia di un progetto sa che lo sei
sta per uscire dalla sincronizzazione che stai per
devono mantenere due versioni differenti
è un po ‘stupido che non possiamo solo
chiamare in alcune di queste librerie
e li uso direttamente a destra, penso
sembra stupido quindi l’esempio che voglio andare
attraverso qui è cosa se noi solo noi solo
voglio prendere la fossa per la corrente
processo abbiamo un sistema di monitoraggio
o alcuni tipi di DevOps amministrativi
cosa che ha bisogno della fossa per poterla chiudere
giù invia segnali qualunque cosa non sia
possibile fare su JVM proprio ora tu
non è nemmeno possibile ottenere l’ID del processo corrente
l’unico modo che puoi ottenere è
se hai intenzione di scrivere un codice C
te stesso e in fondo scrivi un
estensione per JVM quindi per jni è
qualcuno ha fatto Jay e io ok ci sono a
poche persone che provo per te e Jay
abbiamo il nostro codice utente al primo posto
deve fare qualche chiamata ci sarà a
jni endpoint nativo sul lato Java
un codice C che rappresenta ciò
potrebbe quella che la logica nativa è supposta
da fare e poi alla fine arriviamo al
biblioteca di destinazione e ora se si avvia
guardando quello che Jay e io facciamo nel suo genere
di ingannevolmente semplice qui oh noi solo
bastone nativo lì e abbiamo a
la chiamata nativa è improvvisamente come una magia
giù chiamate nel codice nativo e noi siamo
buono per andare ma poi c’è tutto questo
cose che devono essere fatte dietro il
scene che non ha nulla a che fare con il
Il codice Java che hai appena scritto è necessario
genera le intestazioni jni per tutte le tue
endpoint nativi con alcuni piacevolmente
nome della funzione straziata così la JVM può
Trovalo
è necessario implementarlo per questo caso
è ovviamente abbastanza semplice essere pagato
ritorna in un int che si adatta perfettamente
benissimo nel j lungo potremmo fare un po ‘
fondere la logica per assicurarsi che si adatti bene
o firmato a destra per una particolare chiamata
ma ma questo non è troppo terribile così
abbiamo il nostro header abbiamo il nostro file C.
ora dobbiamo costruirlo e questo è
dove cado perché non lo so
come si fa a fare una schifezza che non so
quali librerie dovrei collegare
su e su base per piattaforma come sono
dovrebbe fare questo diverso compilatore
fai le cose in modi diversi e poi tu
devi pensare agli utenti o tu sei
andando a dover costruire questo prima
tempo per tutte le piattaforme o gli utenti sono
andando a costruirlo ogni volta che loro
c’è bisogno di usarlo e questo fa schifo per loro
Anche così si sta andando ad avere per avere make
file che devi avere altro
roba che non fa parte del mondo Java
c’è che deve esserci una migliore
modo di fare questo tutto quello che voglio è un dannato ragazzo
giusto così che era lì che è Java
il runtime nativo entra così necessario per Java
di runtime è una java api per la chiamata
codice nativo abbiamo una sorta di strati
runtime un mucchio di utilità diversa
librerie che puoi usare se alcune di
potresti aver usato j o visto java nativo
accesso in giro molto simile che abbiamo preso
alcuni li portiamo ancora un po ‘ oltre
è essenzialmente una funzione straniera
interfaccia con cui hai mai avuto a che fare
qualsiasi cosa nel mondo del mare che usa ffi
è un’interfaccia di funzione straniera per
la JVM intendo che c’è l’organizzazione
su github dove teniamo tutti i progetti
jnr quindi cosa possiamo fare con jnr
è andare da questa situazione in cui abbiamo
per implementare tutto in viola qui
incluse cose che non sono in Java e
non ha nulla a che fare con ciò che effettivamente
voglio fare a questo abbiamo alcuni
codice utente che definisce un endpoint in
alcune librerie C dicono che questa è la libreria
ecco la funzione qui è il
i parametri e il valore di ritorno me lo consentono
chiama la cosa distrutta come jnr stub
sotto quello capisce come collegare
che nei tipi Java si chiama J e I
fa effettivamente l’invocazione e poi
tutta quella logica è pre-costruita per tutti
piattaforma in modo che possiamo semplicemente spedire un semplice
libreria più le nostre due o tre righe di
Codice Java quindi questo è quello che ottenere pit
in realtà sembra che in jnr definiamo un
interfaccia che ha approssimativamente la funzione
prototipo della funzione c che vogliamo
chiamata
diciamo al caricatore della libreria di creare un
versione un’implementazione di questo
interfaccia basata sulla funzione in arrivo
fuori da una libreria C e poi abbiamo
in mano un oggetto che possiamo chiamare quelli
vedere le funzioni direttamente molto meglio
rispetto alla versione J e I penso che io
menzionato il tempo di esecuzione a strati che
abbiamo intenzione di passare attraverso a
alcuni di questi JN sono una sorta di soste al
punto che ho appena mostrato puoi chiamare
funzioni che puoi definire funzione
endpoint ma non ce ne sono molti
codice di supporto disponibile per te per primo
tutto ciò che voglio menzionare è la piattaforma
non voglio dover ricostruire questo ogni
ora andiamo ad un nuovo sistema, quindi spediamo
con supporto per tutte queste piattaforme
piccolo piccolo stub nativo che è nel
barattolo si svuota se necessario e poi
carica dinamicamente se qualcuno ha un
piattaforma che non è lì mi piacerebbe
ascoltarlo, abbiamo sì, openvms è io
pensa di lavorare ora per tutti voi openvms
utenti là fuori che vogliono davvero saltare
su quel Linux Linux mainframe as400 z
abbiamo tutto il supporto per il materiale
ci sono certamente altre piattaforme che
sono arrivati ma è molto facile per noi
per costruire un piccolo mozzicone su qualsiasi piattaforma
roba nella nostra costruzione ed è bello
vai così Jay NRF se sono fondamentalmente il codice
che ti ho mostrato che è il jna a
equivalente che è la libreria di base per
per il cablaggio di alcune librerie C e di nuovo
c’è quell’esempio abbastanza facile da fare
e ovviamente una volta che hai le basi
impianto idraulico cablato è facile aggiungere nuovi
funziona a questo come vengono ma
ovviamente molte di queste cose sono
operazioni standard che sono di tutti
andando ad avere bisogno di ottenere una fossa di cui non abbiamo bisogno
per far scrivere a tutti nel mondo
la loro interfaccia personale e il loro
la propria logica di carico per ottenere il recupero
operazione disponibile così abbiamo costruito il nostro
primo livello in cima a j NR j jnr posix
che in pratica pre collega un intero gruppo
delle funzioni POSIX più comuni
probabilmente gli utenti avranno bisogno di questo
un piccolo frammento di quelli che sono
cose definite come chmod chn che tu
ancora non può fare altrettanto con le API di JVM
la forcella è lì e non funziona molto
bene puoi immaginare che tipo di
fare cose orribili che una JVM farebbe
sai cose come Geez
Thread di GC che non arrivano per il
cavalcare un tipo di problema, cos’altro è buono
la nostra chiamata pagata è lì che uccide
le effettive operazioni del segnale stanno diventando crude
variabili ambientali e impostazione da parte nostra
variabili nell’ambiente attuale
giù in fondo difficile vedere qui
abbiamo spawn POSIX che è come il
kit di strumenti definitivo per la deposizione delle uova
sottoprocessi e incidentalmente c’è
un pacchetto di Jan il nostro processo che sono
lavorando su di esso che salta tutto il
processo costruttore senza senso e va
direttamente a una chiamata di spawn in modo da ottenere
veri e propri canali fuori da quel processo
puoi selezionare puoi effettivamente
controllare in modo interattivo un sottoprocesso
praticamente impossibile da fare attraverso il
JV jdk process api’s quindi ecco qual è il nostro
ottenere pit sembra che ora andiamo a posix
fabbrica creiamo una nuova istanza che puoi
crea il tuo gestore personale, puoi fare aria
il naso alza un’eccezione piuttosto che fare a
restituire valore alle cose lungo quelle linee
se vuoi le caratteristiche native a
essere abilitato o utilizzare solo il puro java
emulazione POSIX API e poi alla
in fondo una volta che hai in mano te
basta fare la chiamata così abbiamo POSIX noi
ha ottenuto un’istanza POSIX per ogni JRuby
istanza e questo è dove tutti i nostri
la logica va a chiamare il nativo
funziona così ora abbiamo bisogno di costruire un
un po ‘di più in cima a questo, quindi cosa?
se facciamo una chiamata aperta di livello c per aprire a
file o una chiamata socket per creare un socket
a livello nativo e abbiamo appena ottenuto un
descrittore di file in mano e non molto
possiamo fare possiamo tornare indietro e fare una lettura
chiama al livello del mare e continua ad uscire
al lato natio ogni volta che voglio
fai una lettura ma poi ottieni cose come
seleziona quali sono più complicati
sono diversi tra le piattaforme
le API non corrispondono abbastanza a quelle basse
controllo di livello su questi file
descrittori che non puoi davvero fare a
il livello JVM in modo che sia lì
prendi e NX ioj nel nostro enx i / o esteso
cross-platform nativo I oh è
praticamente niño compatibile quindi si adatta
in tutto il resto usiamo i canali
e flussi nella JVM, ma lo fa
chiamate native per ogni operazione attraverso
jnr fa una lettura nativa
kq nativo o sondaggio e per la selezione
logica fa le cose giuste su tutto
piattaforme diverse ma puoi semplicemente
passare in un descrittore di file nativo
una cosa che è davvero divertente da fare
questo puoi prenderlo tu puoi prenderlo
e passare in qualsiasi IO standard
descrittori e sono completamente interattivi
I / O standard selezionabili che non si
in realtà ha modo di fare sulla JVM
oggi non puoi selezionare rispetto allo standard
per esempio quando stai aspettando
input banale da fare con questo integrato
torna su di nuovo cercando di aggiungerne altri
queste caratteristiche ci aspettano molte persone
avranno bisogno di usi jnr unix per il socket
jnr en xio fornisce un socket eunuch
implementazione in un solo canale
sembra un qualsiasi altro canale niño in
il sistema selezionabile funziona come a
presa è perfetta quindi cos’altro possiamo
fallo con onestamente se potessimo
avere questo a livello JVM nel JDK
potremmo fare noi stessi
niño niño a noi stessi in Java
fondamentalmente non abbiamo bisogno di avere la JVM
includere un mucchio di codice nativo da fare
queste cose più che è veramente
eccitante soprattutto per il JDK
ingegneri che vogliono aggiungerne alcuni
nuove funzionalità in particolare come desktop
l’integrazione deve aspettare il prossimo
Versione JVM per includere il codice C per esso
che palle non vogliamo farlo
accesso alla memoria non gestita molto
le persone non sono sicure per allocare un
pezzo di memoria e lavorare con esso
direttamente possiamo fare quella chiamata tribulus
Malloc è tutto ciò che c’è da chiamare
malloc e si ottiene un oggetto puntatore indietro
che ti permette di interagire con quel pezzo
di dati nel mondo nativo molto
facilmente ho menzionato lo standard selezionabile
I / O e process io danno molto di più
interattività a quei flussi e poi
lo sai che altri tipi di socket sono la nuova API
nuove librerie crittografiche tutte le cose che noi
potrebbe fare senza mai scrivere una linea di
codice C quindi penso che sia necessario
la JVM e ne parleremo a
un po ‘più tardi per quanto riguarda le prestazioni
tornando al motivo per cui non usiamo je na
purtroppo facciamo un sacco di lavoro per rendere questo
eseguire il più velocemente possibile il codice che porta
fino alla chiamata jni viene generato così
idealmente è solo un salto dalla tua chiamata
verso l’endpoint jni dall’altra parte
il codice C in realtà genera assembly
al volo collegalo alla JVM in modo che
si spera che una chiamata dal tuo nativo
invocazione nel lato Java al
biblioteca reale quindi forse due o tre
luppolo totale questo è il confronto je na e
jnr
je na è il plus Jr’s i cerchi
qui e questa è una scala logaritmica jnr
è all’incirca un ordine di grandezza più veloce
di J e quindi puoi immaginare quando siamo
usando je na per fare tutte queste cose prima
Quanta parte di un impatto sulle prestazioni
in realtà era possibile migliorarlo ulteriormente
ci sono modi che puoi personalizzare
queste chiamate se per esempio non ci sei
tutti interessati all’aria senza valore e
non ne hai bisogno per essere salvato da te
può lanciare ignorare annotazione errore su
e ottieni un altro venticinque percento
o fuori di esso se è una chiamata cruda
sai che è improbabile che fallisca come un get
chiamata bloccata c’è sicuramente di più
fai qui anche se questo è jnr con con e
senza l’errore ignora jni nel
cerchi insolitamente là che jnr con
ignorare gli errori più velocemente del jni
versione non sono sicuro del perché sia e
quindi il GCC 03 potenzialmente ottimizza
alcuni di questi sono pagati, ma via
c’è ancora del lavoro non banale
fatto qui per il punto di riferimento ed è
molto più veloce di quello che abbiamo alla JVM
livello appena passato attraverso jnr, quindi è così
dove il progetto Panama arriva in questo è
JEP 191 fi per la JVM cosa siamo
lavorando ora o cosa JVM
la gente sta lavorando al momento è il
JVM lato di questo come effettivamente fare
queste chiamate native ottimizzano velocemente così
quando generano l’ assemblaggio ottimizzato
per il codice Java va dritto
fino a una chiamata C per ottenere pit piuttosto
che passare attraverso tutti i nostri extra
impianto idraulico che è possibile fare quando
si stanno avvicinando a questo ora
c’è anche la possibilità di ottenere
migliore sicurezza per questo avere bene
grani per il controllo su voglio caricare
la Lib C ma io voglio solo questi
funzioni per essere mappabili niente come
che esiste nel modello di sicurezza Java
al momento e poi avere il metodo
maniglie per questo è una funzione nativa
renderlo ottimizzato come un metodo di gestire
e invoco dinamico quindi posso effettivamente
avere il mio codice Ruby per fare una chiamata nativa e
fa la chiamata nativa nel generato
assemblare cose interessanti e naturalmente native
la manipolazione del layout della memoria ci sono molte cose
di lavoro su diverse forme di struttura
e e tipi di valore e altre cose
che vengono eseguiti a livello di JVM
avere più conoscenza di ciò che è nativo
il codice vuole vedere farà la JVM
costruire strutture migliori per quelli del
area finale voglio parlare di Ruby
è uguale a oggetti e intendo molto e
un sacco di oggetti qualcuno ha fatto un
misura di quante stringhe a
la richiesta di singoli binari crea durante il
processo di gestione ed è stato
migliaia e migliaia di stringhe
significa la quantità di oggetti creati per
solo operazioni di base in Ruby dove
tutto è un oggetto che può essere
travolgente e può davvero scambiare un
il sistema II sostiene che l’assegnazione è
davvero la radice di tutti i malvagi novantanove
percentuale dei problemi di prestazioni che
Diagnostico in Ruby e Jay Ruby o altro
i progetti si riducono quasi sempre a
allocazione hai davvero bisogno di mantenere un
occhio su quello e quindi è necessario monitorare
Log di GC e quant’altro è più specifico
caso qui jruby 1 punto 0 incluso a
funzione di default chiamata spazio oggetti
Lo spazio dell’oggetto rubino ti permette di camminare
ogni oggetto nell’heap e sai farlo
qualunque calcolo tu voglia su di loro
puoi andare a cercare tutti gli oggetti o
cercare tutte le stringhe o qualsiasi altra cosa
ordinarci di implementarlo sul
JVM potremmo usare le API di debug ma
allora dovremmo avere il debug di API
acceso tutto il tempo così inizialmente noi
implementato con una settimana separata
grafico un albero della settimana di tutti questi
oggetti diversi con un piccolo involucro
in modo da poter camminare nella nostra struttura
memoria e quello vedrebbe tutto il
oggetti che sono stati creati e
idealmente se il loro settimanale si riferiva a loro
dovrebbe andare via una volta che è stata spazzatura
raccolto un enorme successo di prestazioni da
che ogni oggetto che creiamo doveva
avere una seconda doppia in modo che saremo
in grado di ostacolare la passeggiata spaziale ed è per
una funzione utilizzata principalmente in gran parte
debug o esplorazione non utilizzati per
tipica esecuzione runtime del sistema
ha ucciso qualsiasi applicazione se la si utilizza
in fase di esecuzione anche sullo standard
l’implementazione è stata la nostra prima grande
boost eravamo come non possiamo farlo
scusa, Ruby, questo sarà
disabilitato di default anche su JVM
livello questo non sarà efficiente
per noi fare questo qui è il nostro in realtà
lui è il G per l’uscita GC
quando avevamo lo spazio oggetti abilitato e
nota che ognuno di questi era 20 28
più di queste linee stavamo spingendo
circa 1,8 giga al secondo attraverso la memoria
pipeline e sul mio sistema qui il max
la larghezza di banda che sto ottenendo è di circa 10 gig
e così è
prendendo quasi il venti per cento del
larghezza di banda della memoria del sistema per a
benchmark semplice in un’unica applicazione
ovviamente non andando a lavorare questo è
dopo aver deciso di spegnere l’oggetto
spazio di default pochissima evacuazione
succedendo qui non stiamo bruciando
oggetti quasi altrettanto veloci così ora ci sono
cose che sono difficili da risolvere
purtroppo chiusure e blocchi loro
è necessario mantenere e essere in grado di modificare
metodi circostanti circostanti
variabili e così via così quelli devono essere
in una struttura ad heap da qualche parte non c’è
modo per noi di leggere le chiamate e vedere
variabili locali in un metodo da a
i numeri di chiusura in JRuby sono ancora tutti
oggetti così ogni volta che fai un plus
uno creerà a oggetto come risultato
lavoreremo su alcuni
specializzazione sopra il livello JVM ma
idealmente vorremmo che la JVM fosse in grado di farlo
vedere questo e lo fa per noi spera che
venendo che sta venendo giù la linea e
allora c’è un sacco di codice Ruby
sembra che abbiamo questi
strutture dati transitorie che vengono utilizzate
fare alcune semplici operazioni molto
l’ api conveniente è qui che stiamo andando
prendi ognuno di questi oggetti che stiamo andando
chiamare i 2 su di loro per trasformarli in
le stringhe li ordinano e poi ottengono il primo
uno di questi ora purtroppo questo
sta per creare un gruppo di separato
strutture di dati internamente abbiamo il
risultato della mappa è la chiamata dei 2 che abbiamo
la nuova collezione che è un a
risultato ordinato e poi finalmente tiriamo
un valore fuori che idealmente saremmo in grado di fare
ottimizzare tutto ciò e basta
la logica che fa questo tipo di chiamata
e lo smistamento senza l’intermedio
oggetti e anche questo è molto difficile
fare sulla JVM adesso possiamo fare
è pigro ma non aiuta ancora a
tutto perché stiamo creando un pigro
l’enumeratore nel mezzo idealmente lì
non dovrebbero esserci oggetti creati qui altro
rispetto a ciò che la chiamata del 2 non può farlo
fallo subito alla JVM, quindi aiutaci
jbm bene, include una funzionalità
chiamato analisi di fuga che credo
è abilitato di default in Java 8
costruisce e l’idea generale qui è quella
se può vedere un oggetto non lascia mai a
pezzo di codice e non è mai visibile
attraverso i fili eliminerà il
assegnazione effettiva di quell’oggetto e
basta usare i dati che ci sono dentro e
quindi in modo ricorsivo se questi sono oggetti
e loro non lo hanno mai lasciato mai
ambito alla fine si arriva a solo
valori primitivi del registro che ottimizzano
il modo in cui tu
li voglio sfortunatamente questo non riesce a
lavoro per noi in quasi tutti i casi
principalmente perché l’analisi di fuga in
l’hot spot in questo momento non può funzionare con nessuno
ramo che intendo ognuno dei nostri
le chiamate hanno almeno un ramo per vederlo
abbiamo ancora il metodo giusto memorizzato nella cache
quindi ogni metodo interrompe l’ analisi di fuga
in JRuby nella forma molto semplice che è
sulla JVM speriamo che ci sia
miglioramenti sul modo in cui non lo so
qual è lo stato di ciò?
ci porta in un altro quadro che è
stato aiutandoci a negoziare un accordo con alcuni di
questi problemi di allocazione truffle così noi
Iniziamo guardiamo a cosa serve
in realtà costruire una lingua sulla JVM e
questo potrebbe essere un linguaggio dinamico di
linguaggio statico qualunque cosa tu voglia
gli stessi passi di base si applicano abbiamo la nostra JVM
linguaggio che abbiamo analizzato e possibilmente
trasformato in qualche forma bytecode forse noi
hai appena un interprete per quello
bene ma stiamo andando a prendere il caso
dove prendiamo un linguaggio JVM che compiliamo
in codice byte e poi lanciarlo a
la JVM per eseguire la JVM sta per lanciare
quello in un interprete bytecode per a
mentre sta andando a profilo ottimizza
lo getti nella JIT e poi
alla fine otteniamo il codice nativo che viene
dal retro ora il problema è tutto
quella magia nel mezzo delle cose interessanti
non avremmo alcun controllo su non c’è modo
per te per dare suggerimenti di compilazione alla JVM
non c’è modo per voi di modificarlo
runtime è possibile modificare alcuni dei
imposta alcune delle metriche che usa
alla riga di comando ma nessun modo per cambiare
in fase di runtime, quindi non abbiamo alcun controllo
di questo su questa sezione e questo è
dove diventa molto frustrante per noi noi
prova a trovare un modo per formare un codice Ruby adatto
per quello che sappiamo, la JVM può fare questo
non è quello che non è ciò che vogliamo, quindi cosa
se l’ottimizzatore jit JVM è effettivamente
scritto in Java e potremmo personalizzare
e chiama in due pezzi diversi e
e cambia il modo in cui ottimizza il nostro
lingua ed è qui che arriva il ringhio
ringhiare come progetto dai laboratori Oracle a
Cento per cento Java gyp essenzialmente te
può pensare a come hotspot portato a
Java e quindi in esecuzione sulla JVM
può ammettere l’assemblaggio o può farlo
in realtà emette l’hotspot ir che è il
l’hotspot di forma intermedia utilizza
genera il suo codice in modo che tu lo faccia fare a Grall
il suo hotspot di lavoro fa il suo lavoro e poi
finalmente si ottiene il codice nativo al
in basso ma puoi controllare direttamente tutto
questa generazione di codice e tu non hai
anche tu non devi usare JVM
bytecode che può essere a volte un brusco
strumento puoi dire molto più direttamente
voglio accedere a questa memoria che voglio
chiama questa funzione quindi guardiamo a questo
con la configurazione del grawl abbiamo la nostra JVM
linguaggio invece generiamo un ringhio
rappresentazione intermedia che usiamo
ringhia bytecode essenzialmente questo è a
va in ringhio ottimizzatore e di nuovo
questo è tutto il codice Java, quindi possiamo collegarlo
in questo processo e aggiungere il nostro
ottimizzazioni che il nostro linguaggio specifico
rendere le cose ottimizzate più come Ruby
dovrebbe ottimizzare e poi alla fine noi
prendi il nostro codice nativo dal retro ma
otteniamo molto più controllo sul
processo ora in vigore il problema qui è
che non tutti sono scrittori di compilatori
e questo è un livello molto basso molto ricco a
molto complicato sono dentro la rissa come
puoi immaginare che questo sia il collegamento
il mondo Java al reale nativo
operazioni operazioni a livello di CPU così
c’è bisogno di molta comprensione
per scrivere davvero crawl di cui abbiamo bisogno
qualcosa un po ‘meglio di questo
troppo il sogno è che progettiamo il
lingua abbiamo una certa quantità di passaggi
nel mezzo e ad un certo punto nel
futuro tutti amano il nostro linguaggio e
viaggiamo in tutto il mondo per parlare
è ciò che vogliamo veramente che sia
quantità minima di lavoro a posto
l’interprete e abbiamo finito tutti
puoi scrivere un interprete probabilmente
tutti qui hanno scritto qualcosa
di interprete per scopi generali
lingua o una lingua specifica in alcuni
punto nella loro vita se solo potessimo farlo
e poi avere il loro linguaggio come
veloce come tutto ciò che sarebbe bello e
è qui che il tartufo arriva nel tartufo
una struttura linguistica costruita sopra
Grall, tutto ciò che devi fare è creare
il tuo parser in modo da sapere qual è il tuo
il linguaggio sembra produrre un AST e
l’ AST viene contrassegnato con alcuni
annotazioni in tartufo per dire ecco un
il percorso intero qui è un lungo percorso qui
come stai qui è una struttura dati
solo andando essere usato temporaneamente e
basato sull’interprete e la via
che esegue il tartufo può effettivamente fare tutto
che lavoro in crescita per te e ottimizzare
è come se fosse scritto nello specifico
che i VM sono stati scritti in modo specifico
per la tua lingua è davvero incredibile
approccio molto simile
a quello che fanno in torta a torta se qualcuno
familiarità con quello che scrivi interprete
e basato su come l’interprete lo gestisce
può generare un jit per te davvero forte
quindi tutto ciò che dobbiamo davvero fare qui è
scrivi il nostro linguaggio jvm e crea a
AST al tartufo che entra in Grall
ottimizza giù e abbiamo nativo veloce
codice basato sulle nostre lingue
semantica attuale Chris Seaton sta lavorando
con i laboratori Oracle in questo momento su rubino
implementazione come parte di JRuby
il tartufo si chiama prima il tartufo rubino
lo chiamiamo jruby plus tartufo
ora perché immagino di aver parlato con
persone giuste siamo riusciti a convincere
Oracle per prendere questo rubino chiuso
implementazione che è stata incredibilmente veloce
e dare a noi sotto le nostre licenze sono
scioccato che in realtà è successo, ma lo è
parte di JRuby ora e sarà
rilasciato con JRuby 9000 e quanto
meglio è che questo è un grafico sul lontano
lasciato difficile leggere il loro JRuby 17 con
invocare la dinamica che, come ho dimostrato, è quattro
o cinque volte più veloce del mare
implementazione di Ruby e sulla destra
l’estrema destra è il tartufo Ruby
il tartufo in alcuni casi fino a 20
tempi più veloci di JRuby più invocano
dinamico e questo è il novanta per cento di
questo miglioramento è perché possono ottenere
sbarazzarsi di tutti quegli oggetti extra perché
vede attraverso allocazioni molto meglio
rispetto alla JVM fa e siamo in grado di dare il
suggerisce che è necessario pulirli
oggetti via così ho citato il tartufo rubino
fa parte di JRuby ora e lo sarà
pubblicato in JRuby 9000 ce ne sono molti
altre lingue nelle opere e sono
in realtà davvero facile da costruire linguaggi
in cima al tartufo solo il caso banale
un AST un interprete che usa solo
oggetto che comunque ottimizzerà
abbastanza bene, allora puoi buttare il tuo
specializzazioni come ne hai bisogno
potrebbe essere diventato parte di OpenJDK è
possibilità in futuro non lo è
probabile che accada in Java 9 dato il
periodo di tempo questo è l’ altro è successo
questo è che sta forzando anche il
gente hotspot a pensare alle priorità
spero che i ragazzi del hotspot si renderanno conto
che conosci l’analisi di fuga con dentro
con il futuro non chiaro per quelli
gli oggetti sono qualcosa di cui abbiamo effettivamente bisogno
bisogno di essere in grado di fare analisi di fuga
anche se non possiamo vedere attraverso tutto il
codice va bene così avvolto qui così che cosa
abbiamo imparato, intendo
Non posso davvero dire quello che hai imparato
spero che tu abbia ottenuto qualcosa da
questo ciò che ho imparato nel corso di un decennio di
lavorare su JRuby è che c’è davvero
nulla di ciò che è impossibile sulla JVM se
siamo disposti a girarci attorno a
un po ‘e l’ho anche imparato
le persone che lavorano sulla JVM e lavorano
sul JDK sono estremamente interessati
evitando quei workaround e facendolo
possibile per noi utilizzare la JVM come
è e ha tutto questo tutte queste caratteristiche
vieni senza librerie extra
lavoro extra quindi spero che sia questo il
il futuro assomiglierà alla JVM
ha un problema ma possiamo risolverli
e nelle persone provvisorie come noi, quindi, aiutate
ti giri intorno a loro ora una cosa io
voglio l’ultima cosa che dirò qui
questo è tutto open source che puoi davvero
aiutare con questo tartufo grasso tutto il jnr
roba ovviamente JRuby JRuby plus tartufo
la JVM stessa con quella con un open
fonte con un po ‘ di conoscenza
nulla è impossibile sulla piattaforma
e possiamo rendere realtà tutta questa roba
per il futuro, grazie
preliminari I Charles nutter Io lavoro
attualmente a Red Hat vari open-source
cose ma principalmente sul linguaggio JRDM JDM
roba che rende più facile per le nuove lingue
per avvicinarsi alla piattaforma espandendo il
piattaforma per mettere una lingua madre e così
su così la struttura di questo discorso è gentile
di essere una storia una commedia in tre
agisce parlando del lavoro che stiamo facendo
su decadi di pastelli giovani e magri ora
le sfide che abbiamo dovuto affrontare
trattare con la JVM e alcuni dei suoi
limitazioni e come JVM e Jari
si stanno evolvendo insieme per farlo
più facile in futuro, quindi parleremo a
è un po ‘il primo cavallo jruby
fondamentalmente solo rubino sui prodotti JVM
è stato intorno per un po ‘ e nel 2001
era il primo impegno con JRuby
in pratica ho appena iniziato a implementare il
parser Penso che per lo più stavano guardando
a farlo per utensili e poi deciso
hey abbiamo un parser che possiamo interferire
possiamo iniziare a costruire un vero potrebbe essere
correre il tempo in cima alla giuria, sì, ma per
circa cinque anni o giù di lì non ha davvero
muoversi molto velocemente non potrebbe funzionare di più
Il codice rubino era basato su un vecchio
versione di Ruby la singolarità delle rotaie
è successo all’interno della comunità di Ruby
è stato durante quel periodo e così in giro
2005-2006 Sono stato coinvolto nel progetto
e abbiamo pensato bene perché non può essere è
c’è qualche ragione per cui non potremmo davvero
avere Jay Ruby sui binari Rails Ranji
correre sul jamie che sto prendendo
vantaggio delle librerie JVM con JDM così
e nel 2006 siamo stati in grado di farlo
così ci siamo presentati allo show di javaone in esecuzione
in cima alla Serie B in cima al GBM
c’è un pacco primitivo molto presto insieme
forma ma fu presto un inizio
questo è quello che stiamo facendo questo
e ora stiamo lavorando su JRuby 9000
è in realtà la nona major release di
JRuby che abbiamo avuto dal 10 così quando io
era il primo e ora siamo a
jruby che è più veloce di ordini di grandezza
rispetto a quello del 2006 che stiamo guardando
gestendo molto più binari di scorrimento radhika
applicazioni in produzione per reale
i clienti piacciono come è
SoundCloud su JRuby come parti chiave di
i loro membri hanno ragione è molto lavoro
per arrivare a questo punto questo è quello che ho corso
la scorsa notte solo per vedere dove il nostro maestro
ramo è che questo è 29.000 commit
che stanno per finire in JRuby
gli anni e questo non conta tutto
lavoro che abbiamo fatto sui rami di manutenzione
per ognuna di queste uscite anche in modo
c’è ovviamente molto lavoro, ma perché
potremmo soffrire con il
sfide di portare un linguaggio simile
Ruby to the JVM per 9 anni 10 anni
ma la linea di fondo è che eravamo tutti
Ragazzi Java conosci bene la JVM
i suoi toni della pelle in e out o a
almeno pensavamo di fare tutte le cose
e outs e si adatta proprio al nostro modo
voleva costruire Ruby vuole essere in grado di
concentrarsi sull’implementazione della funzionalità
di Ruby il linguaggio delle classi principali di Ruby
e non dobbiamo costruirci la nostra merda
il nostro GC tutti quegli altri pezzi che
la JVM ci offre gratuitamente così la JVM è
tipo di questa scatola nera magica che noi
possiamo semplicemente buttare le nostre cose per lanciare le nostre
codice a lanciare un interprete rubino fare
generazione di piccoli byte di codice, qualunque sia e
eseguirà il nostro codice alla grande e
tutto scorre veloce tranne mio fratello
e questo è ciò che la sfida del
parte interessante che lavora sul traditore
nove anni è in realtà quando JDM
non posso fare quello che dovevamo fare dopo
passo come attraversiamo quella linea di
impossibile il jvm non può farlo più
la gente si arrende, non abbiamo un
opzione in modo da trovare nuovi modi per farlo
siamo lasciati con questa sfida che vogliamo
far funzionare bene Java e Ruby
insieme e non solo funzionano bene insieme
come linguaggio JDM ma funziona bene come a
implementazione ruby così gli utenti di Ruby ottengono
l’esperienza che si aspettano da
in esecuzione JRuby che esegue Ruby in cima al
JVM quindi parleremo di tre
aree specifiche qui che sono state
sfide per noi e come è la JVM
evolvendosi per renderlo un po ‘più facile in
il futuro per gente come te e per noi
per continuare a lavorare qui così prima di tutto
parleremo solo di più
concetto primitivo di base in Ruby dove
generalmente tutte le prestazioni sono perse
tutte quelle chiamate di metodo che facciamo in a
tipica applicazione Ruby qui è una metrica
L’Iran è davvero veloce solo stamattina
per vedere quante chiamate semplici e questo è
Mi piace solo chiamare il metodo Foo o
chiamare un punto foo su qualche oggetto così
ci sono altri tipi di chiamate che fanno super
in vacanza e quant’altro non lo sono
elencato qui ma sai per fare
cose come gem installazione di binari e tutto
delle dipendenze di cui ha bisogno
315.000 chiamate che vengono fatte chiamate da Ruby
facendo generare un nuovo binario
applicazione 606 mila e questo è
generando l’app più l’installazione
dipendenze aggiuntive necessarie per a
esecuzione dell’applicazione ho fatto un po ‘veloce
applicazione cruda e appena finito
tutte e quattro le operazioni circa 16.000 da fare
tutte e quattro le operazioni crude, così sei tu
sapere approssimativamente sarà come un 4000
per richiesta solo per fare un veramente semplice
visualizzazione di alcuni dati quindi dobbiamo fare
questo metodo chiama velocemente e il problema
abbiamo sempre avuto in JRuby abbiamo un
semplice esempio qui foo calling bar
chiamando Baz e su Java cinque e sei
quello che stavamo costruendo jaber oltre la maggior parte
della maggior parte della sua vita che abbiamo
in mezzo questa logica di chiamata in più
questi dobbiamo andare a cercare il
tipo di metodo che dobbiamo accertarci di avere
ho la stessa classe in mano che noi
attesi l’ultima volta che dobbiamo farlo
e sfortunatamente la JVM è pessima
ottimizzando attraverso un pezzo generico di
codice e buy generic voglio dire che hai
un sacco di diversi percorsi di chiamata che sono
tutto questo attraverso questo stesso pezzo di
codice che diventa un nero di ottimizzazione
buco niente può superare questo
serie di chiamate che nulla può attraversare
quella logica chiamata intermedia che noi
hanno e così la maggior parte della grande JVM
ottimizzazioni che speriamo di poter uscire
costruire Ruby sulla JVM in realtà non lo è
materializzarsi e questo è dove invocare
dinamica viene in quante persone sono
familiarità con invocare la dinamica almeno su
la superficie va bene così tanti di voi
sentito almeno un po ‘su di esso
passeremo attraverso un po ‘di storia qui
di fatto gli autori della JVM ne hanno parlato
avere altri linguaggi non Java su
JVM e almeno non lo fece
escludere questa possibilità in futuro
e per questo molto e molto
gente di lingue prese di mira sulla JVM
alcuni dei primi erano in te
so 96 97 poco dopo Java in realtà
è stato rilasciato per la prima volta
ovvii più noti come Jai
thon erano in realtà prima del 2000 a secco ora
pensavo fosse prima del 2000 o agli inizi degli anni 2000 così
molto prima che la JVM fosse pari
considerato come un vm multilingue
la gente stava costruendo le lingue sopra
il problema è che nonostante la JVM
era sempre previsto che potesse funzionare
altri linguaggi non è mai stato progettato
per molte di queste altre lingue lì
sono trucchi come la spedizione dinamica
non ha funzionato molto bene con un staticamente
vm digitato ci sono ottimizzazioni
lingue dinamiche o altri nuovi tipi di
le lingue avrebbero bisogno di diversi tipi di
chiamate i modelli quindi siamo bloccati in questo
questo tipo di bolla questo mondo di JVM
opcode che è praticamente tutto quello che possiamo
lavorare con e e ci sono tre principali
aree di operazioni che è possibile eseguire
a livello JVM puoi effettuare chiamate
invocazione a cui è possibile accedere i campi
gli oggetti sono impostati e ottengono così i dati
lì per altri thread per vedere un array
accedere di nuovo a qualcosa di simile
mettere i dati in una struttura di dati
questo sarà passato in giro e
usati dal mondo sono belli
molte le uniche operazioni che lo faranno
potenzialmente hanno alcuni effetti collaterali alcuni
effetto collaterale visibile al di fuori di quello
operazione e poi c’è tutto questo
altro controllo di flusso e stack
manipolazione nuova
Operazioni di Eric che in realtà non hanno
qualsiasi effetto collaterale del loro tipo di funzionale
operazioni a livello di jvm ma loro
servono per spostare i dati nei posti giusti
per queste operazioni chiave come
invocazione e accesso ai dati e se
hai intenzione di costruire una lingua in cima
della JVM devi praticamente restare
dentro qui devi colorare dentro
queste linee e questo è dove invocare
la dinamica è arrivata davvero davvero
consente alla piattaforma di fare molto di più
di quanto non facesse prima che questo venga dalla JVM
questa è la citazione che ho citato in
il futuro considereremo limitato
estensioni alla Java Virtual Machine
per fornire un supporto migliore per gli altri
le lingue sono tornate nel 1997 a parlare
circa la possibilità di aggiungere
funzionalità aggiuntive solo per supportare
altri linguaggi non JVM non Java e
quello ci conduce il jsr 292 che era il
java 7 jsr per invocare il richiamo dinamico
la dinamica è fondamentalmente un utente definibile
bytecode quindi abbiamo i nostri invocati e
abbiamo i nostri accessi sul campo questo è un
codice byte speciale che programmiamo
internamente la JVM ci chiede cosa fare
piuttosto quando si imbatte in questo bytecode
di avere un insieme predeterminato di
operazioni che conosce già anche
viene fornito con una serie di puntatori veloci del metodo
chiamato metodo maniglie hai visto il
java.lang invoca il pacchetto di questi handle
ora stanno ottenendo il punto in cui sono
molto più veloce di chiamare
riflessione possono ottimizzare molto meglio
la JVM può effettivamente ottimizzare
quelle maniglie attraverso quei puntatori come
se fosse una chiamata diretta è molto
molto responsabilizzare modo phul per iniziare il cablaggio
cose insieme solo con semplicità
maniglie riflettenti che ottimizzano bene
e poi come materiale per il caching e
convalida l’idea generale era che noi
volevo creare un bytecode che terminasse
tutti i codici byte che potremmo avere
questa un’opportunità per fare un cambiamento
la specifica JVM che è davvero molto difficile
per fare abbiamo bisogno di farlo bene e così via
è stato reso molto personalizzabile molto
configurabile ed è in realtà
iniziando a suonare molto bene per
lingue diverse parlano di pochi
gli utenti ovviamente esistevano JRuby e Groovy
prima invochiamo dinamici e siamo cresciuti
in esso jruby è stato il primo ad adottare
invocando dinamico abbiamo effettivamente iniziato a usare
prima che fosse una qualsiasi versione interiore
prima ancora che fosse finalizzato come API
solo per provarlo
e aiutami a provare a tirare le gomme
credi che Groovy abbia una modalità che puoi trasformare
adesso che utilizza invocare dinamica a grande
effettuare nuove implementazioni e Diane
Diane Jas e nas horn costruito sopra
invoca dinamicamente fin dall’inizio
e così stanno ricevendo il
vantaggio di averlo dal giorno
uno e progettando l’intero sistema
intorno ad esso questo è un fatto poco conosciuto
quel Java 8 lambda e il sacco del
Anche le funzionalità di Java 9 stanno crescendo
di invocare dinamicamente tutti questi
posti di blocco che hanno mantenuto la JVM ragazzi
jdk ragazzi dall’aggiunta di funzionalità a java
ora iniziamo a essere spazzati via anche noi
possibile aggiungere funzionalità java basate su invoke
dinamico che era impossibile da fare
prima o almeno difficile da fare
roba efficacemente molto eccitante e lo farò
parla un po ‘di più di tutti quelli
lavoro più tardi quindi ora cosa è esattamente
nemici invocati in realtà sanno come
invoca opere dinamiche non impressionanti
questo significa che tutti avrebbero avuto
qualcosa di nuovo da questo va bene così invoca
abbiamo le nostre quattro invocazioni di base
tipi statici per te conoscono i metodi statici
abbastanza semplice virtuale quando al
compilare il tempo si conosce la classe concreta
che stai chiamando contro l’interfaccia
quando chiami contro un’interfaccia
non sai quale sia la classe concreta
JVM deve scoprirlo più tardi e
quindi costruttore e super chiama quale
si chiamano inviti speciali e questi
riassumere in quattro codici byte diversi
qui con alcuni dei confusi
pasticcio interno che rappresenta il metodo
in realtà chiameranno i loro e
se prendiamo queste quattro operazioni e
scomporli in ciò che effettivamente
succede a livello JVM a cui inizierai
vedi che questa è in gran parte la stessa cosa
per ognuno di loro c’è minore
cambia il modo in cui osserva i metodi come
guardie di ottimizzazione della cache che saranno presenti
posto in alcuni casi ma non in altri
sarebbe bello se potessimo prenderli
pezzi di quei singoli pezzi fuori
ognuno di questi invoca e ricama
insieme però vogliamo fare il nostro caching
proprio modo do metodo di guardare in alto la nostra strada
ed è qui che entra in gioco la dinamica
tutto il richiamo dinamico fa è richiamare a
il tuo codice hai impostato il caching del sito di chiamata
vai a cercare metodi in cui vai in piedi
I valori in memoria e poi danno che
torna alla JVM e dì ecco come te
fai questa operazione ecco come questo invoca
dinamico
dovrebbe funzionare lo fa da allora
con queste maniglie del metodo ottimizzate
con tutta la logica di caching che hai
ottenuto e idealmente lo ottimizza come se fosse
era diretto attraverso la chiamata statica che è
quello che stiamo cercando un po ‘di più
graficamente abbiamo ottenuto questo tipo di a
metafora del centralino qui così su
all’inizio chiamiamo e questo è un
invoca dinamicamente che abbiamo bisogno di qualcosa
là fuori qualche pezzo di dati che dobbiamo
ottenere un metodo che abbiamo bisogno di chiamare o
invoca inizia dinamiche proprio lì
va alla JVM della JVM, quindi guarderemo
per il nostro metodo di bootstrap lo farà
richiamare il nostro codice nel codice utente
dal metodo bootstrap a livello JVM
trova il giusto filo di destinazione tutto
e usa maniglie del metodo per farlo
questo è il tipo di cavi che si collegano qui
una chiamata a un altro le maniglie del metodo
poi finirà per risolverlo
metodo target o Target Field o alcuni
pezzo di dati e prima di Java 7 lo sai
è stato fatto un simile processo per
ogni chiamata in Ruby ogni jruby
chiama ma dovevamo farlo ogni volta che avremmo
tornare indietro attraverso questo processo
forse controllare una cache per fare in modo che la chiamata lo guardi
controllare che il denaro faccia call e così via
più e più volte e ha perso molto
tempo e poi ancora la JVM può ottimizzare
attraverso ciò la magia con invocazione
dinamico è quello dopo questo primo
processo di bootstrap tutto questo
scompare e ricevi chiamate dirette da
che invocano la dinamica nel metodo di destinazione
da quello in poi e quello è il vero
la magia accade così guardi JRuby
Java 7 quella logica intermedia
scompare o almeno fino alla JVM
è preoccupato che scompaia lo colleghiamo
in un certo senso la JVM comprende un po ‘
meglio arriviamo direttamente attraverso i call pad
per quanto riguarda il naso JVM va direttamente
dal cibo un bar a baz e tutti quelli
grandi ottimizzazioni che usciamo di
la JVM come inlining in realtà accade
e vediamo che questo succede a Ruby in linea
in linea con Ruby Java in linea con Ruby
viceversa, tutte queste cose in realtà
funziona e funziona davvero bene
le JVM attuali richiamano quindi la dinamica in JRuby
ovviamente lo stiamo usando per metodo
la spedizione è piuttosto semplice la nostra logica
guarda il metodo che abbiamo in contanti
dice quale era l’ ultimo tipo e se
esso può
partite invalidate se la classe cambia
o se arriva qualche nuovo tipo e noi
potrebbe incatenarli, quindi abbiamo due o
tre tipi che sono disponibili tre o
due o tre tipi di due o tre
metodi di pagamento li usiamo anche per i luoghi
come costante guardare in costanti di Ruby
sono definiti pigramente possono anche essere
modificato forzatamente in genere non lo è
fatto ma può essere fatto così abbiamo
logica di caching simile usciamo e guardiamo
la costante abbiamo un cache che
raramente è rotto raramente deve essere
invalidata la JVM quindi può vedere che come
una vera costante anche se in
Ruby può cambiare in qualsiasi momento e così
può ottimizzarlo come se fosse una costante
scritto nel codice direttamente tutto a posto
ora quanto bene funziona per noi questo è
un grafico che mostra in pratica quanto
più veloce siamo di Ruby 1.9 il
numeri di prestazione per 2 punto 0 2 2.2
non sono molto diversi qui
questi sono questo j di riferimento di Ruby
penso che jruby 1.7 o giù di lì su un Java
cinque o sei dove abbiamo questa logica
impedendo le ottimizzazioni da
accadendo e questo è quello che sembra
con invocare la dinamica solo cambiando
queste chiamate da utilizzare invocano dinamico e
cambiando nient’altro nel runtime noi
ottenere questo miglioramento molto significativo
miglioramento sul rosso nero lì così
molto però che volevamo davvero
esplorare questo un po ‘oltre così questo è
un punto di riferimento per costruire un grande rosso
albero nero che lo attraversa un po ‘ diverso
modi di cancellare gli elementi e poi sai
scaricarlo e riprovare
particolare benchmark Ruby 20 e un puro
l’implementazione rubino del nero rosso ha preso
circa 2 2,5 secondi o così e questo è
questo è un motivo riutilizzabile per cui le persone a
il mondo Ruby si girerà per vedere
le estensioni hanno un algoritmo
una cosa come questa è una struttura di dati pesante
pesantemente colpito struttura di dati che
bisogno di fare velocemente e così lo scrivono
e vedi invece c’è solo così tanto tu
può fare per ottenere lo standard
implementazione a Ruby per correre più velocemente vedere
è il solito go-to e questo aiuta
questo lo riduce di circa la metà a
secondo per ogni o ogni iterazione di
questo particolare punto di riferimento e ora questo
è la parte cool JRuby con lo stesso
implementazione di rubino puro che esegue il
stesso punto di riferimento siamo in realtà più veloci
di Ruby con una estensione di visualizzazione e noi siamo
vedendo questo di più in
più che piuttosto che dover andare a
mare per ottenere prestazioni dal codice Ruby
le persone possono semplicemente spostarlo su JRuby e ottenere
lo stesso tipo di spinta va bene così indietro
agli utenti che parlano un po ‘di
come stanno usando il corno dei neigh I
menzionato in precedenza costruito su invoke
dinamico fin dal primo istante
stanno facendo molto più avanzato
compilatore lavoro avanzato ottimizzazione loro
speculativamente dire va bene questo è probabilmente
sarà un metodo che usa intz o
polmoni e quindi usano invocare dinamici
come spirito come una valvola di sfogo quando
scopre che non lo stai facendo
l’algoritmo contro di esso balla via
invocare la dinamica genera del nuovo codice
e poi entra in quella versione modificata
roba molto bella guardando le prestazioni
iniziando a essere paragonabile alla v8 su a
molti benchmark solo un po ‘
di magia extra su entrambi
dinamico e là sono molto
interessati a trasformare il lavoro che hanno
fatto su nasrin in una lingua generale
quadro così tutti quelli che vogliono usare
invoca dinamici un tipo di linguaggio dinamico
specializzazione che ottimizza numerics e
non potremo collegarci a questo
e avere la stessa cosa così è davvero
fresco ho menzionato quel lambda in java 8
usa invoke dynamic se funziona molto
simile alle classi interne ma pigramente
genera quella classe che non ha bisogno di
avere quello sul comando sul
file system non ha bisogno di essere nel
jar non hai bisogno di questi dollari zero
dollaro uno e tutto ciò che invoca dinamici
è usato fondamentalmente per generarlo sul
vola se arrivi davvero a quel punto
e questo è un esempio di un bytecode così
abbiamo un tipo che stiamo facendo con a
semplice intero confronta che è il nostro che è
il nostro lambda là invoca la dinamica va
fuori e genera quel wrapping di classe
tutto questo codice che viene utilizzato per
le chiamate di lunghezza della stringa effettiva e il
confronta proprio qui e poi quella classe
viene restituito e inserito direttamente nel
invoca la dinamica in modo che non sia mai stata
essere generato di nuovo è come se quello
virtuale quella classe interiore anonima
sempre esistito, ma non si deve
averlo sulla riga di comando non lo fai
devo avere quel qualcosa in più
il fastidio di trattare con i file questo è
gli usi di invoke dynamic diventano più interessanti
ogni anno non ci sarà nessun java nove
sta andando a fare la specializzazione generica
reificazione per le collezioni che farai
avere un ArrayList di int che opera
come ti aspetti che sia una delle chiavi
caratteristiche che sta arrivando ed è
costruito molto pesantemente su invoke
dinamico di nuovo nel punto in cui tu
hai bisogno di un ArrayList di int hai bisogno di a
collezione primitiva che non siamo mai stati
in grado di avere prima senza specializzato
le biblioteche andranno via chiedono il dentro
invoca chiamate dinamiche in alcuni livelli JDK
codice genera ciò che un ArrayList di int
sarebbe simile e quindi collegarlo a destra
di nuovo nell’invoca dinamica, così possiamo
in realtà hanno queste collezioni reificate
senza generarli tutti in anticipo
tempo senza avere un evento ArrayList
e una ArrayList di char sarà tutto a posto
funziona e si collegherà tutti usando invoke
dinamico sotto le coperte molto cool e
hanno dei prototipi funzionanti di questo
già se vuoi provare il
il progetto valhalla branch di OpenJDK va bene
quindi penso che il metodo chiama a
prestazioni a cui ricevere le chiamate al metodo Ruby
ottimizzare il modo in cui vogliamo è una specie di a
problema risolto a questo punto c’è
ovviamente il tipo di specializzazione
dobbiamo ancora lavorare nella prossima area
che ci siamo davvero imbattuti e corriamo ancora
fino ad oggi è che Ruby è in gran parte
un wrapper su UNIX o un wrapper
in giro per POSIX vedere alcuni
esempi di questo è l’aria no
classe e tutte le classi definite
sotto per generare errori e
questi sono fondamentalmente solo tutta l’aria
sa che vedresti cose a livello del mare
che tu riconosceresti se lo sei
costruendo qualsiasi applicazione vedi un altro
esempio la libreria etsy in ruby ha un
numero di metodi per accedere a
file di password su un gruppo di sistemi unix
informazioni utente informazioni e così via
e non si sono nemmeno presi la briga di farlo
questi nomi carini sono solo il mare
funzioni raccolte direttamente nel rubino
quindi se vogliamo implementarlo e avere
tutto il codice rubino là fuori funziona di cui abbiamo bisogno
essere in grado di fare queste cose che dobbiamo
avere a disposizione queste operazioni a
il livello JVM come lo facciamo e
ecco dove avere un nativo migliore
Interopare alla JVM entra così guardiamo
nel mondo JVM qui abbiamo ottenuto il nostro bello
area felice quaternizzata dove non c’è
il codice nativo è scritto una volta eseguito ovunque
giusto e poi abbiamo questo nativo
mondo in cui abbiamo ottenuto tutti questi cool
biblioteca
è che abbiamo bisogno di chiamare abbiamo
caratteristiche del sistema operativo di cui abbiamo bisogno
per accedere alle nuove librerie nuove grafiche
sottosistemi e non c’è davvero niente di buono
modo di fare questo ora come parte del
JVM standard è una grande citazione di John
Rose se i programmatori non Java ne trovano
libreria utile e facile accedervi
dovrebbe essere allo stesso modo accessibile a Java
programmatori e questo non è stato il
filosofia della piattaforma Java per la maggior parte
della sua vita la filosofia di
la piattaforma Java è generalmente stata se
Alcuni programmatori di John su Java ne trovano
utilizzo della biblioteca facile e facile da usare
accesso dovremmo portarlo così a Java
che possiamo avere su Java e poi
quello che tutti quelli che hanno fatto un porto o un
la copia di un progetto sa che lo sei
sta per uscire dalla sincronizzazione che stai per
devono mantenere due versioni differenti
è un po ‘stupido che non possiamo solo
chiamare in alcune di queste librerie
e li uso direttamente a destra, penso
sembra stupido quindi l’esempio che voglio andare
attraverso qui è cosa se noi solo noi solo
voglio prendere la fossa per la corrente
processo abbiamo un sistema di monitoraggio
o alcuni tipi di DevOps amministrativi
cosa che ha bisogno della fossa per poterla chiudere
giù invia segnali qualunque cosa non sia
possibile fare su JVM proprio ora tu
non è nemmeno possibile ottenere l’ID del processo corrente
l’unico modo che puoi ottenere è
se hai intenzione di scrivere un codice C
te stesso e in fondo scrivi un
estensione per JVM quindi per jni è
qualcuno ha fatto Jay e io ok ci sono a
poche persone che provo per te e Jay
abbiamo il nostro codice utente al primo posto
deve fare qualche chiamata ci sarà a
jni endpoint nativo sul lato Java
un codice C che rappresenta ciò
potrebbe quella che la logica nativa è supposta
da fare e poi alla fine arriviamo al
biblioteca di destinazione e ora se si avvia
guardando quello che Jay e io facciamo nel suo genere
di ingannevolmente semplice qui oh noi solo
bastone nativo lì e abbiamo a
la chiamata nativa è improvvisamente come una magia
giù chiamate nel codice nativo e noi siamo
buono per andare ma poi c’è tutto questo
cose che devono essere fatte dietro il
scene che non ha nulla a che fare con il
Il codice Java che hai appena scritto è necessario
genera le intestazioni jni per tutte le tue
endpoint nativi con alcuni piacevolmente
nome della funzione straziata così la JVM può
Trovalo
è necessario implementarlo per questo caso
è ovviamente abbastanza semplice essere pagato
ritorna in un int che si adatta perfettamente
benissimo nel j lungo potremmo fare un po ‘
fondere la logica per assicurarsi che si adatti bene
o firmato a destra per una particolare chiamata
ma ma questo non è troppo terribile così
abbiamo il nostro header abbiamo il nostro file C.
ora dobbiamo costruirlo e questo è
dove cado perché non lo so
come si fa a fare una schifezza che non so
quali librerie dovrei collegare
su e su base per piattaforma come sono
dovrebbe fare questo diverso compilatore
fai le cose in modi diversi e poi tu
devi pensare agli utenti o tu sei
andando a dover costruire questo prima
tempo per tutte le piattaforme o gli utenti sono
andando a costruirlo ogni volta che loro
c’è bisogno di usarlo e questo fa schifo per loro
Anche così si sta andando ad avere per avere make
file che devi avere altro
roba che non fa parte del mondo Java
c’è che deve esserci una migliore
modo di fare questo tutto quello che voglio è un dannato ragazzo
giusto così che era lì che è Java
il runtime nativo entra così necessario per Java
di runtime è una java api per la chiamata
codice nativo abbiamo una sorta di strati
runtime un mucchio di utilità diversa
librerie che puoi usare se alcune di
potresti aver usato j o visto java nativo
accesso in giro molto simile che abbiamo preso
alcuni li portiamo ancora un po ‘ oltre
è essenzialmente una funzione straniera
interfaccia con cui hai mai avuto a che fare
qualsiasi cosa nel mondo del mare che usa ffi
è un’interfaccia di funzione straniera per
la JVM intendo che c’è l’organizzazione
su github dove teniamo tutti i progetti
jnr quindi cosa possiamo fare con jnr
è andare da questa situazione in cui abbiamo
per implementare tutto in viola qui
incluse cose che non sono in Java e
non ha nulla a che fare con ciò che effettivamente
voglio fare a questo abbiamo alcuni
codice utente che definisce un endpoint in
alcune librerie C dicono che questa è la libreria
ecco la funzione qui è il
i parametri e il valore di ritorno me lo consentono
chiama la cosa distrutta come jnr stub
sotto quello capisce come collegare
che nei tipi Java si chiama J e I
fa effettivamente l’invocazione e poi
tutta quella logica è pre-costruita per tutti
piattaforma in modo che possiamo semplicemente spedire un semplice
libreria più le nostre due o tre righe di
Codice Java quindi questo è quello che ottenere pit
in realtà sembra che in jnr definiamo un
interfaccia che ha approssimativamente la funzione
prototipo della funzione c che vogliamo
chiamata
diciamo al caricatore della libreria di creare un
versione un’implementazione di questo
interfaccia basata sulla funzione in arrivo
fuori da una libreria C e poi abbiamo
in mano un oggetto che possiamo chiamare quelli
vedere le funzioni direttamente molto meglio
rispetto alla versione J e I penso che io
menzionato il tempo di esecuzione a strati che
abbiamo intenzione di passare attraverso a
alcuni di questi JN sono una sorta di soste al
punto che ho appena mostrato puoi chiamare
funzioni che puoi definire funzione
endpoint ma non ce ne sono molti
codice di supporto disponibile per te per primo
tutto ciò che voglio menzionare è la piattaforma
non voglio dover ricostruire questo ogni
ora andiamo ad un nuovo sistema, quindi spediamo
con supporto per tutte queste piattaforme
piccolo piccolo stub nativo che è nel
barattolo si svuota se necessario e poi
carica dinamicamente se qualcuno ha un
piattaforma che non è lì mi piacerebbe
ascoltarlo, abbiamo sì, openvms è io
pensa di lavorare ora per tutti voi openvms
utenti là fuori che vogliono davvero saltare
su quel Linux Linux mainframe as400 z
abbiamo tutto il supporto per il materiale
ci sono certamente altre piattaforme che
sono arrivati ma è molto facile per noi
per costruire un piccolo mozzicone su qualsiasi piattaforma
roba nella nostra costruzione ed è bello
vai così Jay NRF se sono fondamentalmente il codice
che ti ho mostrato che è il jna a
equivalente che è la libreria di base per
per il cablaggio di alcune librerie C e di nuovo
c’è quell’esempio abbastanza facile da fare
e ovviamente una volta che hai le basi
impianto idraulico cablato è facile aggiungere nuovi
funziona a questo come vengono ma
ovviamente molte di queste cose sono
operazioni standard che sono di tutti
andando ad avere bisogno di ottenere una fossa di cui non abbiamo bisogno
per far scrivere a tutti nel mondo
la loro interfaccia personale e il loro
la propria logica di carico per ottenere il recupero
operazione disponibile così abbiamo costruito il nostro
primo livello in cima a j NR j jnr posix
che in pratica pre collega un intero gruppo
delle funzioni POSIX più comuni
probabilmente gli utenti avranno bisogno di questo
un piccolo frammento di quelli che sono
cose definite come chmod chn che tu
ancora non può fare altrettanto con le API di JVM
la forcella è lì e non funziona molto
bene puoi immaginare che tipo di
fare cose orribili che una JVM farebbe
sai cose come Geez
Thread di GC che non arrivano per il
cavalcare un tipo di problema, cos’altro è buono
la nostra chiamata pagata è lì che uccide
le effettive operazioni del segnale stanno diventando crude
variabili ambientali e impostazione da parte nostra
variabili nell’ambiente attuale
giù in fondo difficile vedere qui
abbiamo spawn POSIX che è come il
kit di strumenti definitivo per la deposizione delle uova
sottoprocessi e incidentalmente c’è
un pacchetto di Jan il nostro processo che sono
lavorando su di esso che salta tutto il
processo costruttore senza senso e va
direttamente a una chiamata di spawn in modo da ottenere
veri e propri canali fuori da quel processo
puoi selezionare puoi effettivamente
controllare in modo interattivo un sottoprocesso
praticamente impossibile da fare attraverso il
JV jdk process api’s quindi ecco qual è il nostro
ottenere pit sembra che ora andiamo a posix
fabbrica creiamo una nuova istanza che puoi
crea il tuo gestore personale, puoi fare aria
il naso alza un’eccezione piuttosto che fare a
restituire valore alle cose lungo quelle linee
se vuoi le caratteristiche native a
essere abilitato o utilizzare solo il puro java
emulazione POSIX API e poi alla
in fondo una volta che hai in mano te
basta fare la chiamata così abbiamo POSIX noi
ha ottenuto un’istanza POSIX per ogni JRuby
istanza e questo è dove tutti i nostri
la logica va a chiamare il nativo
funziona così ora abbiamo bisogno di costruire un
un po ‘di più in cima a questo, quindi cosa?
se facciamo una chiamata aperta di livello c per aprire a
file o una chiamata socket per creare un socket
a livello nativo e abbiamo appena ottenuto un
descrittore di file in mano e non molto
possiamo fare possiamo tornare indietro e fare una lettura
chiama al livello del mare e continua ad uscire
al lato natio ogni volta che voglio
fai una lettura ma poi ottieni cose come
seleziona quali sono più complicati
sono diversi tra le piattaforme
le API non corrispondono abbastanza a quelle basse
controllo di livello su questi file
descrittori che non puoi davvero fare a
il livello JVM in modo che sia lì
prendi e NX ioj nel nostro enx i / o esteso
cross-platform nativo I oh è
praticamente niño compatibile quindi si adatta
in tutto il resto usiamo i canali
e flussi nella JVM, ma lo fa
chiamate native per ogni operazione attraverso
jnr fa una lettura nativa
kq nativo o sondaggio e per la selezione
logica fa le cose giuste su tutto
piattaforme diverse ma puoi semplicemente
passare in un descrittore di file nativo
una cosa che è davvero divertente da fare
questo puoi prenderlo tu puoi prenderlo
e passare in qualsiasi IO standard
descrittori e sono completamente interattivi
I / O standard selezionabili che non si
in realtà ha modo di fare sulla JVM
oggi non puoi selezionare rispetto allo standard
per esempio quando stai aspettando
input banale da fare con questo integrato
torna su di nuovo cercando di aggiungerne altri
queste caratteristiche ci aspettano molte persone
avranno bisogno di usi jnr unix per il socket
jnr en xio fornisce un socket eunuch
implementazione in un solo canale
sembra un qualsiasi altro canale niño in
il sistema selezionabile funziona come a
presa è perfetta quindi cos’altro possiamo
fallo con onestamente se potessimo
avere questo a livello JVM nel JDK
potremmo fare noi stessi
niño niño a noi stessi in Java
fondamentalmente non abbiamo bisogno di avere la JVM
includere un mucchio di codice nativo da fare
queste cose più che è veramente
eccitante soprattutto per il JDK
ingegneri che vogliono aggiungerne alcuni
nuove funzionalità in particolare come desktop
l’integrazione deve aspettare il prossimo
Versione JVM per includere il codice C per esso
che palle non vogliamo farlo
accesso alla memoria non gestita molto
le persone non sono sicure per allocare un
pezzo di memoria e lavorare con esso
direttamente possiamo fare quella chiamata tribulus
Malloc è tutto ciò che c’è da chiamare
malloc e si ottiene un oggetto puntatore indietro
che ti permette di interagire con quel pezzo
di dati nel mondo nativo molto
facilmente ho menzionato lo standard selezionabile
I / O e process io danno molto di più
interattività a quei flussi e poi
lo sai che altri tipi di socket sono la nuova API
nuove librerie crittografiche tutte le cose che noi
potrebbe fare senza mai scrivere una linea di
codice C quindi penso che sia necessario
la JVM e ne parleremo a
un po ‘più tardi per quanto riguarda le prestazioni
tornando al motivo per cui non usiamo je na
purtroppo facciamo un sacco di lavoro per rendere questo
eseguire il più velocemente possibile il codice che porta
fino alla chiamata jni viene generato così
idealmente è solo un salto dalla tua chiamata
verso l’endpoint jni dall’altra parte
il codice C in realtà genera assembly
al volo collegalo alla JVM in modo che
si spera che una chiamata dal tuo nativo
invocazione nel lato Java al
biblioteca reale quindi forse due o tre
luppolo totale questo è il confronto je na e
jnr
je na è il plus Jr’s i cerchi
qui e questa è una scala logaritmica jnr
è all’incirca un ordine di grandezza più veloce
di J e quindi puoi immaginare quando siamo
usando je na per fare tutte queste cose prima
Quanta parte di un impatto sulle prestazioni
in realtà era possibile migliorarlo ulteriormente
ci sono modi che puoi personalizzare
queste chiamate se per esempio non ci sei
tutti interessati all’aria senza valore e
non ne hai bisogno per essere salvato da te
può lanciare ignorare annotazione errore su
e ottieni un altro venticinque percento
o fuori di esso se è una chiamata cruda
sai che è improbabile che fallisca come un get
chiamata bloccata c’è sicuramente di più
fai qui anche se questo è jnr con con e
senza l’errore ignora jni nel
cerchi insolitamente là che jnr con
ignorare gli errori più velocemente del jni
versione non sono sicuro del perché sia e
quindi il GCC 03 potenzialmente ottimizza
alcuni di questi sono pagati, ma via
c’è ancora del lavoro non banale
fatto qui per il punto di riferimento ed è
molto più veloce di quello che abbiamo alla JVM
livello appena passato attraverso jnr, quindi è così
dove il progetto Panama arriva in questo è
JEP 191 fi per la JVM cosa siamo
lavorando ora o cosa JVM
la gente sta lavorando al momento è il
JVM lato di questo come effettivamente fare
queste chiamate native ottimizzano velocemente così
quando generano l’ assemblaggio ottimizzato
per il codice Java va dritto
fino a una chiamata C per ottenere pit piuttosto
che passare attraverso tutti i nostri extra
impianto idraulico che è possibile fare quando
si stanno avvicinando a questo ora
c’è anche la possibilità di ottenere
migliore sicurezza per questo avere bene
grani per il controllo su voglio caricare
la Lib C ma io voglio solo questi
funzioni per essere mappabili niente come
che esiste nel modello di sicurezza Java
al momento e poi avere il metodo
maniglie per questo è una funzione nativa
renderlo ottimizzato come un metodo di gestire
e invoco dinamico quindi posso effettivamente
avere il mio codice Ruby per fare una chiamata nativa e
fa la chiamata nativa nel generato
assemblare cose interessanti e naturalmente native
la manipolazione del layout della memoria ci sono molte cose
di lavoro su diverse forme di struttura
e e tipi di valore e altre cose
che vengono eseguiti a livello di JVM
avere più conoscenza di ciò che è nativo
il codice vuole vedere farà la JVM
costruire strutture migliori per quelli del
area finale voglio parlare di Ruby
è uguale a oggetti e intendo molto e
un sacco di oggetti qualcuno ha fatto un
misura di quante stringhe a
la richiesta di singoli binari crea durante il
processo di gestione ed è stato
migliaia e migliaia di stringhe
significa la quantità di oggetti creati per
solo operazioni di base in Ruby dove
tutto è un oggetto che può essere
travolgente e può davvero scambiare un
il sistema II sostiene che l’assegnazione è
davvero la radice di tutti i malvagi novantanove
percentuale dei problemi di prestazioni che
Diagnostico in Ruby e Jay Ruby o altro
i progetti si riducono quasi sempre a
allocazione hai davvero bisogno di mantenere un
occhio su quello e quindi è necessario monitorare
Log di GC e quant’altro è più specifico
caso qui jruby 1 punto 0 incluso a
funzione di default chiamata spazio oggetti
Lo spazio dell’oggetto rubino ti permette di camminare
ogni oggetto nell’heap e sai farlo
qualunque calcolo tu voglia su di loro
puoi andare a cercare tutti gli oggetti o
cercare tutte le stringhe o qualsiasi altra cosa
ordinarci di implementarlo sul
JVM potremmo usare le API di debug ma
allora dovremmo avere il debug di API
acceso tutto il tempo così inizialmente noi
implementato con una settimana separata
grafico un albero della settimana di tutti questi
oggetti diversi con un piccolo involucro
in modo da poter camminare nella nostra struttura
memoria e quello vedrebbe tutto il
oggetti che sono stati creati e
idealmente se il loro settimanale si riferiva a loro
dovrebbe andare via una volta che è stata spazzatura
raccolto un enorme successo di prestazioni da
che ogni oggetto che creiamo doveva
avere una seconda doppia in modo che saremo
in grado di ostacolare la passeggiata spaziale ed è per
una funzione utilizzata principalmente in gran parte
debug o esplorazione non utilizzati per
tipica esecuzione runtime del sistema
ha ucciso qualsiasi applicazione se la si utilizza
in fase di esecuzione anche sullo standard
l’implementazione è stata la nostra prima grande
boost eravamo come non possiamo farlo
scusa, Ruby, questo sarà
disabilitato di default anche su JVM
livello questo non sarà efficiente
per noi fare questo qui è il nostro in realtà
lui è il G per l’uscita GC
quando avevamo lo spazio oggetti abilitato e
nota che ognuno di questi era 20 28
più di queste linee stavamo spingendo
circa 1,8 giga al secondo attraverso la memoria
pipeline e sul mio sistema qui il max
la larghezza di banda che sto ottenendo è di circa 10 gig
e così è
prendendo quasi il venti per cento del
larghezza di banda della memoria del sistema per a
benchmark semplice in un’unica applicazione
ovviamente non andando a lavorare questo è
dopo aver deciso di spegnere l’oggetto
spazio di default pochissima evacuazione
succedendo qui non stiamo bruciando
oggetti quasi altrettanto veloci così ora ci sono
cose che sono difficili da risolvere
purtroppo chiusure e blocchi loro
è necessario mantenere e essere in grado di modificare
metodi circostanti circostanti
variabili e così via così quelli devono essere
in una struttura ad heap da qualche parte non c’è
modo per noi di leggere le chiamate e vedere
variabili locali in un metodo da a
i numeri di chiusura in JRuby sono ancora tutti
oggetti così ogni volta che fai un plus
uno creerà a oggetto come risultato
lavoreremo su alcuni
specializzazione sopra il livello JVM ma
idealmente vorremmo che la JVM fosse in grado di farlo
vedere questo e lo fa per noi spera che
venendo che sta venendo giù la linea e
allora c’è un sacco di codice Ruby
sembra che abbiamo questi
strutture dati transitorie che vengono utilizzate
fare alcune semplici operazioni molto
l’ api conveniente è qui che stiamo andando
prendi ognuno di questi oggetti che stiamo andando
chiamare i 2 su di loro per trasformarli in
le stringhe li ordinano e poi ottengono il primo
uno di questi ora purtroppo questo
sta per creare un gruppo di separato
strutture di dati internamente abbiamo il
risultato della mappa è la chiamata dei 2 che abbiamo
la nuova collezione che è un a
risultato ordinato e poi finalmente tiriamo
un valore fuori che idealmente saremmo in grado di fare
ottimizzare tutto ciò e basta
la logica che fa questo tipo di chiamata
e lo smistamento senza l’intermedio
oggetti e anche questo è molto difficile
fare sulla JVM adesso possiamo fare
è pigro ma non aiuta ancora a
tutto perché stiamo creando un pigro
l’enumeratore nel mezzo idealmente lì
non dovrebbero esserci oggetti creati qui altro
rispetto a ciò che la chiamata del 2 non può farlo
fallo subito alla JVM, quindi aiutaci
jbm bene, include una funzionalità
chiamato analisi di fuga che credo
è abilitato di default in Java 8
costruisce e l’idea generale qui è quella
se può vedere un oggetto non lascia mai a
pezzo di codice e non è mai visibile
attraverso i fili eliminerà il
assegnazione effettiva di quell’oggetto e
basta usare i dati che ci sono dentro e
quindi in modo ricorsivo se questi sono oggetti
e loro non lo hanno mai lasciato mai
ambito alla fine si arriva a solo
valori primitivi del registro che ottimizzano
il modo in cui tu
li voglio sfortunatamente questo non riesce a
lavoro per noi in quasi tutti i casi
principalmente perché l’analisi di fuga in
l’hot spot in questo momento non può funzionare con nessuno
ramo che intendo ognuno dei nostri
le chiamate hanno almeno un ramo per vederlo
abbiamo ancora il metodo giusto memorizzato nella cache
quindi ogni metodo interrompe l’ analisi di fuga
in JRuby nella forma molto semplice che è
sulla JVM speriamo che ci sia
miglioramenti sul modo in cui non lo so
qual è lo stato di ciò?
ci porta in un altro quadro che è
stato aiutandoci a negoziare un accordo con alcuni di
questi problemi di allocazione truffle così noi
Iniziamo guardiamo a cosa serve
in realtà costruire una lingua sulla JVM e
questo potrebbe essere un linguaggio dinamico di
linguaggio statico qualunque cosa tu voglia
gli stessi passi di base si applicano abbiamo la nostra JVM
linguaggio che abbiamo analizzato e possibilmente
trasformato in qualche forma bytecode forse noi
hai appena un interprete per quello
bene ma stiamo andando a prendere il caso
dove prendiamo un linguaggio JVM che compiliamo
in codice byte e poi lanciarlo a
la JVM per eseguire la JVM sta per lanciare
quello in un interprete bytecode per a
mentre sta andando a profilo ottimizza
lo getti nella JIT e poi
alla fine otteniamo il codice nativo che viene
dal retro ora il problema è tutto
quella magia nel mezzo delle cose interessanti
non avremmo alcun controllo su non c’è modo
per te per dare suggerimenti di compilazione alla JVM
non c’è modo per voi di modificarlo
runtime è possibile modificare alcuni dei
imposta alcune delle metriche che usa
alla riga di comando ma nessun modo per cambiare
in fase di runtime, quindi non abbiamo alcun controllo
di questo su questa sezione e questo è
dove diventa molto frustrante per noi noi
prova a trovare un modo per formare un codice Ruby adatto
per quello che sappiamo, la JVM può fare questo
non è quello che non è ciò che vogliamo, quindi cosa
se l’ottimizzatore jit JVM è effettivamente
scritto in Java e potremmo personalizzare
e chiama in due pezzi diversi e
e cambia il modo in cui ottimizza il nostro
lingua ed è qui che arriva il ringhio
ringhiare come progetto dai laboratori Oracle a
Cento per cento Java gyp essenzialmente te
può pensare a come hotspot portato a
Java e quindi in esecuzione sulla JVM
può ammettere l’assemblaggio o può farlo
in realtà emette l’hotspot ir che è il
l’hotspot di forma intermedia utilizza
genera il suo codice in modo che tu lo faccia fare a Grall
il suo hotspot di lavoro fa il suo lavoro e poi
finalmente si ottiene il codice nativo al
in basso ma puoi controllare direttamente tutto
questa generazione di codice e tu non hai
anche tu non devi usare JVM
bytecode che può essere a volte un brusco
strumento puoi dire molto più direttamente
voglio accedere a questa memoria che voglio
chiama questa funzione quindi guardiamo a questo
con la configurazione del grawl abbiamo la nostra JVM
linguaggio invece generiamo un ringhio
rappresentazione intermedia che usiamo
ringhia bytecode essenzialmente questo è a
va in ringhio ottimizzatore e di nuovo
questo è tutto il codice Java, quindi possiamo collegarlo
in questo processo e aggiungere il nostro
ottimizzazioni che il nostro linguaggio specifico
rendere le cose ottimizzate più come Ruby
dovrebbe ottimizzare e poi alla fine noi
prendi il nostro codice nativo dal retro ma
otteniamo molto più controllo sul
processo ora in vigore il problema qui è
che non tutti sono scrittori di compilatori
e questo è un livello molto basso molto ricco a
molto complicato sono dentro la rissa come
puoi immaginare che questo sia il collegamento
il mondo Java al reale nativo
operazioni operazioni a livello di CPU così
c’è bisogno di molta comprensione
per scrivere davvero crawl di cui abbiamo bisogno
qualcosa un po ‘meglio di questo
troppo il sogno è che progettiamo il
lingua abbiamo una certa quantità di passaggi
nel mezzo e ad un certo punto nel
futuro tutti amano il nostro linguaggio e
viaggiamo in tutto il mondo per parlare
è ciò che vogliamo veramente che sia
quantità minima di lavoro a posto
l’interprete e abbiamo finito tutti
puoi scrivere un interprete probabilmente
tutti qui hanno scritto qualcosa
di interprete per scopi generali
lingua o una lingua specifica in alcuni
punto nella loro vita se solo potessimo farlo
e poi avere il loro linguaggio come
veloce come tutto ciò che sarebbe bello e
è qui che il tartufo arriva nel tartufo
una struttura linguistica costruita sopra
Grall, tutto ciò che devi fare è creare
il tuo parser in modo da sapere qual è il tuo
il linguaggio sembra produrre un AST e
l’ AST viene contrassegnato con alcuni
annotazioni in tartufo per dire ecco un
il percorso intero qui è un lungo percorso qui
come stai qui è una struttura dati
solo andando essere usato temporaneamente e
basato sull’interprete e la via
che esegue il tartufo può effettivamente fare tutto
che lavoro in crescita per te e ottimizzare
è come se fosse scritto nello specifico
che i VM sono stati scritti in modo specifico
per la tua lingua è davvero incredibile
approccio molto simile
a quello che fanno in torta a torta se qualcuno
familiarità con quello che scrivi interprete
e basato su come l’interprete lo gestisce
può generare un jit per te davvero forte
quindi tutto ciò che dobbiamo davvero fare qui è
scrivi il nostro linguaggio jvm e crea a
AST al tartufo che entra in Grall
ottimizza giù e abbiamo nativo veloce
codice basato sulle nostre lingue
semantica attuale Chris Seaton sta lavorando
con i laboratori Oracle in questo momento su rubino
implementazione come parte di JRuby
il tartufo si chiama prima il tartufo rubino
lo chiamiamo jruby plus tartufo
ora perché immagino di aver parlato con
persone giuste siamo riusciti a convincere
Oracle per prendere questo rubino chiuso
implementazione che è stata incredibilmente veloce
e dare a noi sotto le nostre licenze sono
scioccato che in realtà è successo, ma lo è
parte di JRuby ora e sarà
rilasciato con JRuby 9000 e quanto
meglio è che questo è un grafico sul lontano
lasciato difficile leggere il loro JRuby 17 con
invocare la dinamica che, come ho dimostrato, è quattro
o cinque volte più veloce del mare
implementazione di Ruby e sulla destra
l’estrema destra è il tartufo Ruby
il tartufo in alcuni casi fino a 20
tempi più veloci di JRuby più invocano
dinamico e questo è il novanta per cento di
questo miglioramento è perché possono ottenere
sbarazzarsi di tutti quegli oggetti extra perché
vede attraverso allocazioni molto meglio
rispetto alla JVM fa e siamo in grado di dare il
suggerisce che è necessario pulirli
oggetti via così ho citato il tartufo rubino
fa parte di JRuby ora e lo sarà
pubblicato in JRuby 9000 ce ne sono molti
altre lingue nelle opere e sono
in realtà davvero facile da costruire linguaggi
in cima al tartufo solo il caso banale
un AST un interprete che usa solo
oggetto che comunque ottimizzerà
abbastanza bene, allora puoi buttare il tuo
specializzazioni come ne hai bisogno
potrebbe essere diventato parte di OpenJDK è
possibilità in futuro non lo è
probabile che accada in Java 9 dato il
periodo di tempo questo è l’ altro è successo
questo è che sta forzando anche il
gente hotspot a pensare alle priorità
spero che i ragazzi del hotspot si renderanno conto
che conosci l’analisi di fuga con dentro
con il futuro non chiaro per quelli
gli oggetti sono qualcosa di cui abbiamo effettivamente bisogno
bisogno di essere in grado di fare analisi di fuga
anche se non possiamo vedere attraverso tutto il
codice va bene così avvolto qui così che cosa
abbiamo imparato, intendo
Non posso davvero dire quello che hai imparato
spero che tu abbia ottenuto qualcosa da
questo ciò che ho imparato nel corso di un decennio di
lavorare su JRuby è che c’è davvero
nulla di ciò che è impossibile sulla JVM se
siamo disposti a girarci attorno a
un po ‘e l’ho anche imparato
le persone che lavorano sulla JVM e lavorano
sul JDK sono estremamente interessati
evitando quei workaround e facendolo
possibile per noi utilizzare la JVM come
è e ha tutto questo tutte queste caratteristiche
vieni senza librerie extra
lavoro extra quindi spero che sia questo il
il futuro assomiglierà alla JVM
ha un problema ma possiamo risolverli
e nelle persone provvisorie come noi, quindi, aiutate
ti giri intorno a loro ora una cosa io
voglio l’ultima cosa che dirò qui
questo è tutto open source che puoi davvero
aiutare con questo tartufo grasso tutto il jnr
roba ovviamente JRuby JRuby plus tartufo
la JVM stessa con quella con un open
fonte con un po ‘ di conoscenza
nulla è impossibile sulla piattaforma
e possiamo rendere realtà tutta questa roba
per il futuro, grazie
Please follow and like us: