Author: Carl Friedrich Bolz <[email protected]>
Branch: regalloc-playground
Changeset: r92207:50dd22a26d67
Date: 2017-08-22 15:10 +0200
http://bitbucket.org/pypy/pypy/changeset/50dd22a26d67/
Log: simplify
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
@@ -881,7 +881,7 @@
assert opindex > self.index_lifetimes[-1][0]
self.index_lifetimes.append((opindex, varlifetime))
- def compute_free_until_pos(self, opindex):
+ def free_until_pos(self, opindex):
for (index, varlifetime) in self.index_lifetimes:
if opindex <= index:
if varlifetime is not None and varlifetime.definition_pos >=
opindex:
@@ -914,7 +914,7 @@
self.fixed_register_use[register] =
FixedRegisterPositions(register)
self.fixed_register_use[register].fixed_register(opindex, varlifetime)
- def compute_longest_free_reg(self, position, free_regs):
+ def longest_free_reg(self, position, free_regs):
""" for every register in free_regs, compute how far into the
future that register can remain free, according to the constraints of
the fixed registers. Find the register that is free the longest.
Return a tuple
@@ -927,7 +927,7 @@
if fixed_reg_pos is None:
return reg, sys.maxint
else:
- free_until_pos = fixed_reg_pos.compute_free_until_pos(position)
+ free_until_pos = fixed_reg_pos.free_until_pos(position)
if free_until_pos > max_free_pos:
best_reg = reg
max_free_pos = free_until_pos
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
@@ -168,35 +168,31 @@
assert fpr2.index_lifetimes == [(4, None)]
-def test_compute_free_until_pos_none():
+def test_free_until_pos_none():
longevity = LifetimeManager({})
- longevity.fixed_register(1, r0, None)
- longevity.fixed_register(4, r2, None)
longevity.fixed_register(5, r1, None)
longevity.fixed_register(8, r1, None)
longevity.fixed_register(35, r1, None)
fpr1 = longevity.fixed_register_use[r1]
- assert fpr1.compute_free_until_pos(0) == 5
- assert fpr1.compute_free_until_pos(1) == 5
- assert fpr1.compute_free_until_pos(2) == 5
- assert fpr1.compute_free_until_pos(3) == 5
- assert fpr1.compute_free_until_pos(4) == 5
- assert fpr1.compute_free_until_pos(5) == 5
- assert fpr1.compute_free_until_pos(10) == 35
- assert fpr1.compute_free_until_pos(20) == 35
- assert fpr1.compute_free_until_pos(30) == 35
- assert fpr1.compute_free_until_pos(36) == sys.maxint
+ assert fpr1.free_until_pos(0) == 5
+ assert fpr1.free_until_pos(1) == 5
+ assert fpr1.free_until_pos(2) == 5
+ assert fpr1.free_until_pos(3) == 5
+ assert fpr1.free_until_pos(4) == 5
+ assert fpr1.free_until_pos(5) == 5
+ assert fpr1.free_until_pos(10) == 35
+ assert fpr1.free_until_pos(20) == 35
+ assert fpr1.free_until_pos(30) == 35
+ assert fpr1.free_until_pos(36) == sys.maxint
-def test_compute_free_until_pos():
+def test_free_until_pos():
b0, b1, b2 = newboxes(0, 0, 0)
l0 = Lifetime(0, 5)
l1 = Lifetime(2, 9)
l2 = Lifetime(30, 40)
longevity = LifetimeManager({b0: l0, b1: l1, b2: l2})
- longevity.fixed_register(1, r0, b0)
- longevity.fixed_register(4, r2, b0)
longevity.fixed_register(5, r1, b1)
longevity.fixed_register(8, r1, b1)
longevity.fixed_register(35, r1, b2)
@@ -206,31 +202,32 @@
# simple cases: we are before the beginning of the lifetime of the variable
# in the fixed register, then it's free until the definition of the
# variable
- assert fpr1.compute_free_until_pos(0) == 2
- assert fpr1.compute_free_until_pos(1) == 2
- assert fpr1.compute_free_until_pos(2) == 2
- assert fpr1.compute_free_until_pos(10) == 30
- assert fpr1.compute_free_until_pos(20) == 30
- assert fpr1.compute_free_until_pos(30) == 30
+ assert fpr1.free_until_pos(0) == 2
+ assert fpr1.free_until_pos(1) == 2
+ assert fpr1.free_until_pos(2) == 2
+ assert fpr1.free_until_pos(10) == 30
+ assert fpr1.free_until_pos(20) == 30
+ assert fpr1.free_until_pos(30) == 30
# after the fixed use, we are fined anyway
- assert fpr1.compute_free_until_pos(36) == sys.maxint
- assert fpr1.compute_free_until_pos(50) == sys.maxint
+ assert fpr1.free_until_pos(36) == sys.maxint
+ assert fpr1.free_until_pos(50) == sys.maxint
# asking for a position *after* the definition of the variable in the fixed
# register means the variable didn't make it into the fixed register, but
# at the latest by the use point it will have to go there
- assert fpr1.compute_free_until_pos(3) == 5
- assert fpr1.compute_free_until_pos(4) == 5
- assert fpr1.compute_free_until_pos(5) == 5
- assert fpr1.compute_free_until_pos(6) == 8
- assert fpr1.compute_free_until_pos(7) == 8
- assert fpr1.compute_free_until_pos(8) == 8
- assert fpr1.compute_free_until_pos(31) == 35
- assert fpr1.compute_free_until_pos(32) == 35
- assert fpr1.compute_free_until_pos(33) == 35
- assert fpr1.compute_free_until_pos(34) == 35
- assert fpr1.compute_free_until_pos(35) == 35
+ assert fpr1.free_until_pos(3) == 5
+ assert fpr1.free_until_pos(4) == 5
+ assert fpr1.free_until_pos(5) == 5
+ assert fpr1.free_until_pos(6) == 8
+ assert fpr1.free_until_pos(7) == 8
+ assert fpr1.free_until_pos(8) == 8
+ assert fpr1.free_until_pos(31) == 35
+ assert fpr1.free_until_pos(32) == 35
+ assert fpr1.free_until_pos(33) == 35
+ assert fpr1.free_until_pos(34) == 35
+ assert fpr1.free_until_pos(35) == 35
+
class TestRegalloc(object):
def test_freeing_vars(self):
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
