[JAVA] Trüffel Tutorial Folien Persönliches Übersetzungsprotokoll ①

Trüffel-Tutorial-Folien (30-60p) Dies ist mein eigenes Übersetzungsprotokoll.

Wir garantieren keine Fehlübersetzungen oder Auslassungen.

Wenn es ein Problem gibt, löschen Sie es.

Highlights von SL (Eine einfache Sprache)

• Dynamische Eingabe
• Starkes Tippen
• Keine implizite Typkonvertierung
• Ganzzahl mit beliebiger Genauigkeit
• Erstklassige Funktion
• Dynamische Funktionsdefinition? (Dynamische Funktionsneudefinition)
• Ein Objekt ist eine Datenstruktur, in der Schlüssel und Werte gespeichert werden.

• Jeder Schlüsseltyp und Wert kann verwendet werden

• Der Schlüssel ist normalerweise vom Typ String

Schimmel

• Ist Null ein Typ, der sich selbst hat? (Null ist ein eigener Typ)
• Auch "Undefiniert" genannt

beste Übung

• Verwenden Sie für die Leistung so oft wie möglich primitive Typen

• Verwenden Sie Java null nicht in Ihrer Gastsprache

Syntax

C-ähnliche Steuerungssyntax

• if, while, break, continue, return

Operator

• +, -, *, /, ==, !=, <, <=, >, >=, &&, ||, ()
• \ + Wird auch als String-Verkettungsoperator definiert
• ||Wann&&Hat eine Kurzschlussfestigkeit
• Verwenden Sie. Oder [], um auf Eigenschaften zuzugreifen? (. oder [] für den Zugriff auf Eigentum)

wörtlich

• Number, String, Function

Eingebaute Funktion? (Eingebaute Funktionen)

• println, readln: Standardeingabe / -ausgabe
• nanoTime: Zeitmessung? (um Zeitmessungen zu ermöglichen)
• defineFunction: Dynamische Funktionsdefinition? (Dynamische Funktionsneudefinition)
• stacktrace, helloEqualsWorld: Operationen "Stack Walking" und "Stack Frame"
• neu: Weisen Sie ein neues Objekt ohne Eigenschaften zu

Parsing

Abkürzung

SL Beispiel

Abkürzung

Getting Started

Abkürzung

AST-Dolmetscher

Es tut mir leid, dass ich weglasse

Trüffelknoten und Bäume

Class Node

Basisklasse des Trüffelknotens? (Basisklasse aller Trüffelbaumknoten)

• Eltern / Kind-Management
• Ersetzen Sie sich durch einen neuen Knoten? (Ersetzen dieses Knotens durch einen (neuen) Knoten)
• Kopie des Knotens
• Die Methode execute () ist in einer Unterklasse definiert. Warum also nicht hier definieren? (Keine execute () -Methoden: Definieren Sie Ihre eigenen in Unterklassen.)

NodeUtil bietet praktische Dienstprogrammmethoden.

public abstract class Node implements Cloneable {
    public final Node getParent() { ... }
    public final Iterable<Node> getChildren() { ... }
    public final <T extends Node> T replace(T newNode) { ... }
    public Node copy() { ... }
    public SourceSection getSourceSection();
} 

Wenn Syntax

public final class SLIfNode extends SLStatementNode {
    
    @Child private SLExpressionNode conditionNode;
    @Child private SLStatementNode thenPartNode;
    @Child private SLStatementNode elsePartNode;
    
    public SLIfNode(SLExpressionNode conditionNode, SLStatementNode thenPartNode, SLStatementNode elsePartNode) {
        this.conditionNode = conditionNode;
        this.thenPartNode = thenPartNode;
        this.elsePartNode = elsePartNode;
    }
    
    public void executeVoid(VirtualFrame frame) {
        if (conditionNode.executeBoolean(frame)) {
            thenPartNode.executeVoid(frame);
        }else{
            elsePartNode.executeVoid(frame);
        }
    }
}

Kommentieren Sie die Felder der untergeordneten Knoten mit @Child und machen Sie sie nicht endgültig.

Wenn Syntax mit Profilerstellung

public final class SLIfNode extends SLStatementNode {
    
    @Child private SLExpressionNode conditionNode;
    @Child private SLStatementNode thenPartNode;
    @Child private SLStatementNode elsePartNode;
    private final ConditionProfile condition = ConditionProfile.createCountingProfile();
    
    public SLIfNode(SLExpressionNode conditionNode, SLStatementNode thenPartNode, SLStatementNode elsePartNode) {
        this.conditionNode = conditionNode;
        this.thenPartNode = thenPartNode;
        this.elsePartNode = elsePartNode;
    }
    
