Author: Richard Plangger <[email protected]>
Branch: fix-longevity
Changeset: r82496:1b6e563e6cb0
Date: 2016-02-25 13:11 +0100
http://bitbucket.org/pypy/pypy/changeset/1b6e563e6cb0/
Log: (remi, plan_rich) fixed all broken tests because of our refactoring
diff --git a/rpython/jit/backend/llsupport/regalloc.py
b/rpython/jit/backend/llsupport/regalloc.py
--- a/rpython/jit/backend/llsupport/regalloc.py
+++ b/rpython/jit/backend/llsupport/regalloc.py
@@ -276,11 +276,9 @@
save_around_call_regs = []
frame_reg = None
- free_callee_regs = [reg for reg in all_regs if reg not in
save_around_call_regs]
- free_caller_regs = save_around_call_regs[:]
- is_callee_lookup = [True] * len(all_regs)
- for reg in save_around_call_regs:
- is_callee_lookup[reg.index] = False
+ free_callee_regs = []
+ free_caller_regs = []
+ is_callee_lookup = None
def get_lower_byte_free_register(self, reg):
# try to return a volatile register first!
@@ -326,17 +324,24 @@
def put_back_register(self, reg):
if self.is_callee_lookup[reg.index]:
- self.free_callee_regs.push(reg)
+ self.free_callee_regs.append(reg)
else:
- self.free_caller_regs.push(reg)
+ self.free_caller_regs.append(reg)
+
+ def free_register_count(self):
+ return len(self.free_callee_regs) + len(self.free_caller_regs)
def is_free(self, reg):
return reg in self.free_callee_regs or \
reg in self.free_caller_regs
def __init__(self, live_ranges, frame_manager=None, assembler=None):
- self.free_regs = self.all_regs[:]
- self.free_regs.reverse()
+ self.free_callee_regs = [reg for reg in self.all_regs if reg not in
self.save_around_call_regs]
+ self.free_caller_regs = self.save_around_call_regs[:]
+ self.is_callee_lookup = [True] * len(self.all_regs)
+ for reg in self.save_around_call_regs:
+ self.is_callee_lookup[reg.index] = False
+
self.live_ranges = live_ranges
self.temp_boxes = []
if not we_are_translated():
@@ -395,7 +400,7 @@
self.temp_boxes = []
def _check_invariants(self):
- free_count = len(self.free_callee_regs) + len(self.free_caller_regs)
+ free_count = self.free_register_count()
if not we_are_translated():
# make sure no duplicates
assert len(dict.fromkeys(self.reg_bindings.values())) ==
len(self.reg_bindings)
@@ -442,11 +447,15 @@
# yes, this location is a no_lower_byte_register
return loc
# find a free register that is also a lower byte register
- if loc:
- self.put_back_register(loc)
+ if not self.has_free_registers():
+ return None
reg = self.get_lower_byte_free_register(v)
- self.reg_bindings[v] = reg
- return reg
+ if reg is not None:
+ if loc:
+ self.put_back_register(loc)
+ self.reg_bindings[v] = reg
+ return reg
+ return None
try:
return self.reg_bindings[v]
@@ -737,22 +746,25 @@
self.dist_to_next_call = dist_to_next_call
def exists(self, var):
- return var in self.longevity
+ return var in self.longevity
def last_use(self, var):
- return self.longevity[var][1]
+ return self.longevity[var][1]
def new_live_range(self, var, start, end):
- self.longevity[var] = (start, end)
+ self.longevity[var] = (start, end)
def survives_call(self, var, position):
- start, end = self.longevity[var]
- dist = self.dist_to_next_call[position]
- assert end >= position
- if end-position <= dist:
- # it is 'live during a call' if it live range ends after the call
- return True
- return False
+ if not we_are_translated():
+ if self.dist_to_next_call is None:
+ return False
+ start, end = self.longevity[var]
+ dist = self.dist_to_next_call[position]
+ assert end >= position
+ if end-position <= dist:
+ # it is 'live during a call' if it live range ends after the call
+ return True
+ return False
def compute_var_live_ranges(inputargs, operations):
# compute a dictionary that maps variables to index in
diff --git a/rpython/jit/backend/llsupport/test/test_regalloc.py
b/rpython/jit/backend/llsupport/test/test_regalloc.py
--- a/rpython/jit/backend/llsupport/test/test_regalloc.py
+++ b/rpython/jit/backend/llsupport/test/test_regalloc.py
@@ -23,9 +23,9 @@
class FakeReg(object):
def __init__(self, i):
- self.n = i
+ self.index = i
def __repr__(self):
- return 'r%d' % self.n
+ return 'r%d' % self.index
r0, r1, r2, r3 = [FakeReg(i) for i in range(4)]
regs = [r0, r1, r2, r3]
@@ -83,22 +83,22 @@
for b in b0, b1, b2:
rm.try_allocate_reg(b)
rm._check_invariants()
- assert len(rm.free_regs) == 1
+ assert rm.free_register_count() == 1
assert len(rm.reg_bindings) == 3
rm.possibly_free_vars([b0, b1, b2])
- assert len(rm.free_regs) == 1
+ assert rm.free_register_count() == 1
assert len(rm.reg_bindings) == 3
rm._check_invariants()
rm.next_instruction()
rm.possibly_free_vars([b0, b1, b2])
rm._check_invariants()
- assert len(rm.free_regs) == 2
+ assert rm.free_register_count() == 2
assert len(rm.reg_bindings) == 2
rm._check_invariants()
rm.next_instruction()
rm.possibly_free_vars([b0, b1, b2])
rm._check_invariants()
- assert len(rm.free_regs) == 4
+ assert rm.free_register_count() == 4
assert len(rm.reg_bindings) == 0
def test_register_exhaustion(self):
@@ -230,7 +230,7 @@
rm.next_instruction()
for b in b0, b1, b2, b3:
rm.force_allocate_reg(b)
- assert not len(rm.free_regs)
+ assert not rm.has_free_registers()
rm._check_invariants()
rm.next_instruction()
rm.force_result_in_reg(b4, b0)
@@ -259,8 +259,8 @@
fm = TFrameManager()
asm = MockAsm()
rm = RegisterManager(LiveRanges(longevity, None, None),
frame_manager=fm, assembler=asm)
- rm.free_regs = rm.free_regs[:1]
- rm.all_regs = rm.free_regs[:]
+ rm.free_callee_regs = rm.free_callee_regs[:1]
+ rm.all_regs = rm.free_callee_regs[:]
rm.next_instruction()
fm.loc(b0)
rm.force_result_in_reg(b1, b0)
@@ -388,7 +388,7 @@
rm.next_instruction()
for b in b0, b1, b2, b3:
rm.force_allocate_reg(b)
- assert len(rm.free_regs) == 0
+ assert not rm.has_free_registers()
rm.next_instruction()
loc = rm.loc(b3)
spilled = rm.force_allocate_reg(b4)
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
