Changeset 2800

Timestamp:

Dec 27, 2012, 12:58:34 PM (6 years ago)

Author:

cameron

Message:

Initial BitPack? CCGO object

Location:

proto/Compiler

Files:

• CCGO_HMCPS.py (modified) (1 diff)
• pablo.py (modified) (1 diff)

proto/Compiler/CCGO_HMCPS.py

@@ -546 +546 @@
         return decls + [make_callStmt('BitBlock_declare', [mk_var(t)]) for t in temps]
 
+#
+#  A version of HMCPS_CCGO with bit packing using hsimd:signmask
+#
+class HMCPS_CCGO_BitPack(HMCPS_CCGO):
+
+    def allocate_all(self):
+        self.aligned_size = determine_aligned_block_sizes(self.field_count, self.carryInfoSet)
+        self.carryPack_count = (self.aligned_size[0] + self.BLOCK_SIZE - 1) / self.BLOCK_SIZE
+        self.totalPack_count = self.carryPack_count + self.carryInfoSet.adv_n_count
+        self.alloc_map = {}
+        self.alloc_map[0] = 0
+        self.adv_n_map = {}
+        self.block_base = {}
+        self.allocate_ops()
+        # carry_offset is used within the inner body of while loops to access local carries.
+        # The calculated (ub, rp) value is reduced by this amount for the local carry Pack(s).
+        self.carry_offset = 0
+
+    def GenerateCarryInAccess(self, operation_no):
+        block_no = self.carryInfoSet.containing_block[operation_no]
+        posn = self.alloc_map[operation_no] - self.carry_offset
+        pk = posn/self.BLOCK_SIZE
+        rp = posn%self.BLOCK_SIZE
+        if rp == 0: e = self.carry_pack_full(pk)
+        elif rp < self.BLOCK_SIZE/2: e = make_call("simd<%i>::srli<%i>" %(self.BLOCK_SIZE/2, rp), [self.carry_pack_full(pk)])
+        else: e = make_call("bitblock::srli<%i>" %(rp), [self.carry_pack_full(pk)])
+        if rp == self.BLOCK_SIZE - 1:
+          return e
+        else: return make_call('simd_and', [e, mk_var("simd_const_1")])
+
+
+    def GenerateCarryOutStore(self, operation_no, carry_out_expr):
+        block_no = self.carryInfoSet.containing_block[operation_no]
+        posn = self.alloc_map[operation_no] - self.carry_offset
+        rp = posn%self.field_count
+        # Save the carry in the carry temp variable and then merge
+        # pending carry temps as far as possible.
+        assigs = [make_assign(self.temp_prefix + repr(rp), carry_out_expr)] 
+        assigs += self.gen_merges(rp, rp)
+        # Only generate an actual store for the last carryout in a pack.
+        next_op = operation_no + 1
+        while self.adv_n_map.has_key(next_op): next_op += 1
+        next_posn = self.alloc_map[next_op] - self.carry_offset
+        skip = next_posn - posn - 1
+        if skip > 0: 
+          assigs += self.gen_multiple_carry_zero_then_pack(rp+1, skip)
+        #print (posn, skip)
+        if next_posn % self.field_count == 0:
+          pk = posn/self.BLOCK_SIZE
+          fd = (posn%self.BLOCK_SIZE)/self.field_count
+          mask_op = "hsimd<%i>::signmask" % (self.fw)
+          storable_carry_in_form = make_call(mask_op, [mk_var(self.cg_temp(self.field_count - 1, 0))])
+          assigs.append(make_assign(self.carry_pack_index(self.field_count, pk, fd, mode = ast.Store()), storable_carry_in_form))
+        return assigs
+
+
+    def GenerateTest(self, block_no, testExpr):
+        int_size = self.BLOCK_SIZE/2
+        posn = self.block_base[block_no] - self.carry_offset
+        pk = posn/self.BLOCK_SIZE
+        fd = (posn%self.BLOCK_SIZE)/int_size
+        rp = posn%int_size
+        sz = self.aligned_size[block_no]
+        if sz in [8, 16, 32, 64] and align(posn, sz) == posn:
+            fd = (posn%self.BLOCK_SIZE)/sz
+            t = self.carry_pack_index(sz, pk, fd)
+            return TestHelper_Integer_Or(testExpr, t)
+        elif rp + sz <= int_size:
+            e = self.carry_pack_index(int_size, pk, fd)
+            t = ast.BinOp(e, ast.BitAnd(), ast.Num(((1<<sz) - 1)<<rp))
+            return TestHelper_Integer_Or(testExpr, t)
+        else:
+            e = self.carry_pack_index(int_size, pk, fd)
+            t = ast.BinOp(e, ast.BitAnd(), ast.Num(((1<<(int_size-rp)) - 1)<<rp))
+            sz -= (int_size-rp)
+            posn += (int_size-rp)
+            pk = posn/self.BLOCK_SIZE
+            fd = (posn%self.BLOCK_SIZE)/int_size
+            while sz >= int_size:
+              t = ast.BinOp(t, ast.BitOr(), self.carry_pack_index(int_size, pk, fd))
+              sz -= int_size
+              posn += int_size
+              pk = posn/self.BLOCK_SIZE
+              fd = (posn%self.BLOCK_SIZE)/int_size
+            if sz > 0:
+              e = self.carry_pack_index(int_size, pk, fd)
+              t = ast.BinOp(t, ast.BitOr(), ast.BinOp(e, ast.BitAnd(), ast.Num((1<<sz) -1)))
+            return TestHelper_Integer_Or(testExpr, t)
+            
+    def GenerateInitializations(self):
+        v = self.carryPackVar        
+        inits = ""
+        for i in range(0, self.totalPack_count):
+          inits += "%s[%i]._128 = simd<%i>::constant<0>();\n" % (v, i, self.fw)
+        for op_no in range(self.carryInfoSet.block_op_count[0]):
+          if op_no in self.carryInfoSet.init_one_list: 
+            posn = self.alloc_map[op_no]
+            pk = posn/self.BLOCK_SIZE
+            fd = (posn%self.BLOCK_SIZE)/self.field_count
+            rp = posn%self.BLOCK_SIZE
+            inits += "%s[%i]._%i[%i] |= 1 << %i;\n" % (self.carryPackVar, pk, self.fw, fd, rp)
+        return inits
+
+
+    def GenerateCarryElseFinalization(self, block_no):
+        # if the block consists of full carry packs, then
+        # no action need be taken: the corresponding carry-in packs
+        # must already be zero, or the then branch would have been taken.
+        count = self.aligned_size[block_no]
+        if count % self.field_count == 0: return []
+        # The block has half a carry-pack or less.
+        assigs = []
+        posn = self.block_base[block_no] - self.carry_offset
+        ub = posn / self.field_count
+        rp = posn % self.field_count
+        next_op = self.carryInfoSet.block_first_op[block_no] + self.carryInfoSet.block_op_count[block_no]
+        end_pos = (self.alloc_map[next_op]  - self.carry_offset - 1) % self.field_count
+        #print rp, next_op,self.alloc_map[next_op]
+        #assigs = [make_assign(self.cg_temp(end_pos, rp), make_zero(self.fw))]
+        assigs = self.gen_multiple_carry_zero_then_pack(rp, end_pos - rp + 1)
+        if (end_pos + 1) % self.field_count == 0:
+          pk = posn/self.BLOCK_SIZE
+          fd = (posn%self.BLOCK_SIZE)/self.field_count
+          mask_op = "hsimd<%i>::signmask" % (self.fw)
+          storable_carry_in_form = make_call(mask_op, [mk_var(self.cg_temp(self.field_count - 1, 0))])
+          assigs.append(make_assign(self.carry_pack_index(self.field_count, pk, fd, mode = ast.Store()), storable_carry_in_form))
+        return assigs
+
+#
+#  TO DO:
+#
+    def GenerateCarryWhileFinalization(self, block_no):
+        posn = self.block_base[block_no]
+        sz = self.aligned_size[block_no] 
+        if sz < self.field_count:
+          rp = posn%self.field_count
+          v0 = self.cg_temp(rp + sz - 1, rp)
+          lv0 = self.local_temp(sz - 1, 0)
+          return [make_assign(v0, make_call('simd_or', [mk_var(v0), mk_var(lv0)]))]
+        local_posn = 0
+        pk = posn/self.BLOCK_SIZE
+        assigs = []
+        for i in range((sz + self.field_count -1)/self.field_count):  
+          pk = posn/self.BLOCK_SIZE
+          fd = (posn%self.BLOCK_SIZE)/self.field_count
+          local_pk = local_posn/self.BLOCK_SIZE
+          local_fd = (local_posn%self.BLOCK_SIZE)/self.field_count
+          v0 = self.carry_pack_index(self.field_count, pk, fd)
+          lv0 = self.local_pack_index(self.field_count, local_pk, local_fd)
+          assigs.append(make_assign([self.carry_pack_index(self.field_count, pk, fd, ast.Store())], ast.BinOp(v0, ast.BitOr(), lv0)))
+          posn += self.field_count
+          local_posn += self.field_count
+        return assigs

proto/Compiler/pablo.py

@@ -329 +329 @@
     elif ops <= 4: ccgo = CCGO_HMCPS.HMCPS_CCGO2(BLOCK_SIZE, 32, carryInfoSet, 'carryG', '__c')
     #elif ops <= 8: ccgo = CCGO_HMCPS.HMCPS_CCGO(BLOCK_SIZE, 16, carryInfoSet, 'carryG', '__c')
-    #else: ccgo = CCGO_HMCPS.HMCPS_CCGO(BLOCK_SIZE, 8, carryInfoSet, 'carryG', '__c')
-    else: ccgo = CCGO_HMCPS.HMCPS_CCGO2(BLOCK_SIZE, 16, carryInfoSet, 'carryG', '__c')
+    #else: ccgo = CCGO_HMCPS.HMCPS_CCGO2(BLOCK_SIZE, 16, carryInfoSet, 'carryG', '__c')
+    else: ccgo = CCGO_HMCPS.HMCPS_CCGO_BitPack(BLOCK_SIZE, 8, carryInfoSet, 'carryG', '__c')
   else:
     ccgo = CCGO.testCCGO(BLOCK_SIZE, carryInfoSet, 'carryQ')