Changeset 2778


Ignore:
Timestamp:
Dec 15, 2012, 7:50:40 PM (6 years ago)
Author:
ksherdy
Message:

Added EOF_mask support. Added final block (a.k.a. optimised 'do_block' support). Updated compiler pipeline / application configuration.

Location:
proto/pablo/src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/applications/ApplicationGenerator.java

    r2775 r2778  
    33//import ast.StartSymbolNode;
    44
     5import compiler.ast.pabloS.Generators;
    56import compiler.codeGenerator.visitors.CPPUnparser;
    67import compiler.codeGenerator.visitors.Unparser;
     
    910import compiler.syntacticAnalysis.SyntacticAnalysisFailedException;
    1011import compiler.syntacticAnalysis.SyntacticAnalyzer;
     12import compiler.transformer.PabloSTransformer;
    1113import compiler.transformer.visitors.CarryInfoSetVisitor;
     14import compiler.transformer.visitors.Pablo2CarryXFormer;
    1215import compiler.transformer.visitors.PabloS2PabloBXFormer;
    1316import compiler.symbols.*;
     
    4144        public void generate() throws SyntacticAnalysisFailedException {
    4245
    43 //              OutputCodeFolder parser = new OutputCodeFolder(outputDirectory, srcDirectory);         
     46                // OutputCodeFolder parser = new OutputCodeFolder(outputDirectory, srcDirectory);               
    4447
    45                 // Target Lang
     48                // Transformation configuration
    4649                Builtins2Lang builtins2Lang = null;
    4750                CarrySetBuiltins2Lang carrySet2Lang = null;
    4851                Unparser unparser = null;
    49                
     52
    5053                if(applicationConfig.targetLang.contentEquals(ApplicationConfig.CLANG)) {
    5154                        //builtins2Lang = new Builtins2C();
    52                         //carrySet2Lang = new CarrySet2C();     
     55                        //carrySet2Lang = new CarrySet2C();
     56                        //unparser = new CUnparser();
    5357                } else {
    5458                        builtins2Lang = new Builtins2CPP();
    5559                        carrySet2Lang = new CarrySetBuiltins2CPP();
    56                 }
    57                
     60                }               
     61
    5862                // Parse
    5963                pabloS.ast.ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
    60                
    61                 // Build Carry Information Set
    62                
     64
     65
     66                // Build Carry Information Set symbol table // TODO - Update - carry_count, advance_n_count only
    6367                SymbolTable symbolTable = new SymbolTable();
    6468               
    6569                CarryInfoSetVisitor carryInfoSetVisitor = new CarryInfoSetVisitor(syntaxTree, symbolTable);
    6670                carryInfoSetVisitor.visit();
     71                       
     72                // Transform
     73                PabloSTransformer pabloSXFormer = new PabloSTransformer(syntaxTree);
     74                pabloSXFormer.setBuiltins2Lang(builtins2Lang);
     75                pabloSXFormer.setCarrySet2Lang(carrySet2Lang);
     76                pabloSXFormer.setFinalBlockMode(false);
     77                pabloS.ast.ASTNode decoratedTree = pabloSXFormer.xForm();
     78
     79                // Optimized transform
     80                pabloSXFormer.setFinalBlockMode(true);
     81                pabloS.ast.ASTNode optDecoratedTree = pabloSXFormer.xForm();
    6782               
    68                 // Transform
     83                PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(symbolTable);
     84                pabloB.ast.ASTNode resultASTTree = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    6985               
    70                 PabloS2PabloBXFormer xFormer = new PabloS2PabloBXFormer(symbolTable);
    71                 pabloB.ast.ASTNode node = xFormer.optXForm(syntaxTree, syntaxTree.deepCopy());
     86                unparser = new CPPUnparser(symbolTable);
    7287               
    73                 // Generate Code
    74                 if(applicationConfig.targetLang.contentEquals(ApplicationConfig.CLANG)) {
    75                         //unparser = new CUnparser();   
    76                 } else {
    77                         unparser = new CPPUnparser(symbolTable);
    78                 }
    79                
    80                 String code = unparser.getCode(node);
    81                
     88                String code = unparser.getCode(resultASTTree);
    8289                System.out.print(code);
    8390               
    8491                // Fill Template
    85                
    8692               
    8793                /*
  • proto/pablo/src/compiler/ast/pabloS/Accessors.java

    r2767 r2778  
    204204                }
    205205                return false;
     206        }
     207       
     208        public static ParameterListNode parameterListNode(FuncDefNode node) {
     209               
     210                if(hasParameters(node)) {
     211                        return (ParameterListNode) node.child(2);
     212                }
     213               
     214                return null;
    206215        }
    207216       
  • proto/pablo/src/compiler/ast/pabloS/Generators.java

    r2767 r2778  
    2222       
    2323        ////////////////////////////////////////////////////////////////////////////
    24         // Static factories for various nodes
     24        // Static factories for various node types
    2525        //
    2626        ////////////////////////////////////////////////////////////////////////////
     27        public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
     28               
     29                ParameterListNode parameterListNode = null;
     30               
     31                if(!Accessors.hasParameters(funcDefNode)) {
     32                        parameterListNode = new ParameterListNode(parameterNode.getToken()); // almost, probably not quite right
     33                        funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
     34                } else {
     35                        parameterListNode = Accessors.parameterListNode(funcDefNode);
     36                }
     37               
     38                parameterListNode.appendChild(parameterNode);
     39               
     40        }
     41       
    2742
    2843        /** Makes a new FuncCallNode with a Func identifier string and the TextLocation taken from token.
     
    99114       
    100115        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
    101                 assert identifier instanceof IdentifierNode || identifier instanceof CompoundIdentifierNode;
     116                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    102117
    103118                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
     
    230245        }       
    231246               
     247        public static ParameterNode makeEOFMaskParameter(Builtins2Lang builtins2Lang, Token locationToken) {
     248               
     249                Token parameterNodeToken = Generators.makeLextantToken(Lextant.STREAM, locationToken);
     250                ParameterNode parameterNode = new ParameterNode(parameterNodeToken);
     251               
     252                Token streamTypeToken = Generators.makeLextantToken(Lextant.STREAM, locationToken);
     253                StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
     254                IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), locationToken);
     255               
     256                parameterNode.appendChild(streamTypeNode);
     257                parameterNode.appendChild(identifierNode);
     258               
     259                return parameterNode;
     260        }
     261       
     262        public static void appendEOFMaskParameter(FuncDefNode node, Builtins2Lang builtins2Lang) {
     263               
     264                if(!Accessors.hasParameters(node)) {
     265                        // parameter list
     266                }
     267               
     268                // append
     269               
     270        }
     271       
    232272        // Helper
    233273        public static String capitalize(String str) {
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2775 r2778  
    124124                }
    125125               
    126                 // TODO - Add IDISA_INLINE configuration option
    127                 code.addFormattedLine("IDISA_INLINE %s %s (%s)", returnType, funcName, parameters);
     126                code.addFormattedLine("IDISA_INLINE %s %s(%s)", returnType, funcName, parameters);
    128127                code.addLine("{");
    129128                code.addAll(blockStmtCodeStore, 1);
     
    433432        public CodeStore visitLeave(StreamTypeNode node, List<CodeStore> childResults) {
    434433                CodeStore code = new CodeStore();
    435                 // TODO - Map stream --> BitBlock <-- stream, BitBlock <-- stream<1>
     434                // TODO - Map stream --> BitBlock and stream<1> --> BitBlock
    436435                // code.setResultVarName(Accessors.streamTypeName(node));
    437436                code.setResultVarName("BitBlock");
  • proto/pablo/src/compiler/transformer/PabloSTransformer.java

    r2775 r2778  
    11package compiler.transformer;
    22
     3//
     4// Deep copies AST.
     5// Decorates AST copy.
     6// Static interface decorates AST in default mode only.
     7// TODO - Add a method to sync/set defaults with the configuration object
     8//
     9// Use PabloSTransformer instance to set non-defaults.
     10//
     11
     12
     13import compiler.lang.carry.CarrySetBuiltins2CPP;
    314import compiler.lang.carry.CarrySetBuiltins2Lang;
     15import compiler.lang.pabloS.Builtins2CPP;
    416import compiler.lang.pabloS.Builtins2Lang;
    5 import compiler.symbols.SymbolTable;
     17//import compiler.symbols.SymbolTable;
    618import compiler.transformer.visitors.*;
    719
     
    1022        private pabloS.ast.ASTNode ASTTree;
    1123       
    12         private SymbolTable symbolTable;
     24        //private SymbolTable symbolTable;
    1325       
    1426        private Builtins2Lang builtins2Lang;
    1527        private CarrySetBuiltins2Lang carrySet2Lang;
     28        private boolean finalBlockMode;
    1629       
    1730        private boolean addDumpStmts;
     
    1932       
    2033        //////////////////////////////////////////////////////////////
    21         // static interface
    22                
    23         public static pabloS.ast.ASTNode analyze(pabloS.ast.ASTNode root, Builtins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {
    24                 PabloSTransformer analyzer = new PabloSTransformer(root, builtins2Lang, carrySet2Lang);         
    25                 return analyzer.transform();
     34        // static interface - transforms AST in default mode only
     35        //
     36        public static pabloS.ast.ASTNode analyze(pabloS.ast.ASTNode root) {
     37                PabloSTransformer analyzer = new PabloSTransformer(root);               
     38                return analyzer.xForm();
    2639        }       
    2740       
    2841        //////////////////////////////////////////////////////////////
    2942        // constructor and helpers
     43        public PabloSTransformer(pabloS.ast.ASTNode ASTTree) {
     44               
     45                this.ASTTree = ASTTree;         
     46                initDefaults();
     47                // this.symbolTable = symbolTable;
     48        }       
    3049       
    31         public PabloSTransformer(pabloS.ast.ASTNode root, Builtins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {           
    32                 this.ASTTree = root;           
     50        private void initDefaults() {
     51                this.setBuiltins2Lang(new Builtins2CPP());
     52                this.setCarrySet2Lang(new CarrySetBuiltins2CPP());
     53               
    3354                this.setAddDumpStmts(false);
    3455                this.setAddAssertBitBlockAlignStmts(false);
    35                 this.setBuiltins2Lang(builtins2Lang);
    36                 this.setCarrySet2Lang(carrySet2Lang);
    37                
    38                 this.symbolTable = new SymbolTable();
    39         }       
     56                this.setFinalBlockMode(false);
     57        }
    4058       
    4159        //////////////////////////////////////////////////////////////
    4260        // analysis
    43         public pabloS.ast.ASTNode transform() {
     61        public pabloS.ast.ASTNode xForm() {
    4462               
    45             AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(ASTTree);
     63                pabloS.ast.ASTNode decoratedTree = ASTTree.deepCopy();
     64               
     65            AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(decoratedTree);
    4666            advanceCombiner.XForm();
    4767                               
    48             AugAssignXFormer AugAssign = new AugAssignXFormer(ASTTree);
     68            AugAssignXFormer AugAssign = new AugAssignXFormer(decoratedTree);
    4969                AugAssign.XForm();
    5070               
    51                 CarryIntroXFormer carryQIntro = new CarryIntroXFormer(ASTTree, getCarrySet2Lang());
     71                CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getCarrySet2Lang());
    5272                carryQIntro.XForm();
    5373
    54                 AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(ASTTree, getBuiltins2Lang());
     74                // Transform
     75                Pablo2CarryXFormer pablo2CarryXFormer = new Pablo2CarryXFormer(decoratedTree, builtins2Lang, carrySet2Lang);
     76                pablo2CarryXFormer.XForm(finalBlockMode);               
     77               
     78                AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(decoratedTree, getBuiltins2Lang());
    5579                assertZeroXFormer.XForm();             
    5680           
    57                 Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(ASTTree);
     81                Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
    5882                bitwiseToIDISA.XForm();
    5983
    6084                if(isAddDumpStmts()) {
    61                         DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(ASTTree, getBuiltins2Lang()); 
     85                        DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(decoratedTree, getBuiltins2Lang()); 
    6286                        dumpAssignStmtsXFormer.XForm();
    6387                }
    6488               
    6589                if(isAddAssertBitBlockAlignStmts()) {
    66                         AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(ASTTree, getBuiltins2Lang()); 
     90                        AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(decoratedTree, getBuiltins2Lang()); 
    6791                        assertBitBlockAlignStmtsXFormer.XForm();
    6892                }                                                       
    6993                               
    70                 return ASTTree;
     94                return decoratedTree;
    7195        }
    7296
     
    87111        }
    88112
    89         private Builtins2Lang getBuiltins2Lang() {
     113        public Builtins2Lang getBuiltins2Lang() {
    90114                return builtins2Lang;
    91115        }
    92116
    93         private void setBuiltins2Lang(Builtins2Lang builtins2Lang) {
     117        public void setBuiltins2Lang(Builtins2Lang builtins2Lang) {
    94118                this.builtins2Lang = builtins2Lang;
    95119        }
    96120
    97         private CarrySetBuiltins2Lang getCarrySet2Lang() {
     121        public CarrySetBuiltins2Lang getCarrySet2Lang() {
    98122                return carrySet2Lang;
    99123        }
    100124
    101         private void setCarrySet2Lang(CarrySetBuiltins2Lang carrySet2Lang) {
     125        public void setCarrySet2Lang(CarrySetBuiltins2Lang carrySet2Lang) {
    102126                this.carrySet2Lang = carrySet2Lang;
     127        }
     128
     129        public boolean isFinalBlockMode() {
     130                return finalBlockMode;
     131        }
     132
     133        public void setFinalBlockMode(boolean finalBlockMode) {
     134                this.finalBlockMode = finalBlockMode;
    103135        }       
    104136       
  • proto/pablo/src/compiler/transformer/visitors/Pablo2CarryXFormer.java

    r2775 r2778  
    1313
    1414//TODO - Add while type to switch on/off carry in mode. Carry in is an internal to this visitor.
     15
     16// Transforms Pablo stream builtins to Runtime Carry Information Set function calls.
     17//
     18// Supports multiple back ends.
     19//
     20// isFinalBlock = true optimization for final block transformation
    1521
    1622public class Pablo2CarryXFormer {
     
    4248                //private int lastStmtCarries;
    4349               
    44                 XFormer(boolean isFinalBlock) { // TODO - ciMode parameter
    45                         this.finalBlockMode = isFinalBlock;
     50                XFormer(boolean finalBlockMode) { // TODO - ciMode parameter
     51                        this.finalBlockMode = finalBlockMode;
    4652                        this.ciMode = true;
    4753                        //this.coMode = coMode;
     
    6369                        this.currentCarry = 0;
    6470                        this.currentAdvN = 0;
    65                         //this.lastStmtCarries = 0;                     
     71                        //this.lastStmtCarries = 0;
    6672                }               
     73
     74                public void visitLeave(FuncDefNode node) {
     75                        if(finalBlockMode) {
     76                                ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(builtins2Lang, node.getToken());
     77                                Generators.appendParameter(node, EOFMaskParameter);
     78                        }
     79                }                       
    6780               
    6881                public void visitLeave(FuncCallNode node) {
  • proto/pablo/src/compiler/transformer/visitors/PabloS2PabloBXFormer.java

    r2775 r2778  
    1818        public static String PABLO2PABLOB_XFORM_SUPPORT_MSG = "PabloS to PabloB node transformation not supported.";
    1919       
    20         private pabloS.ast.ASTNode sASTTree;   
    21         private pabloS.ast.ASTNode sOptASTTree;                 
     20        private pabloS.ast.ASTNode decoratedASTTree;   
     21        private pabloS.ast.ASTNode optDecoratedASTTree;                 
    2222       
    2323        private SymbolTable symbolTable;
     
    2525       
    2626    public PabloS2PabloBXFormer(compiler.symbols.SymbolTable symbolTable) {
    27         this.sASTTree = null;
    28         this.sOptASTTree = null;
     27        this.decoratedASTTree = null;
     28        this.optDecoratedASTTree = null;
    2929        this.symbolTable = symbolTable;
    3030    }
    3131
    32     /*
    33     public pabloB.ast.ASTNode XForm(pabloS.ast.ASTNode root) {
    34         pabloB.ast.ASTNode node = null;
    35                 return node;
     32    public pabloB.ast.ASTNode XForm(pabloS.ast.ASTNode decoratedASTTree) {
     33                return XForm(decoratedASTTree, decoratedASTTree);
    3634    }
    37     */
    3835   
    39     public pabloB.ast.ASTNode optXForm(pabloS.ast.ASTNode sASTTree, pabloS.ast.ASTNode sOptASTTree) {
    40                
    41         this.sASTTree = sASTTree;
    42                 this.sOptASTTree = sOptASTTree;
    43        
    44                 // xForm PabloS to PabloB
    45                 pabloB.ast.ASTNode bASTTree = this.sASTTree.accept(new pabloBASTBuilder());
    46                 pabloB.ast.ASTNode bOptASTTree = this.sOptASTTree.accept(new pabloBASTBuilder());
     36   
     37    public pabloB.ast.ASTNode XForm(pabloS.ast.ASTNode decoratedASTTree, pabloS.ast.ASTNode optDecoratedASTTree) {
     38               
     39        this.decoratedASTTree = decoratedASTTree;
     40                this.optDecoratedASTTree = optDecoratedASTTree;
     41       
     42                pabloB.ast.ASTNode bASTTree = this.decoratedASTTree.accept(new pabloBASTBuilder());
     43                pabloB.ast.ASTNode bOptASTTree = this.optDecoratedASTTree.accept(new pabloBASTBuilder());
    4744                 
    4845                Map<String, pabloB.ast.FuncDefNode> map = funcDefMapBuilder(bASTTree);
Note: See TracChangeset for help on using the changeset viewer.