    public void executeVoid(VirtualFrame frame) {
        if (condition.profile(conditionNode.executeBoolean(frame))) {
            thenPartNode.executeVoid(frame);
        }else{
            elsePartNode.executeVoid(frame);
        }
    }
}

Durch die Profilerstellung mit einem Interpreter kann der Compiler besseren Code generieren.

Block

public final class SLBlockNode extends SLStatementNode {
    
    @Children private final SLStatementNode[] bodyNodes;
    
    public SLBlockNode(SLStatementNode[] bodyNodes) {
        this.bodyNodes =  bodyNodes;
    }
    
    @ExplodeLoop public void executeVoid(VirtualFrame frame) {
        for (SLStatementNode statement : bodyNodes) {
            statement.executeVoid(frame);
        }
    }
}

• Felder, die mehrere Knoten darstellen, werden durch ein endgültiges Array mit @Children dargestellt.

• Muss ich @ExplodeLoop hinzufügen, wenn ich untergeordnete Elemente wiederhole? (Die Iteration der Kinder muss mit @ExplodeLoop kommentiert werden.)

Rückgabesyntax: Kontrollfluss zwischen Knoten

public final class SLReturnNode extends SLStatementNode {
    
    @Child private SLExpressionNode valueNode;
    
    ...
    
    public void executeVoid(VirtualFrame frame) {
        throw new SLReturnException(valueNode.executeGeneric(frame));
    }
}

public final class SLReturnException extends ControlFlowException {
    
    private final Object result;
    
    ...
}

public final class SLFunctionBodyNode extends SLExpressionNode {
    
    @Child private SLStatementNode bodyNode;
    
    ...
    
    public Object executeGeneric(VirtualFrame frame) {
        try {
            bodyNode.executeVoid(frame);
        }catch (SLReturnException ex){
            return ex.getResult();
        }
        return SLNull.SINGLETON;
    }
}

• Verwenden Sie Ausnahmen für den Kontrollfluss zwischen Knoten.
• Ausnahmen, die für den Kontrollfluss verwendet werden, erben von ControlFlowException.

Steuerung zwischen Knoten mit Ausnahmen? (Ausnahmen für den Kontrollfluss zwischen Knoten)

Spult die Ausnahme alle Stapelrahmen zurück? (Ausnahme wickelt alle Interpreter-Stack-Frames der Methode ab (Schleifen, Bedingungen, Blöcke, ...))

Zusatz? (Zusatz)

@NodeChildren({@NodeChild("leftNode"), @NodeChild("rightNode")})
public abstract class SLBinaryNode extends SLExpressionNode {
}

public abstract class SLAddNode extends SLBinaryNode {
    
    @Specialization(rewriteOn = ArithmeticException.class)
    protected final long add(long left, long right) {
        return ExactMath.addExact(left, right);
    }
    
    @Specialization
    protected final BigInteger add(BigInteger left, BigInteger right) {
        return left.add(right);
    }
    
    @Specialization(guards = "isString(left, right)")
    protected final String add(Object left, Object right) {
        return left.toString() + right.toString();
    }
    
    protected final boolean isString(Object a, Object b) {
        return a instanceof String || b instanceof String;
    }
} 

• Die Reihenfolge der @ Specialization-Methoden ist wichtig. Das erste passende Element wird ausgewählt.

• In allen anderen Spezialisierungen ist der Schutz implizit basierend auf der Methodensignatur.

Von Truffle DSL generierter Code ①

Von der Factory-Methode generierter Code

@GeneratedBy(SLAddNode.class)
public final class SLAddNodeGen extends SLAddNode {

    public static SLAddNode create(SLExpressionNode leftNode, SLExpressionNode rightNode) {
        ... 
    }
    
    ...
}

• The parser uses the factory to create a node that is initially in the uninitialized state.
• The generated code performs all the transitions between specialization states.

Von Truffle DSL generierter Code ②

@GeneratedBy(methodName = "add(long, long)", value = SLAddNode.class)
private static final class Add0Node_ extends BaseNode_ {
    
