[JAVA] Truffle Tutorial Slides Mémo de traduction personnel ①

Diapositives du didacticiel sur les truffes (30-60p) Ceci est mon propre mémo de traduction.

Nous ne garantissons pas les erreurs de traduction ou les omissions.

S'il y a un problème, supprimez-le.

Points forts de SL (un langage simple)

• Typage dynamique
• Typage fort
• Pas de conversion de type implicite
• Entier de précision arbitraire
• Fonction de première classe
• Définition de fonction dynamique? (Redéfinition dynamique des fonctions)
• Un objet est une structure de données qui stocke des clés et des valeurs.

• Tout type de clé et de valeur peut être utilisé

• La clé est généralement de type String

Moule

• Null est-il un type qui a lui-même? (Null est son propre type)
• Aussi appelé "Indéfini"

meilleur entrainement

• Utilisez autant que possible les types primitifs pour les performances

• N'utilisez pas Java null dans votre langue d'invité

syntaxe

Syntaxe de contrôle de type C

• if, while, break, continue, return

opérateur

• +, -, *, /, ==, !=, <, <=, >, >=, &&, ||, ()
• \ + Est également défini comme un opérateur de concaténation de chaîne
• ||Quand&&A une cote de court-circuit
• Utiliser. Ou [] pour accéder aux propriétés? (. ou [] pour l'accès à la propriété)

littéral

• Number, String, Function

Fonction intégrée? (Fonctions intégrées)

• println, readln: entrée / sortie standard
• nanoTime: mesure du temps? (pour permettre des mesures de temps)
• defineFunction: Définition de fonction dynamique? (Redéfinition dynamique des fonctions)
• stacktrace, helloEqualsWorld: opérations "stack walking" et "stack frame"
• nouveau: attribuer un nouvel objet sans propriétés

Analyse

Abréviation

Exemple SL

Abréviation

Getting Started

Abréviation

Interprète AST

Je suis désolé j'ai omis

Nœuds et arbres de truffe

Class Node

Classe de base du nœud Truffle? (classe de base de tous les nœuds de l'arbre Truffle)

• Gestion parents / enfants
• Se remplacer par un nouveau nœud? (Remplacement de ce nœud par un (nouveau) nœud)
• Copie du nœud
• La méthode execute () est définie dans une sous-classe, alors pourquoi ne pas la définir ici? (Pas de méthode execute (): définissez la vôtre dans les sous-classes)

NodeUtil fournit des méthodes utilitaires pratiques.

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();
} 

Si la syntaxe

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);
        }
    }
}

Annotez les champs des nœuds enfants avec @Child et ne les rendez pas définitifs.

Si syntaxe avec profilage

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);
        }
    }
}

Le profilage avec un interpréteur permet au compilateur de générer un meilleur code.

bloquer

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);
        }
    }
}

• Les champs qui représentent plusieurs nœuds sont représentés par un tableau final avec @Children.

• Dois-je ajouter @ExplodeLoop lors de la répétition d'éléments enfants? (L'itération des enfants doit être annotée avec @ExplodeLoop)

syntaxe de retour: flux de contrôle entre les nœuds

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;
    }
}

• Utilisez des exceptions pour contrôler le flux entre les nœuds.
• Les exceptions utilisées pour le flux de contrôle héritent de ControlFlowException.

Contrôle inter-nœuds avec exceptions? (Exceptions pour le flux de contrôle inter-nœuds)

L'exception rembobine-t-elle toutes les images de la pile? (Exception déroule tous les cadres de la pile d'interpréteurs de la méthode (boucles, conditions, blocs, ...))

Une addition? (Une addition)

@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;
    }
} 

• L'ordre des méthodes @Specialization est important. Le premier élément correspondant est sélectionné.

• Dans toutes les autres spécialisations, la protection est implicite basée sur la signature de la méthode.

Code généré par Truffle DSL ①

Code généré par la méthode d'usine

@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.

Code généré par Truffle DSL ②

@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();
        }
    } //L'article d'origine n'a pas ce crochet de fermeture
}

Définition du système de type DSL Truffle

@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);
    }
}

• Utilisez @TypeCheck et @TypeCast pour personnaliser la conversion de type.

@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.
• En plus de la méthode abstraite executeGeneric (), execute () pour chaque spécialisation

UnexpectedResultException

