Changeset 2640

Timestamp:

Nov 16, 2012, 12:20:19 PM (6 years ago)

Author:

cameron

Message:

GenerateCarryDecls?, GenerateLocalDeclare?, GenerateCarryWhileTest?

File:

• proto/Compiler/pablo.py (modified) (14 diffs)

proto/Compiler/pablo.py

@@ -499 +499 @@
         # Add a dummy entry for any possible final block that is empty.
         self.carryIndex[carryInfoSet.operation_no] = carry_counter
+    # Helper
     def CarryGroupAtt(self, attname, CarryGroupVarName=""):
         if CarryGroupVarName == '': CarryGroupVarName = self.carryGroupVar
         return ast.Attribute(ast.Name(CarryGroupVarName, ast.Load()), attname, ast.Load())
+    def GenerateCarryDecls(self):
+        carry_counter = 0
+        adv_n_counter = 0
+        for op_no in range(self.carryInfoSet.block_op_count[0]):
+          if not op_no in self.carryInfoSet.advance_amount.keys(): carry_counter += 1
+          elif self.carryInfoSet.advance_amount[op_no] == 1: carry_counter += 1
+          else: adv_n_counter += 1
+        return "CarryArray<%i, %i> %s;" % (carry_counter, adv_n_counter, self.carryGroupVar)
+
     def GenerateCarryInAccess(self, operation_no):
         carry_index = self.carryIndex[operation_no - self.operation_offset]
@@ -519 +529 @@
         ifIndex = self.carryIndex[self.carryInfoSet.block_first_op[block_no]]       
         return [mkCallStmt(self.CarryGroupAtt('CarryDequeueEnqueue'), [ast.Num(ifIndex), ast.Num(carry_count)])]
-    def GenerateCarryWhileTest(self, whileIndex): pass
+    def GenerateLocalDeclare(self, block_no):
+        local_carryvar = ast.Name("sub" + self.carryGroupVar, ast.Load())
+        return mkCallStmt('LocalCarryDeclare', [local_carryvar, ast.Num(self.carryInfoSet.block_op_count[block_no])])
+    def GenerateCarryWhileTest(self, block_no, testExpr):
+        carry_count = self.carryInfoSet.block_op_count[block_no]
+        if carry_count == 0: return testExpr
+        carry0 = self.carryIndex[self.carryInfoSet.block_first_op[block_no]]       
+        return ast.BoolOp(ast.Or(), [testExpr, mkCall(self.CarryGroupAtt('CarryTest'), [ast.Num(carry0), ast.Num(carry_count)])])
     def EnterLocalWhileBlock(self, operation_offset):  
         self.carryGroupVar = "sub" + self.carryGroupVar
@@ -816 +833 @@
     inner_while = self.local_while_xfrm(local_carryvar, copy.deepcopy(whileNode))
     self.generic_visit(whileNode)
-    local_carry_decl = mkCallStmt('LocalCarryDeclare', [local_carryvar, ast.Num(carries)])
+    local_carry_decl = self.ccgo.GenerateLocalDeclare(this_block)
+    #local_carry_decl = mkCallStmt('LocalCarryDeclare', [local_carryvar, ast.Num(carries)])
     inner_while.body.insert(0, local_carry_decl)
     #final_combine = mkCallStmt(ast.Attribute(self.carryvar, 'CarryCombine', ast.Load()), [ast.Attribute(local_carryvar, 'cq', ast.Load()),ast.Num(carry_base), ast.Num(carries)])
@@ -835 +853 @@
 
     if self.carryin == '': new_test = whileNode.test
-    else: new_test = ast.BoolOp(ast.Or(), [whileNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_test_arglist)])
-    else_part = [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), [ast.Num(carry_base), ast.Num(carries)])]    
+    else: new_test = self.ccgo.GenerateCarryWhileTest(this_block, whileNode.test)
+    else_part = [self.ccgo.GenerateCarryElseFinalization(this_block)]    
     newIf = ast.If(new_test, whileNode.body + while_body_extend, else_part)
     self.last_stmt = newIf
@@ -925 +943 @@
                 err_stream = node.value.args[0]
                 err_code = node.value.args[1]