    @Override public long executeLong(VirtualFrame frameValue) throws UnexpectedResultException {
        long leftNodeValue_;
        try {
            leftNodeValue_ = root.leftNode_.executeLong(frameValue);
        }catch (UnexpectedResultException ex){
            Object rightNodeValue =  executeRightNode_(frameValue);
            return SLTypesGen.expectLong(getNext().execute_(frameValue,  ex.getResult(), rightNodeValue));
        }
        long rightNodeValue_;
        try {
            rightNodeValue_ = root.rightNode_.executeLong(frameValue);
        }catch (UnexpectedResultException ex){
            return SLTypesGen.expectLong(getNext().execute_(frameValue,  leftNodeValue_, ex.getResult()));
        }
        try {
            return root.add(leftNodeValue_, rightNodeValue_);
        } catch (ArithmeticException ex) {
            root.excludeAdd0_ = true;
            return SLTypesGen.expectLong(remove("threw rewrite exception", frameValue, leftNodeValue_, rightNodeValue_));
        }
    }
    
    @Override public Object execute(VirtualFrame frameValue) {
        try {
            return executeLong(frameValue);
        } catch (UnexpectedResultException ex) {
            return ex.getResult();
        }
    } //Der Originalartikel hat diese schließende Klammer nicht
}

Systemdefinition vom Typ Trüffel-DSL

@TypeSystem({long.class, BigInteger.class, boolean.class,              String.class, SLFunction.class, SLNull.class})
public abstract class SLTypes {
    @ImplicitCast
    public BigInteger castBigInteger(long value) {
        return BigInteger.valueOf(value);
    }
}

• Verwenden Sie @TypeCheck und @TypeCast, um die Typkonvertierung anzupassen.

@TypeSystemReference(SLTypes.class)
public abstract class SLExpressionNode extends SLStatementNode {
    
    public abstract Object executeGeneric(VirtualFrame frame);
    
    public long executeLong(VirtualFrame frame) throws UnexpectedResultException {
        return SLTypesGen.SLTYPES.expectLong(executeGeneric(frame));
    }
    
    public boolean executeBoolean(VirtualFrame frame)　...
} 

• SLTypesGen is a generated subclass of SLTypes.
• Zusätzlich zur abstrakten executeGeneric () -Methode execute () für jede Spezialisierung

UnexpectedResultException

• Die typspezifische Methode execute () hat einen speziellen Rückgabetyp --Erlauben Sie primitive Rückgabetypen, um Autoboxing zu vermeiden. --Ergebnisse können ohne Casting verwendet werden. (Ermöglicht die Verwendung des Ergebnisses ohne Typumwandlungen)

• Speculation types are stable and the specialization fits.

• But what to do when speculation was too optimistic?

• Sie müssen einen Wert mit einem allgemeineren Typ als dem Rückgabewert zurückgeben.
• Gibt den Wert "boxed" mit UnexpectedResultException zurück.

• Exception handler performs node rewriting

• Es gibt keine Leistungsengpässe, da Ausnahmen nur einmal ausgelöst werden.

Trüffel-DSL-Workflow

Abkürzung

Rahmenlayout

• Frames sind Objekte auf dem Heap.

--Ist die Funktion dem Prolog zugeordnet? (Im Funktionsprolog zugeordnet)

• Als Parameter für die Methode execute () übergeben? (Als Parameter zur Ausführung von () Methoden übergeben)

• Der Compiler entfernt die Zuordnung.

• No object allocation and object access.
• Lokale Variablen in Ihrer Gastsprache funktionieren genauso wie in Java.

• FrameDescriptor: describes the layout of a frame.

• Zuordnung von Bezeichnern (normalerweise Variablennamen) zu typisierten Slots? (Eine Zuordnung von Bezeichnern (normalerweise Variablennamen) zu typisierten Slots.)
• Hat jeder Slot einen eindeutigen Index für das Frame-Objekt? (Jeder Slot hat einen eindeutigen Index für das Frame-Objekt.)
• Beim Parsen erstellt und gefüllt.

• Rahmen

• Erstellt für jede Funktion Ihrer eigenen (Gast-) Sprache aufgerufen.

Rahmenverwaltung

• Die Trüffel-API macht nur die Frame-Schnittstelle verfügbar.

• Die Implementierungsklasse hängt vom Optimierungssystem ab.

• Virtueller Rahmen

• Vom Compiler automatisch optimiert.
• Weisen Sie keine Felder zu und verlassen Sie die interpretierte Funktion nicht.

• Materialisierter Rahmen

• Ein Rahmen, der ohne Einschränkungen gespeichert werden kann? (Ein Frame, der ohne Einschränkungen gespeichert werden kann) --Beispiel: Abschlussrahmen, der an eine andere Funktion übergeben werden muss? (Rahmen eines Verschlusses, der an eine andere Funktion übergeben werden muss)

• Rahmenzuordnung

--Factory-Methode der TruffleRuntime-Klasse

Rahmenverwaltung

public interface Frame {
    
