d = D()
- self.assertEqual(d.f(), 1) # warmup
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD - 1):
+ self.assertEqual(d.f(), 1) # warmup
calls.clear()
self.assertEqual(d.f(), 1) # try to specialize
self.assertEqual(calls, [(d, D)])
return o.x
o = C()
- for i in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
assert f(o) == 1
Descriptor.__get__ = lambda self, instance, value: 2
def f():
return Class.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
Descriptor.__get__ = __get__
Descriptor.__set__ = __set__
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_metaclass_descriptor_shadows_class_attribute(self):
def f():
return Class.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
def test_metaclass_set_descriptor_after_optimization(self):
def f():
return Class.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
Metaclass.attribute = attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_metaclass_del_descriptor_after_optimization(self):
def f():
return Class.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
del Metaclass.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_type_descriptor_shadows_attribute_method(self):
def f():
return Class.mro
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertIsNone(f())
def test_type_descriptor_shadows_attribute_member(self):
def f():
return Class.__base__
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertIs(f(), object)
def test_type_descriptor_shadows_attribute_getset(self):
def f():
return Class.__name__
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertEqual(f(), "Class")
def test_metaclass_getattribute(self):
def f():
return Class.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
def test_metaclass_swap(self):
def f():
return Class.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
Class.__class__ = NewMetaclass
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_load_shadowing_slot_should_raise_type_error(self):
o = Sneaky()
o.shadowed = 42
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
with self.assertRaises(TypeError):
f(o)
o = Sneaky()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
with self.assertRaises(TypeError):
f(o)
o = Sneaky()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
with self.assertRaises(TypeError):
f(o)
o = Sneaky()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
with self.assertRaises(TypeError):
f(o)
def f():
return instance.attribute()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
Descriptor.__get__ = __get__
Descriptor.__set__ = __set__
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_metaclass_descriptor_added_after_optimization(self):
def f():
return Class.attribute()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
Descriptor.__get__ = __get__
Descriptor.__set__ = __set__
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_metaclass_descriptor_shadows_class_attribute(self):
def f():
return Class.attribute()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
def test_metaclass_set_descriptor_after_optimization(self):
def f():
return Class.attribute()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
Metaclass.attribute = attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_metaclass_del_descriptor_after_optimization(self):
def f():
return Class.attribute()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
del Metaclass.attribute
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
def test_type_descriptor_shadows_attribute_method(self):
def f():
return Class.mro()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertEqual(f(), ["Spam", "eggs"])
def test_type_descriptor_shadows_attribute_member(self):
def f():
return Class.__base__()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertNotEqual(f(), "Spam")
def test_metaclass_getattribute(self):
def f():
return Class.attribute()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
def test_metaclass_swap(self):
def f():
return Class.attribute()
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertTrue(f())
Class.__class__ = NewMetaclass
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertFalse(f())
pass
f.__defaults__ = (None,)
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
f()
def test_too_many_defaults_1(self):
pass
f.__defaults__ = (None, None)
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
f(None)
f()
pass
f.__defaults__ = (None, None, None)
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
f(None, None)
f(None)
f()
return MyClass()
# Trigger specialization
- for _ in range(1025):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
instantiate()
self.assert_specialized(instantiate, "CALL_ALLOC_AND_ENTER_INIT")
def instantiate():
return InitTakesArg()
- for _ in range(2):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
with self.assertRaises(TypeError):
instantiate()
self.assert_specialized(instantiate, "CALL_ALLOC_AND_ENTER_INIT")
# but you can also burn through a *ton* of type/dict/function versions:
ITEMS = 1000
LOOPS = 4
- WARMUPS = 2
WRITERS = 2
@requires_jit_disabled
else:
read.__code__ = read.__code__.replace()
# Specialize:
- for _ in range(self.WARMUPS):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
read(items)
if check_items:
for item in items:
item = C()
item.a = None
# Resize into a combined unicode dict:
- for i in range(29):
+ for i in range(_testinternalcapi.SHARED_KEYS_MAX_SIZE - 1):
setattr(item, f"_{i}", None)
items.append(item)
return items
for _ in range(self.ITEMS):
item = C()
# Resize into a combined unicode dict:
- for i in range(29):
+ for i in range(_testinternalcapi.SHARED_KEYS_MAX_SIZE - 1):
setattr(item, f"_{i}", None)
items.append(item)
return items
c.a = 1
c.b = 2
c.__dict__
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
c.a
self.assertEqual(
_testinternalcapi.get_object_dict_values(c),
c.a = 1
c.b = 2
d = c.__dict__
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
c.a
self.assertIs(c.__dict__, d)
c.a = 1
c.b = 2
c2 = copy.copy(c)
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
c.a
c2.a
self.assertEqual(
(1, 2, '<NULL>')
)
c3 = copy.deepcopy(c)
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
c.a
c3.a
self.assertEqual(
c.a = 1
c.b = 2
c2 = pickle.loads(pickle.dumps(c))
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
c.a
c2.a
self.assertEqual(
c.a = 1
c.b = 2
c.__dict__ = D(c.__dict__)
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
c.a
self.assertIs(
_testinternalcapi.get_object_dict_values(c),
for i in range(n):
o.b = i
# Prime f to store to dict slot 1
- f(c, 100)
+ f(c, _testinternalcapi.SPECIALIZATION_THRESHOLD)
test_obj = NoInlineAorB()
test_obj.__dict__ = make_special_dict()
@requires_specialization_ft
def test_binary_op(self):
def binary_op_add_int():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = 1, 2
c = a + b
self.assertEqual(c, 3)
self.assert_no_opcode(binary_op_add_int, "BINARY_OP")
def binary_op_add_unicode():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = "foo", "bar"
c = a + b
self.assertEqual(c, "foobar")
self.assert_no_opcode(binary_op_add_unicode, "BINARY_OP")
def binary_op_add_extend():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = 6, 3.0
c = a + b
self.assertEqual(c, 9.0)
arg / 42,
)
nan = float('nan')
- self.assertEqual(compactlong_lhs(1.0), (43.0, 41.0, 42.0, 42.0))
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+ self.assertEqual(compactlong_lhs(1.0), (43.0, 41.0, 42.0, 42.0))
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertTrue(all(filter(lambda x: x is nan, compactlong_lhs(nan))))
- self.assertEqual(compactlong_rhs(42.0), (84.0, 0.0, 84.0, 1.0))
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+ self.assertEqual(compactlong_rhs(42.0), (84.0, 0.0, 84.0, 1.0))
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
self.assertTrue(all(filter(lambda x: x is nan, compactlong_rhs(nan))))
self.assert_no_opcode(compactlong_lhs, "BINARY_OP_EXTEND")
meth = super().__init__
super().__init__()
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
A()
self.assert_specialized(A.__init__, "LOAD_SUPER_ATTR_ATTR")
globals()['super'] = fake_super
try:
# Should be unspecialized after enough calls.
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
A()
finally:
globals()['super'] = real_super
@requires_specialization_ft
def test_contain_op(self):
def contains_op_dict():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = 1, {1: 2, 2: 5}
self.assertTrue(a in b)
self.assertFalse(3 in b)
self.assert_no_opcode(contains_op_dict, "CONTAINS_OP")
def contains_op_set():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = 1, {1, 2}
self.assertTrue(a in b)
self.assertFalse(3 in b)
pass
async def send_with():
- for i in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
async with CM():
x = 1
def send_yield_from():
yield from g()
- for i in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
list(send_yield_from())
self.assert_specialized(send_yield_from, "SEND_GEN")
class C:
__slots__ = ['x']
- def set_slot():
+ def set_slot(n):
c = C()
- for i in range(100):
+ for i in range(n):
c.x = i
- set_slot()
+ set_slot(_testinternalcapi.SPECIALIZATION_THRESHOLD)
self.assert_specialized(set_slot, "STORE_ATTR_SLOT")
self.assert_no_opcode(set_slot, "STORE_ATTR")
# Adding a property for 'x' should unspecialize it.
C.x = property(lambda self: None, lambda self, x: None)
- set_slot()
+ set_slot(_testinternalcapi.SPECIALIZATION_COOLDOWN)
self.assert_no_opcode(set_slot, "STORE_ATTR_SLOT")
@cpython_only
class C:
pass
- def set_value():
+ def set_value(n):
c = C()
- for i in range(100):
+ for i in range(n):
c.x = i
- set_value()
+ set_value(_testinternalcapi.SPECIALIZATION_THRESHOLD)
self.assert_specialized(set_value, "STORE_ATTR_INSTANCE_VALUE")
self.assert_no_opcode(set_value, "STORE_ATTR")
# Adding a property for 'x' should unspecialize it.
C.x = property(lambda self: None, lambda self, x: None)
- set_value()
+ set_value(_testinternalcapi.SPECIALIZATION_COOLDOWN)
self.assert_no_opcode(set_value, "STORE_ATTR_INSTANCE_VALUE")
@cpython_only
pass
c = C()
- for i in range(29):
+ for i in range(_testinternalcapi.SHARED_KEYS_MAX_SIZE - 1):
setattr(c, f"_{i}", None)
- def set_value():
- for i in range(100):
+ def set_value(n):
+ for i in range(n):
c.x = i
- set_value()
+ set_value(_testinternalcapi.SPECIALIZATION_THRESHOLD)
self.assert_specialized(set_value, "STORE_ATTR_WITH_HINT")
self.assert_no_opcode(set_value, "STORE_ATTR")
# Adding a property for 'x' should unspecialize it.
C.x = property(lambda self: None, lambda self, x: None)
- set_value()
+ set_value(_testinternalcapi.SPECIALIZATION_COOLDOWN)
self.assert_no_opcode(set_value, "STORE_ATTR_WITH_HINT")
@cpython_only
def test_to_bool(self):
def to_bool_bool():
true_cnt, false_cnt = 0, 0
- elems = [e % 2 == 0 for e in range(100)]
+ elems = [e % 2 == 0 for e in range(_testinternalcapi.SPECIALIZATION_THRESHOLD)]
for e in elems:
if e:
true_cnt += 1
else:
false_cnt += 1
- self.assertEqual(true_cnt, 50)
- self.assertEqual(false_cnt, 50)
+ d, m = divmod(_testinternalcapi.SPECIALIZATION_THRESHOLD, 2)
+ self.assertEqual(true_cnt, d + m)
+ self.assertEqual(false_cnt, d)
to_bool_bool()
self.assert_specialized(to_bool_bool, "TO_BOOL_BOOL")
def to_bool_int():
count = 0
- for i in range(100):
+ for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
if i:
count += 1
else:
count -= 1
- self.assertEqual(count, 98)
+ self.assertEqual(count, _testinternalcapi.SPECIALIZATION_THRESHOLD - 2)
to_bool_int()
self.assert_specialized(to_bool_int, "TO_BOOL_INT")
def to_bool_list():
count = 0
- elems = [1, 2, 3]
+ elems = list(range(_testinternalcapi.SPECIALIZATION_THRESHOLD))
while elems:
count += elems.pop()
self.assertEqual(elems, [])
- self.assertEqual(count, 6)
+ self.assertEqual(count, sum(range(_testinternalcapi.SPECIALIZATION_THRESHOLD)))
to_bool_list()
self.assert_specialized(to_bool_list, "TO_BOOL_LIST")
def to_bool_none():
count = 0
- elems = [None, None, None, None]
+ elems = [None] * _testinternalcapi.SPECIALIZATION_THRESHOLD
for e in elems:
if not e:
count += 1
- self.assertEqual(count, len(elems))
+ self.assertEqual(count, _testinternalcapi.SPECIALIZATION_THRESHOLD)
to_bool_none()
self.assert_specialized(to_bool_none, "TO_BOOL_NONE")
def to_bool_str():
count = 0
- elems = ["", "foo", ""]
+ elems = [""] + ["foo"] * (_testinternalcapi.SPECIALIZATION_THRESHOLD - 1)
for e in elems:
if e:
count += 1
- self.assertEqual(count, 1)
+ self.assertEqual(count, _testinternalcapi.SPECIALIZATION_THRESHOLD - 1)
to_bool_str()
self.assert_specialized(to_bool_str, "TO_BOOL_STR")
@requires_specialization_ft
def test_unpack_sequence(self):
def unpack_sequence_two_tuple():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = 1, 2
self.assertEqual(a, 1)
self.assertEqual(b, 2)
self.assert_no_opcode(unpack_sequence_two_tuple, "UNPACK_SEQUENCE")
def unpack_sequence_tuple():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, = 1,
self.assertEqual(a, 1)
self.assert_no_opcode(unpack_sequence_tuple, "UNPACK_SEQUENCE")
def unpack_sequence_list():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = [1, 2]
self.assertEqual(a, 1)
self.assertEqual(b, 2)
@requires_specialization_ft
def test_binary_subscr(self):
def binary_subscr_list_int():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a = [1, 2, 3]
for idx, expected in enumerate(a):
self.assertEqual(a[idx], expected)
self.assert_no_opcode(binary_subscr_list_int, "BINARY_SUBSCR")
def binary_subscr_tuple_int():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a = (1, 2, 3)
for idx, expected in enumerate(a):
self.assertEqual(a[idx], expected)
self.assert_no_opcode(binary_subscr_tuple_int, "BINARY_SUBSCR")
def binary_subscr_dict():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a = {1: 2, 2: 3}
self.assertEqual(a[1], 2)
self.assertEqual(a[2], 3)
self.assert_no_opcode(binary_subscr_dict, "BINARY_SUBSCR")
def binary_subscr_str_int():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a = "foobar"
for idx, expected in enumerate(a):
self.assertEqual(a[idx], expected)
def __getitem__(self, item):
return self.val
- items = [C(i) for i in range(100)]
- for i in range(100):
+ items = [C(i) for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD)]
+ for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
self.assertEqual(items[i][i], i)
binary_subscr_getitems()
@requires_specialization_ft
def test_compare_op(self):
def compare_op_int():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = 1, 2
c = a == b
self.assertFalse(c)
self.assert_no_opcode(compare_op_int, "COMPARE_OP")
def compare_op_float():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = 1.0, 2.0
c = a == b
self.assertFalse(c)
self.assert_no_opcode(compare_op_float, "COMPARE_OP")
def compare_op_str():
- for _ in range(100):
+ for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
a, b = "spam", "ham"
c = a == b
self.assertFalse(c)
projects / thirdparty / Python / cpython.git / commitdiff
