Debian Codegraph @

Lib/test/test_type_cache.py

raw
1 """ Tests for the internal type cache in CPython. """
2 import collections.abc
3 import dis
4 import unittest
5 import warnings
6 from test import support
7 from test.support import import_helper, requires_specialization, requires_specialization_ft
8 try:
9 from sys import _clear_type_cache
10 except ImportError:
11 _clear_type_cache = None
12
13 # Skip this test if the _testcapi module isn't available.
14 _testcapi = import_helper.import_module("_testcapi")
15 _testinternalcapi = import_helper.import_module("_testinternalcapi")
16 type_get_version = _testcapi.type_get_version
17 type_assign_specific_version_unsafe = _testinternalcapi.type_assign_specific_version_unsafe
18 type_assign_version = _testcapi.type_assign_version
19 type_modified = _testcapi.type_modified
20
21 def clear_type_cache():
22 with warnings.catch_warnings():
23 warnings.simplefilter("ignore", DeprecationWarning)
24 _clear_type_cache()
25
26 @support.cpython_only
27 @unittest.skipIf(_clear_type_cache is None, "requires sys._clear_type_cache")
28 class TypeCacheTests(unittest.TestCase):
29 def test_tp_version_tag_unique(self):
30 """tp_version_tag should be unique assuming no overflow, even after
31 clearing type cache.
32 """
33 # Check if global version tag has already overflowed.
34 Y = type('Y', (), {})
35 Y.x = 1
36 Y.x # Force a _PyType_Lookup, populating version tag
37 y_ver = type_get_version(Y)
38 # Overflow, or not enough left to conduct the test.
39 if y_ver == 0 or y_ver > 0xFFFFF000:
40 self.skipTest("Out of type version tags")
41 # Note: try to avoid any method lookups within this loop,
42 # It will affect global version tag.
43 all_version_tags = []
44 append_result = all_version_tags.append
45 assertNotEqual = self.assertNotEqual
46 for _ in range(30):
47 clear_type_cache()
48 X = type('Y', (), {})
49 X.x = 1
50 X.x
51 tp_version_tag_after = type_get_version(X)
52 assertNotEqual(tp_version_tag_after, 0, msg="Version overflowed")
53 append_result(tp_version_tag_after)
54 self.assertEqual(len(set(all_version_tags)), 30,
55 msg=f"{all_version_tags} contains non-unique versions")
56
57 def test_type_assign_version(self):
58 class C:
59 x = 5
60
61 self.assertEqual(type_assign_version(C), 1)
62 c_ver = type_get_version(C)
63
64 C.x = 6
65 self.assertEqual(type_get_version(C), 0)
66 self.assertEqual(type_assign_version(C), 1)
67 self.assertNotEqual(type_get_version(C), 0)
68 self.assertNotEqual(type_get_version(C), c_ver)
69
70 def test_type_assign_specific_version(self):
71 """meta-test for type_assign_specific_version_unsafe"""
72 class C:
73 pass
74
75 type_assign_version(C)
76 orig_version = type_get_version(C)
77 if orig_version == 0:
78 self.skipTest("Could not assign a valid type version")
79
80 type_modified(C)
81 type_assign_specific_version_unsafe(C, orig_version + 5)
82 type_assign_version(C) # this should do nothing
83
84 new_version = type_get_version(C)
85 self.assertEqual(new_version, orig_version + 5)
86
87 clear_type_cache()
88
89 def test_per_class_limit(self):
90 class C:
91 x = 0
92
93 type_assign_version(C)
94 orig_version = type_get_version(C)
95 for i in range(1001):
96 C.x = i
97 type_assign_version(C)
98
99 new_version = type_get_version(C)
100 self.assertEqual(new_version, 0)
101
102 def test_119462(self):
103
104 class Holder:
105 value = None
106
107 @classmethod
108 def set_value(cls):
109 cls.value = object()
110
111 class HolderSub(Holder):
112 pass
113
114 for _ in range(1050):
115 Holder.set_value()
116 HolderSub.value
117
118 def test_abc_register_invalidates_subclass_versions(self):
119 class Parent:
120 pass
121
122 class Child(Parent):
123 pass
124
125 type_assign_version(Parent)
126 type_assign_version(Child)
127 parent_version = type_get_version(Parent)
128 child_version = type_get_version(Child)
129 if parent_version == 0 or child_version == 0:
130 self.skipTest("Could not assign valid type versions")
131
132 collections.abc.Mapping.register(Parent)
133
134 self.assertEqual(type_get_version(Parent), 0)
135 self.assertEqual(type_get_version(Child), 0)
136
137 @support.cpython_only
138 class TypeCacheWithSpecializationTests(unittest.TestCase):
139 def tearDown(self):
140 clear_type_cache()
141
142 def _assign_valid_version_or_skip(self, type_):
143 type_modified(type_)
144 type_assign_version(type_)
145 if type_get_version(type_) == 0:
146 self.skipTest("Could not assign valid type version")
147
148 def _no_more_versions(self, user_type):
149 type_modified(user_type)
150 for _ in range(1001):
151 type_assign_specific_version_unsafe(user_type, 1000_000_000)
152 type_assign_specific_version_unsafe(user_type, 0)
153 self.assertEqual(type_get_version(user_type), 0)
154
155 def _all_opnames(self, func):
156 return set(instr.opname for instr in dis.Bytecode(func, adaptive=True))
157
158 def _check_specialization(self, func, arg, opname, *, should_specialize):
159 for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
160 func(arg)
161
162 if should_specialize:
163 self.assertNotIn(opname, self._all_opnames(func))
164 else:
165 self.assertIn(opname, self._all_opnames(func))
166
167 @requires_specialization
168 def test_class_load_attr_specialization_user_type(self):
169 class A:
170 def foo(self):
171 pass
172
173 self._assign_valid_version_or_skip(A)
174
175 def load_foo_1(type_):
176 type_.foo
177
178 self._check_specialization(load_foo_1, A, "LOAD_ATTR", should_specialize=True)
179 del load_foo_1
180
181 self._no_more_versions(A)
182
183 def load_foo_2(type_):
184 return type_.foo
185
186 self._check_specialization(load_foo_2, A, "LOAD_ATTR", should_specialize=False)
187
188 @requires_specialization
189 def test_class_load_attr_specialization_static_type(self):
190 self.assertNotEqual(type_get_version(str), 0)
191 self.assertNotEqual(type_get_version(bytes), 0)
192
193 def get_capitalize_1(type_):
194 return type_.capitalize
195
196 self._check_specialization(get_capitalize_1, str, "LOAD_ATTR", should_specialize=True)
197 self.assertEqual(get_capitalize_1(str)('hello'), 'Hello')
198 self.assertEqual(get_capitalize_1(bytes)(b'hello'), b'Hello')
199
200 @requires_specialization
201 def test_property_load_attr_specialization_user_type(self):
202 class G:
203 @property
204 def x(self):
205 return 9
206
207 self._assign_valid_version_or_skip(G)
208
209 def load_x_1(instance):
210 instance.x
211
212 self._check_specialization(load_x_1, G(), "LOAD_ATTR", should_specialize=True)
213 del load_x_1
214
215 self._no_more_versions(G)
216
217 def load_x_2(instance):
218 instance.x
219
220 self._check_specialization(load_x_2, G(), "LOAD_ATTR", should_specialize=False)
221
222 @requires_specialization
223 def test_store_attr_specialization_user_type(self):
224 class B:
225 __slots__ = ("bar",)
226
227 self._assign_valid_version_or_skip(B)
228
229 def store_bar_1(type_):
230 type_.bar = 10
231
232 self._check_specialization(store_bar_1, B(), "STORE_ATTR", should_specialize=True)
233 del store_bar_1
234
235 self._no_more_versions(B)
236
237 def store_bar_2(type_):
238 type_.bar = 10
239
240 self._check_specialization(store_bar_2, B(), "STORE_ATTR", should_specialize=False)
241
242 @requires_specialization_ft
243 def test_class_call_specialization_user_type(self):
244 class F:
245 def __init__(self):
246 pass
247
248 self._assign_valid_version_or_skip(F)
249
250 def call_class_1(type_):
251 type_()
252
253 self._check_specialization(call_class_1, F, "CALL", should_specialize=True)
254 del call_class_1
255
256 self._no_more_versions(F)
257
258 def call_class_2(type_):
259 type_()
260
261 self._check_specialization(call_class_2, F, "CALL", should_specialize=False)
262
263 @requires_specialization
264 def test_to_bool_specialization_user_type(self):
265 class H:
266 pass
267
268 self._assign_valid_version_or_skip(H)
269
270 def to_bool_1(instance):
271 not instance
272
273 self._check_specialization(to_bool_1, H(), "TO_BOOL", should_specialize=True)
274 del to_bool_1
275
276 self._no_more_versions(H)
277
278 def to_bool_2(instance):
279 not instance
280
281 self._check_specialization(to_bool_2, H(), "TO_BOOL", should_specialize=False)
282
283
284 if __name__ == "__main__":
285 unittest.main()