Changeset 3303


Ignore:
Timestamp:
Jun 14, 2013, 11:06:54 AM (6 years ago)
Author:
ksherdy
Message:

Tempify builtins initial transformation impl.

Location:
proto/pabloj/trunk/src/toolchain/pabloS
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3280 r3303  
    3838        }
    3939       
     40        public static LocalVarDeclNode makeLocalVarDeclNode(Locator locator, ASTNode type, ASTNode lhs) {
     41            Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
     42            LocalVarDeclNode localVarDecl = new LocalVarDeclNode(assignToken);
     43            localVarDecl.appendChild(type);
     44            localVarDecl.appendChild(lhs);
     45            return localVarDecl;
     46        }
     47       
    4048        public static LocalVarDeclNode makeLocalVarDeclNode(Locator locator, ASTNode type, ASTNode lhs, ASTNode rhs) {         
    41                 Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
    42                 LocalVarDeclNode localVarDecl = new LocalVarDeclNode(assignToken);
    43                 localVarDecl.appendChild(type);
    44                 localVarDecl.appendChild(lhs);
     49            LocalVarDeclNode localVarDecl = makeLocalVarDeclNode(locator,type,lhs);
    4550                localVarDecl.appendChild(rhs);
    4651                return localVarDecl;
     
    5560        }
    5661       
    57         // Make function Call variants 
     62        // Make function call variants 
    5863        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {
    5964                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);     
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/TempifyCarryBuiltinCalls.java

    r3297 r3303  
    11/*
    2  * Converting expressions involving built-ins to compiled form. 
     2 * Converts carry generating builtins expressions to compiled form.
    33 * Applied before carry variable insertion.
    44 *
    55 * @author Ken Herdy <ksherdy at sfu dot ca>
     6 *
     7 * Case 1: 'assignment' or 'local variable declaration' statement
     8 *
     9 * returnValue = pablo.BUILTIN_CALL(args) 
     10 *
     11 * =>
     12 *
     13 * stream temp;
     14 * temp = pablo_blk_BUILTIN_CALL(args);
     15 *   
     16 * Case 2: 'if' condition
     17 *
     18 * if(pablo.BUILTIN_CALL(args) { ... }
     19 *
     20 * } 
     21 *
     22 * =>
     23 *
     24 * stream temp;
     25 * temp = pablo_blk_BUILTIN_CALL(args);
     26 * if(temp) { ... }
     27 *
     28 * Case 3: 'while' condition
     29 *
     30 * while(pablo.BUILTIN_CALL(args) { ... } 
     31 *
     32 * =>
     33 *
     34 * stream temp:
     35 * temp = pablo_blk_BUILTIN_CALL(args);
     36 * while(temp) {
     37 *  ...
     38 *   
     39 *  stream temp:
     40 *  temp = pablo_blk_BUILTIN_CALL(args); 
     41 * } 
     42 *   
    643 */
    744package toolchain.pabloS.transformer.visitors.carry;
     
    946import java.util.ArrayList;
    1047import java.util.Collections;
     48import java.util.Iterator;
    1149import java.util.LinkedHashMap;
     50import java.util.List;
    1251import java.util.Map;
    1352
     
    2362       
    2463        static public ASTNode apply(ASTNode ASTree) {
    25                 Tempifier tempifier = new Tempifier();
     64            Tempifier tempifier = new Tempifier();
    2665                ASTree.accept(tempifier);
    2766                return ASTree;                 
    2867        }   
    2968   
    30     static private class Tempifier extends VoidVisitor.Default {
    31 
    32         Labeller labeller = new Labeller();
    33         Map<BlockStmtNode, ArrayList<LocalVarDeclNode>> localVarDeclTemps;
    34         Map<BlockStmtNode, ArrayList<AssignNode> > assignStmtTemps;
    35        
    36         public void visitEnter(FuncDefNode node) {
    37                 labeller.reset();
    38             localVarDeclTemps = new LinkedHashMap<BlockStmtNode, ArrayList<LocalVarDeclNode>>();
    39             assignStmtTemps = new LinkedHashMap<BlockStmtNode, ArrayList<AssignNode>>();
    40         }
    41        
    42         public void visitEnter(BlockStmtNode node) {
    43             labeller.reset();
    44         }
    45        
    46         public void visitLeave(BlockStmtNode node) {
     69        static private class Tempifier extends VoidVisitor.Default {
     70       
     71            private final ASTNode NO_ENCLOSING_BLOCK_STMT = null;
     72           
     73            Labeller labeller;
     74            Map<ASTNode, List<ASTNode>> tempDeclsEnclBlockStmt;
     75            Map<ASTNode, List<Pair<ASTNode, List<ASTNode>>>> tempDeclsInsertionChild;
     76           
     77            Map<ASTNode, List<ASTNode>> tempAssignsEnclBlockStmt;
     78            Map<ASTNode, List<Pair<ASTNode, List<ASTNode>>>> tempAssignsInsertionChild;
     79
     80            public Tempifier() {
     81                this(0);
     82            }
     83
     84            public Tempifier(int nextValue) {
     85                labeller = new Labeller();
     86                labeller.setBase("__temp__");
     87                labeller.setNextValue(nextValue);
     88
     89            tempDeclsEnclBlockStmt = new LinkedHashMap<ASTNode, List<ASTNode>>();
     90            tempAssignsEnclBlockStmt = new LinkedHashMap<ASTNode, List<ASTNode>>();
     91               
     92                tempDeclsInsertionChild = new LinkedHashMap<ASTNode, List<Pair<ASTNode, List<ASTNode>>>>();
     93                tempAssignsInsertionChild = new LinkedHashMap<ASTNode, List<Pair<ASTNode, List<ASTNode>>>>();
     94            }
     95
     96        //////////////////////////////////////////////////////////////
     97        // visitor callbacks
     98           
     99            public void visitEnter(FuncDefNode node) {
     100                labeller.reset();
     101               
     102                tempDeclsEnclBlockStmt.clear();
     103                tempAssignsEnclBlockStmt.clear();
     104               
     105                tempDeclsInsertionChild.clear();
     106                tempAssignsInsertionChild.clear();
     107            }
     108           
     109            public void visitLeave(BlockStmtNode node) {
     110            insertTempDecls(node);
     111            insertTempAssigns(node);
     112            }
     113           
     114        public void visitLeave(LocalVarDeclNode node) {
     115            bindTempDeclsToBlockStmt(node);
     116            bindTempAssignToBlockStmt(node);           
     117        }           
     118           
     119            public void visitLeave(AssignNode node) {
     120            bindTempDeclsToBlockStmt(node);
     121            bindTempAssignToBlockStmt(node);           
     122            }
     123           
     124            public void visitLeave(WhileStmtNode node) {
     125
     126                appendTempDeclsToWhileBody(node);      // WARNING: append calls must precede bind calls in this method
     127            appendTempAssignsToWhileBody(node);
     128               
     129                bindTempDeclsToBlockStmt(node);
     130            bindTempAssignToBlockStmt(node);
    47131           
    48             if(assignStmtTemps.containsKey(node)) {
    49                 Collections.reverse(assignStmtTemps.get(node));
    50                 for(AssignNode assignStmt : assignStmtTemps.get(node)) {
    51                     node.insertChild(assignStmt);
    52                 }
    53                 assignStmtTemps.remove(node);
    54             }
    55            
    56             if(localVarDeclTemps.containsKey(node)) {
    57                 Collections.reverse(localVarDeclTemps.get(node));
    58                 for(LocalVarDeclNode localVarDecl : localVarDeclTemps.get(node)) {
    59                     node.insertChild(localVarDecl);
    60                 }
    61                 localVarDeclTemps.remove(node);
    62             }
    63         }
    64 
    65         public void visitLeave(FuncCallNode node) {
    66                 if(BuiltinCallUtil.isCarry(node)) {
    67                    
    68                     BlockStmtNode blockStmt          = (BlockStmtNode)getEnclosingBlockStmt(node);
    69                         Locator locator                  = blockStmt.getToken();
    70                         IdentifierNode name              = Generators.makeIdentifierNode(locator, labeller.newLabel());
    71                         LocalVarDeclNode localVarDecl    = makeTempLocalVarDecl(locator, name);
    72                         AssignNode assignStmt            = Generators.makeAssignNode(locator, name, node);
    73                        
    74                         bindLocalVarDeclToBlockStmt(blockStmt, localVarDecl);
    75                 bindAssignStmtToBlockStmt(blockStmt, assignStmt);
    76                        
    77                 }
    78         }
    79 
    80         private void bindAssignStmtToBlockStmt(BlockStmtNode blockStmt,
    81                 AssignNode assignStmt) {
    82             if(!assignStmtTemps.containsKey(blockStmt)) {
    83                 assignStmtTemps.put(blockStmt, new ArrayList<AssignNode>());
    84             }
    85             ArrayList<AssignNode> assignStmtList = assignStmtTemps.get(blockStmt);
    86             assignStmtList.add(assignStmt);
    87         }
    88 
    89         private void bindLocalVarDeclToBlockStmt(BlockStmtNode blockStmt,
    90                 LocalVarDeclNode localVarDecl) {
    91             if(!localVarDeclTemps.containsKey(blockStmt)) {
    92                 localVarDeclTemps.put(blockStmt, new ArrayList<LocalVarDeclNode>());
    93             }
    94             ArrayList<LocalVarDeclNode> localVarDeclList = localVarDeclTemps.get(blockStmt);
    95             localVarDeclList.add(localVarDecl);
    96         }
    97        
    98         private boolean hasEnclosingBlockStmt(ASTNode node) {
    99            
    100             ASTNode current = node.getParent();
    101            
    102             while(current != ASTNode.NO_PARENT) {
    103                 if(current instanceof BlockStmtNode) {
    104                     return true;
    105                 }
    106                 current = current.getParent();
    107             }
    108            
    109             return false;
    110            
    111         }       
    112        
    113         private ASTNode getEnclosingBlockStmt(ASTNode node) {
    114            
    115             ASTNode current = node.getParent();
    116            
    117             while(current != ASTNode.NO_PARENT) {
    118                 if(current instanceof BlockStmtNode) {
    119                     return current;
    120                 }
    121                 current = current.getParent();
    122             }
    123 
    124             assert false: "getEnclosingBlockStmt() called on node of improper type.";
    125             return ASTNode.NO_PARENT; // KH: ASTNODE.NO_ANCESTOR ?
    126            
    127         }
    128        
    129                 private LocalVarDeclNode makeTempLocalVarDecl(Locator locator, IdentifierNode temp) {
    130                         StreamTypeNode streamType = Generators.makeStreamType(locator);
    131                         ASTNode lhs = temp;
    132                         int fieldWidth = streamType.getFieldWidth();
    133                         ASTNode rhs = Generators.makeMaskFuncCall(locator, fieldWidth, 0);
    134                         LocalVarDeclNode tempLocalVarDecl = Generators.makeLocalVarDeclNode(locator, streamType, lhs, rhs);
    135                         return tempLocalVarDecl;
    136                 }
     132            }
     133
     134        public void visitLeave(IfStmtNode node) {
     135            bindTempDeclsToBlockStmt(node);
     136            bindTempAssignToBlockStmt(node);
     137        }
     138
     139        public void visitLeave(FuncCallNode node) {
     140            if(BuiltinCallUtil.isCarry(node)) {
     141
     142                BlockStmtNode blockStmt          = getEnclosingBlockStmt(node);
     143                Locator locator                  = blockStmt;
     144                IdentifierNode name              = Generators.makeIdentifierNode(locator, labeller.newLabel());
     145                StreamTypeNode type              = Generators.makeStreamType(locator);
     146                LocalVarDeclNode localVarDecl    = Generators.makeLocalVarDeclNode(locator, type, name.deepCopy());
     147                AssignNode assignStmt            = Generators.makeAssignNode(locator, name.deepCopy(), node.deepCopy());
     148
     149                addValueToList(tempDeclsEnclBlockStmt, blockStmt, localVarDecl);
     150                addValueToList(tempAssignsEnclBlockStmt, blockStmt, assignStmt);
     151
     152                node.updateSelf(name);               
     153            }
     154        }
     155       
     156        //////////////////////////////////////////////////////////////
     157        // helpers
     158       
     159        private void appendTempAssignsToWhileBody(WhileStmtNode node) {
     160            BlockStmtNode whileBody    = Accessors.body(node);
     161            BlockStmtNode blockStmt    = getEnclosingBlockStmt(node);
     162            if(tempAssignsEnclBlockStmt.containsKey(blockStmt)) {
     163                for(ASTNode tempAssign : tempAssignsEnclBlockStmt.get(blockStmt)) {
     164                    whileBody.appendChild(tempAssign);
     165                }
     166            }
     167        }
     168
     169        private void appendTempDeclsToWhileBody(WhileStmtNode node) {
     170            BlockStmtNode whileBody    = Accessors.body(node);
     171            BlockStmtNode blockStmt    = getEnclosingBlockStmt(node);
     172            if(tempDeclsEnclBlockStmt.containsKey(blockStmt)) {
     173                for(ASTNode tempDecl : tempDeclsEnclBlockStmt.get(blockStmt)) {
     174                    whileBody.appendChild(tempDecl);
     175                }
     176            }
     177        }
     178       
     179        private void insertTempAssigns(BlockStmtNode node) {
     180            if(tempAssignsInsertionChild.containsKey(node)) {
     181                List<Pair<ASTNode, List<ASTNode>>> pairs = tempAssignsInsertionChild.get(node);
     182                for(Pair<ASTNode, List<ASTNode>> pair : pairs) {
     183                    for(ASTNode precessor : pair.right()) {
     184                        node.insertBeforeChild(pair.left(), precessor);   
     185                    }
     186                }
     187            }
     188        }
     189
     190        private void insertTempDecls(BlockStmtNode node) {
     191            if(tempDeclsInsertionChild.containsKey(node)) {
     192                List<Pair<ASTNode, List<ASTNode>>> pairs = tempDeclsInsertionChild.get(node);
     193                for(Pair<ASTNode, List<ASTNode>> pair : pairs) {
     194                    for(ASTNode precessor : pair.right()) {
     195                        node.insertBeforeChild(pair.left(), precessor);   
     196                    }
     197                }
     198            }
     199        }
     200       
     201        private void bindTempAssignToBlockStmt(ASTNode node) {
     202            BlockStmtNode blockStmt          = getEnclosingBlockStmt(node);
     203            if(tempAssignsEnclBlockStmt.containsKey(blockStmt)) {
     204                addValueToList(tempAssignsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, tempAssignsEnclBlockStmt.get(blockStmt)));
     205                tempAssignsEnclBlockStmt.remove(blockStmt);
     206            }
     207        }
     208
     209        private void bindTempDeclsToBlockStmt(ASTNode node) {
     210            BlockStmtNode blockStmt          = getEnclosingBlockStmt(node);
     211            if(tempDeclsEnclBlockStmt.containsKey(blockStmt)) {
     212                addValueToList(tempDeclsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, tempDeclsEnclBlockStmt.get(blockStmt)));
     213                tempDeclsEnclBlockStmt.remove(blockStmt);
     214            }
     215        }           
     216
     217        private BlockStmtNode getEnclosingBlockStmt(ASTNode node) {
     218                BlockStmtNode enclosingBlockStmt = (BlockStmtNode) getEnclosingNodeOfType(node, BlockStmtNode.class);
     219                assert enclosingBlockStmt != NO_ENCLOSING_BLOCK_STMT : "getEnclosingBlockStmt(node) has no ancestor of type 'BlockStmtNode'";
     220                return enclosingBlockStmt;
     221            }
     222
     223            private ASTNode getEnclosingNodeOfType(ASTNode node, Class<?> clazz) {
     224                ASTNode current = node.getParent();
     225                while(current != NO_ENCLOSING_BLOCK_STMT) {
     226                    if(current.getClass().isAssignableFrom(clazz)) {
     227                        return current;
     228                    }
     229                    current = current.getParent();
     230                }
     231
     232                return NO_ENCLOSING_BLOCK_STMT;
     233            }
     234           
     235        private <V, K> void addValueToList(Map<K, List<V>> map, K key, V value) {
     236            if(!map.containsKey(key)) {
     237                map.put(key, new ArrayList<V>());
     238            }
     239            List<V> list = map.get(key);
     240            list.add(value);
     241        }
     242               
     243        private static class Pair<L,R> {
     244
     245            private final L left;
     246            private final R right;
     247
     248            public Pair(L left, R right) {
     249              this.left = left;
     250              this.right = right;
     251            }
     252
     253            public L left() { return left; }
     254            public R right() { return right; }
     255        }
    137256    }
    138    
    139   //KH: messes up iterator, infinite loop
    140 //  public void visitLeave(IfStmtNode node) {
    141 //      ASTNode condition = Accessors.condition(node);
    142 //      TempifyCarryBuiltinCalls.apply(condition);
    143 //      insertAssignsBeforeNode(node);
    144 //  }
    145 // 
    146 //  public void visitLeave(WhileStmtNode node) {
    147 //      ASTNode condition = Accessors.condition(node);
    148 //      TempifyCarryBuiltinCalls.apply(condition);
    149 //      insertAssignsBeforeNode(node);
    150 //  }
    151 // 
    152 //  public void visitLeave(LocalVarDeclNode node) {
    153 //      insertAssignsBeforeNode(node);
    154 //  }
    155 // 
    156 //  public void visitLeave(AssignNode node) {
    157 //      insertAssignsBeforeNode(node);
    158 //  }
    159  
    160 //KH: messes up iterator, infinite loop
    161 //
    162 //private void insertAssignsBeforeNode(ASTNode node) {
    163 //    for(AssignNode assign : carryBuiltinCallAssigns) {
    164 //        Mutators.insertStatementBefore(node, assign);
    165 //    }
    166 //    carryBuiltinCallAssigns.clear();
    167 //}   
    168257}
    169 
Note: See TracChangeset for help on using the changeset viewer.