• La méthode execute () spécifique au type a un type de retour spécial --Autoriser les types de retour primitifs pour éviter la mise en boîte automatique.

• Les résultats peuvent être utilisés sans lancer. (Permet d'utiliser le résultat sans casts de type)
• Speculation types are stable and the specialization fits.

• But what to do when speculation was too optimistic?

• Vous devez renvoyer une valeur avec un type plus général que la valeur de retour. --Retourne la valeur "boxed" avec UnexpectedResultException.

• Exception handler performs node rewriting

• Il n'y a pas de goulot d'étranglement des performances car les exceptions ne sont levées qu'une seule fois.

Flux de travail DSL Truffle

Abréviation

Disposition du cadre

• Les cadres sont des objets sur le tas.

• La fonction est-elle attribuée au prologue? (Alloué dans le prologue de la fonction)

• Passé comme paramètre de la méthode execute ()? (Passé comme paramètre pour les méthodes execute ())

• Le compilateur supprime l'affectation.

• No object allocation and object access.
• Les variables locales dans votre langage Invité fonctionnent de la même manière qu'en Java.

• FrameDescriptor: describes the layout of a frame.

• Mappage d'identificateurs (généralement des noms de variables) vers des emplacements typés? (Un mappage d'identificateurs (généralement des noms de variables) vers des emplacements typés.) -Est-ce que chaque slot a un index unique pour l'objet frame? (Chaque emplacement a un index unique dans l'objet frame.) --Créé et rempli lors de l'analyse.

• Cadre

• Créé pour chaque fonction de votre propre langue (Invité) appelée.

Gestion des trames

• L'API Truffle expose uniquement l'interface du cadre.

• La classe d'implémentation dépend du système d'optimisation.

• Cadre virtuel

• Optimisé automatiquement par le compilateur. --Ne pas attribuer aux champs ni quitter la fonction interprétée.

• Cadre matérialisé

--Un cadre qui peut être stocké sans restrictions? (Un cadre qui peut être stocké sans restrictions)

• Exemple: Cadre de fermeture qui doit être passé à une autre fonction? (cadre d'une fermeture qui doit être passé à une autre fonction)

• Allocation de trames

• Méthode d'usine de la classe TruffleRuntime

Gestion des trames

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();
}

• Les cadres prennent en charge tous les types et objets primitifs Java.

• SL String, SLFunction, SLNull sont stockés en tant qu'objet.

• N'allouez pas de cadres ou n'implémentez pas de cadres.

Variables locales

@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;
    }
}

• Si kind? Est long, setKind () ne fait rien.
• Si vous ne pouvez pas vous spécialiser dans un seul type primitif, basculez toutes les lectures et écritures sur 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());
    }
} //Il n'y a pas de parenthèse fermante dans le texte d'origine

• guard garantit que l'emplacement de trame contient une valeur longue.
• Puis-je encore écrire un cadre avec des valeurs primitives avant de basculer la variable locale sur le type d'objet? (nous pouvons toujours avoir des cadres avec des valeurs primitives écrites avant de basculer la variable locale sur le genre Object.)

compiler? (Compilation)

• Évaluation partielle automatique des arbres de syntaxe abstraite.

• Démarre automatiquement en fonction du nombre d'exécutions de la fonction.

• Compiler suppose que l'arborescence de la syntaxe abstraite est stable

• Tous les champs @Child et @Children sont traités comme finaux.

• La réécriture ultérieure des nœuds invalide-t-elle le code machine? (La réécriture ultérieure du nœud invalide le code machine)

• Renvoyer "désoptimisation" à l'interprète? (Transfert retour à l'interprète: «Désoptimisation»)
• La logique complexe de la réécriture des nœuds ne fait-elle pas partie du code compilé? (Logique complexe pour la réécriture des nœuds ne faisant pas partie du code compilé) ――Indispensable pour d'excellentes performances de pointe? (Essentiel pour d'excellentes performances de pointe)

• L'optimisation du compilateur élimine la surcharge d'interprétation.

• Souhaitez-vous en envoyer plus entre les nœuds? (Plus de répartition entre les nœuds)
• Souhaitez-vous allouer plus de VirtualFrames? (Plus d'allocation d'objets VirtualFrame)
• Plus d'exceptions pour le flux de contrôle entre nœuds? (Plus d'exceptions pour le flux de contrôle inter-nœuds)