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)
