def test_convert_to_ssa_mov_phi_long(): ''' Test ssa conversion with a simple phi case over trace fragments. ''' args = {} block_size = (4, 4) def codegen(code, block_size, args): for i in xrange(2): with scoped_alloc(code, 4) as (a, b, c, d): yield Imm(a, 1) yield Imm(b, 2) yield Cmp(a, b) yield Mov(c, a) yield Imm(a, 3) # to check if a is captured before new assignment yield Mov(c, b, cond='GT') yield Mov(d, c) expect = ''' imm r0~0, 1 imm r1~0, 2 cmp r0~0, r1~0 imm r0~1, 3 phi{GT} r2~1, r1~0, r0~0 mov r3~1, r2~1 imm r0~2, 1 imm r1~1, 2 cmp r0~2, r1~1 imm r0~3, 3 phi{GT} r2~2, r1~1, r0~2 mov r3~2, r2~2 ''' block_len = 4 convertor = CodegenToSSAConvertor(block_len) test_code_total = [] for i, current_fragment in enumerate(convertor.gen_ssa_fragments(codegen, Code(), block_size, args)): test_code = convert_compact_repr_to_obj(current_fragment.instructions) for x in test_code: test_code_total.append(x) assert match_code(test_code_total, expect)
def test_convert_to_ssa_instr_phi(): ''' Test ssa conversion with a more complicated phi case. ''' args = {} block_size = (4, 4) def codegen(code, block_size, args): with scoped_alloc(code, 4) as (a, b, c, d): yield Imm(a, 1) yield Imm(b, 2) yield Cmp(a, b) yield Inv(c, a, cond='LE') yield Imm(a, 3) # to check if a is captured before new assignment yield Mov(c, b, cond='GT') yield Mov(d, c) expect = ''' imm r0~0, 1 imm r1~0, 2 cmp r0~0, r1~0 inv tmp_1, r0~0 imm r0~1, 3 mov tmp_0, r1~0 phi{LE} r2~1, tmp_1, tmp_0 mov r3~1, r2~1 ''' convertor = CodegenToSSAConvertor(100) ref_code = convert_code_to_compact_repr(list(codegen(Code(), block_size, args))) test_code = convert_compact_repr_to_obj(convertor._convert_code_to_ssa(ref_code)[0]) assert match_code(test_code, expect)
def test_convert_to_ssa_easy(): ''' Test for the simple case without any branches. ''' args = {} block_size = (4, 4) def codegen(code, block_size, args): with scoped_alloc(code, 2) as (a, b): yield Imm(a, 1) yield Imm(b, 2) yield Add(a, a, b) expect = ''' imm r0~0, 1 imm r1~0, 2 add r0~1, r0~0, r1~0 ''' convertor = CodegenToSSAConvertor(100) ref_code = convert_code_to_compact_repr(list(codegen(Code(), block_size, args))) test_code = convert_compact_repr_to_obj(convertor._convert_code_to_ssa(ref_code)[0]) assert match_code(test_code, expect)
def test_convert_to_ssa_ports(): ''' Test for the simple case without any branches, with port communication. ''' args = {} block_size = (4, 4) def codegen(code, block_size, args): with scoped_alloc(code, 2) as (a, b): yield Imm(a, 1) yield Mov(code.out, a) yield Mov(b, code.east) yield Add(a, a, b) expect = ''' imm r0~0, 1 mov out, r0~0 mov r1~0, east add r0~1, r0~0, r1~0 ''' convertor = CodegenToSSAConvertor(100) ref_code = convert_code_to_compact_repr(list(codegen(Code(), block_size, args))) test_code = convert_compact_repr_to_obj(convertor._convert_code_to_ssa(ref_code)[0]) assert match_code(test_code, expect)
def test_convert_to_ssa_vj_no_errors(): ''' Test if ssa conversion is sufficient to convert VJ codegen. ''' from violajones import gen_code from violajones import parse_haar cascade_filename = '../data/haarcascade_frontalface_alt.xml' block_size = (32, 32) im_size = block_size pe_dim = tuple(s//b for s, b in zip(im_size, block_size)) # first load the cascade cascade = parse_haar.parse_haar_xml(cascade_filename) # use single stage to speed up test cascade.stages = [cascade.stages[0]] args = {'pe_dim': pe_dim, 'haar_classifier':cascade} block_len = 100 convertor = CodegenToSSAConvertor(block_len) test_code_total = [] for i, current_ref_code in enumerate(convertor.gen_ssa_fragments(gen_code.gen_detect_faces_fullintegral, Code(), block_size, args)): test_code = convert_compact_repr_to_obj(current_ref_code) assert test_code # we just want no errors
yield Imm(const_1, 1) yield Mov(a, const_1) yield Mov(code.out, a) #yield Mov(b, code.east) yield Mov(b, a) args = {} block_size = (4, 4) block_len = 100 convertor = CodegenToSSAConvertor(block_len, True) try: all_code = [] all_usage = [] for i, current_ref_code in enumerate(convertor.gen_ssa_fragments(test_codegen, Code(), block_size, args)): test_code = convert_compact_repr_to_obj(current_ref_code) for instr, reg_usage in current_ref_code: all_code.append(instr) all_usage.append(reg_usage) print '\n'.join(str(x) for x in test_code) liveness = RegisterAllocator.liveness_analysis(all_code) RegisterAllocator.print_liveness(all_code, liveness) print '\n'.join(' '.join('x' if x else '.' for x in y) for y in all_usage) original_reg_ranges = get_allocation_ranges(all_usage) print 'original register ranges:' print original_reg_ranges new_code, reg_mapping = RegisterAllocator.register_allocation(all_code, liveness, 30) print '\n'.join(str(x) for x in new_code)