    FrameDescriptor getFrameDescriptor();
    Object[] getArguments();
    boolean isType(FrameSlot slot);
    
    Type getType(FrameSlot slot) throws FrameSlotTypeException;
    
    void setType(FrameSlot slot, Type value);
    
    Object getValue(FrameSlot slot);
    
    MaterializedFrame materialize();
}

• Frames unterstützen alle primitiven Java-Typen und -Objekte.

• SL String, SLFunction, SLNull werden als Objekt gespeichert.

• Ordnen Sie keine Frames zu und implementieren Sie keine Frames.

Lokale Variablen

@NodeChild("valueNode")
@NodeField(name = "slot", type = FrameSlot.class)
public abstract class SLWriteLocalVariableNode extends SLExpressionNode {
    
    protected abstract FrameSlot getSlot();
    
    @Specialization(guards = "isLongOrIllegal(frame)")
    protected long writeLong(VirtualFrame frame, long value) {
        getSlot().setKind(FrameSlotKind.Long);
        frame.setLong(getSlot(), value);
        return value;
    }
    
    protected boolean isLongOrIllegal(VirtualFrame frame) {
        return getSlot().getKind() == FrameSlotKind.Long || getSlot().getKind() == FrameSlotKind.Illegal;
    }
    
    ...
     
    @Specialization(contains = {"writeLong", "  writeBoolean"})
    protected Object write(VirtualFrame frame, Object value) {
        getSlot().setKind(FrameSlotKind.Object);
        frame.setObject(getSlot(), value);
        return value;
    }
}

• Wenn kind? Ist lang, macht setKind () nichts.
• Wenn Sie sich nicht auf einen einzelnen primitiven Typ spezialisieren können, wechseln Sie alle Lese- und Schreibvorgänge zu Object.

@NodeField(name = "slot", type = FrameSlot.class)
public abstract class SLReadLocalVariableNode extends SLExpressionNode {
    
    protected abstract FrameSlot getSlot();
    
    @Specialization(guards = "isLong(frame)")
    protected long readLong(VirtualFrame frame) {
        return FrameUtil.getLongSafe(frame, getSlot());
    }
    
    protected boolean isLong(VirtualFrame frame) {
        return getSlot().getKind() == FrameSlotKind.Long;
    }
    
    ...
        
    @Specialization(contains = {"readLong", "readBoolean"})
    protected Object readObject(VirtualFrame frame) {
        if (!frame.isObject(getSlot())) {
            CompilerDirectives.transferToInterpreter();
            Object result = frame.getValue(getSlot());
            frame.setObject(getSlot(), result);
            return result;
        }
        return FrameUtil.getObjectSafe(frame, getSlot());
    }
} //Der Originaltext enthält keine schließende Klammer

• guard garantiert, dass der Frame-Slot einen langen Wert enthält.
• Kann ich trotzdem einen Frame mit primitiven Werten schreiben, bevor ich die lokale Variable auf Objekttyp umstelle? (Wir können immer noch Frames mit primitiven Werten schreiben lassen, bevor wir die lokale Variable auf die Art Object umgestellt haben.)

kompilieren? (Zusammenstellung)

• Automatische Teilauswertung abstrakter Syntaxbäume.

• Startet automatisch, je nachdem, wie oft die Funktion ausgeführt wird.

• Beim Kompilieren wird davon ausgegangen, dass der abstrakte Syntaxbaum stabil ist

• Alle @ Kinder- und @ Kinderfelder werden wie endgültig behandelt.

• Macht ein späteres Umschreiben des Knotens den Maschinencode ungültig? (Späteres Umschreiben des Knotens macht den Maschinencode ungültig.)

• "Deoptimierung" an den Dolmetscher zurücksenden? (Zurück zum Dolmetscher: "Deoptimierung")
• Ist die komplexe Logik zum Umschreiben von Knoten nicht Teil des kompilierten Codes? (Komplexe Logik zum Umschreiben von Knoten, die nicht Teil des kompilierten Codes ist) ――Unverzichtbar für hervorragende Spitzenleistungen? (Unverzichtbar für hervorragende Spitzenleistung)

• Durch die Compileroptimierung entfällt der Interpreter-Overhead.

• Möchten Sie noch mehr zwischen Knoten versenden? (Kein Versand mehr zwischen Knoten)
• Möchten Sie mehr VirtualFrames zuweisen? (Keine Zuordnung von VirtualFrame-Objekten mehr)
• Keine weiteren Ausnahmen für den Internodien-Kontrollfluss? (Keine Ausnahmen mehr für den Kontrollfluss zwischen Knoten)