-                return ast.If(err_stream,
+                return ast.If(mkCall('bitblock::any', [err_stream]),
                               [ast.Expr(mkCall(self.assert_routine, [err_code, err_stream]))],
                               [])
@@ -1036 +1054 @@
 
 class Emitter():
-        def __init__(self, use_C_syntax):
+        def __init__(self, use_C_syntax, ccgo):
                 self.use_C_syntax = use_C_syntax
+                self.ccgo = ccgo
 
         def definition(self, stream_function, icount=0):
@@ -1144 +1163 @@
                 #       adv_n_decl = "\n" + self.indent(icount) + "BitBlock pending64[%s];" % adv_n_count
                 #CARRY SET
-                return self.indent(icount) + "CarryArray<%i, %i> %s;" % (carry_count, adv_n_count, carry_variable)
+                return self.indent(icount) + self.ccgo.GenerateCarryDecls()
 
         def carry_test(self, carry_variable, carry_count, icount=0):
@@ -1206 +1225 @@
     self.main_carry_count = CarryCounter().count(self.main_node)
     self.main_adv_n_count = adv_nCounter().count(self.main_node)
+    self.main_carry_info_set = CarryInfoSetVisitor().getInfoSet(self.main_node)
+    self.main_ccgo = Strategic_CCGO_Factory(self.main_carry_info_set)
     assert self.main_adv_n_count == 0, "Advance32() in main not supported.\n"
     del self.stream_function_node[self.main_node_id]
@@ -1215 +1236 @@
                 stream_function.init_to_one_list = CarryInitToOneList().count(node)
                 stream_function.adv_n_count = adv_nCounter().count(node)
+                carry_info_set = CarryInfoSetVisitor().getInfoSet(node)
+                stream_function.ccgo = Strategic_CCGO_Factory(carry_info_set)
                 stream_function.type_name = node.name[0].upper() + node.name[1:]
                 stream_function.instance_name = node.name[0].lower() + node.name[1:]
@@ -1226 +1249 @@
 
                 StringMatchCompiler().xfrm(node)
-                AssertCompiler().xfrm(node)
                 AugAssignRemoval().xfrm(node)
 
-                carry_info_set = CarryInfoSetVisitor().getInfoSet(node)
-                ccgo = Strategic_CCGO_Factory(carry_info_set)
                 
                 Bitwise_to_SIMD().xfrm(node)
@@ -1237 +1257 @@
                         carryQname = stream_function.instance_name + ".carryQ"
                 else: carryQname = "carryQ"
-                CarryIntroVisitor = CarryIntro(ccgo, carryQname)
+                CarryIntroVisitor = CarryIntro(stream_function.ccgo, carryQname)
                 CarryIntroVisitor.xfrm_fndef(node)
                 CarryIntroVisitor.xfrm_fndef_final(final_block_node)
-
+                # 
+                # Compile asserts after carry intro so that generated if-statements
+                # are ignored.
+                AssertCompiler().xfrm(node)
+                AssertCompiler().xfrm(final_block_node)
                 if self.add_dump_stmts: 
                         Add_SIMD_Register_Dump().xfrm(node)
@@ -1251 +1275 @@
                 #if stream_function.carry_count > 0:
                 #       node.body += [mkCallStmt('carryQ.CarryQ_Adjust', [ast.Num(stream_function.carry_count)])]
-                node.body += ccgo.GenerateStreamFunctionFinalization()
+                node.body += stream_function.ccgo.GenerateStreamFunctionFinalization()
 
                 
@@ -1263 +1287 @@
         sys.exit()
                 
-    self.emitter = Emitter(self.use_C_syntax)
+    self.emitter = Emitter(self.use_C_syntax, stream_function.ccgo)
     
   def any_carry_expr(self):
@@ -1286 +1310 @@
     self.Cglobals = StreamStructGen().gen_struct_types(self.main_module)
     for key in self.stream_functions.keys():
-                self.Cglobals += Emitter(self.use_C_syntax).definition(self.stream_functions[key],2)       
+                sf = self.stream_functions[key]
+                self.Cglobals += Emitter(self.use_C_syntax, sf.ccgo).definition(sf, 2)     
                         
   def gen_declarations(self):