[Python-checkins] bpo-46072: Output stats as markdown with collapsible sections. (GH-31228)
markshannon
webhook-mailer at python.org
Wed Feb 9 07:30:40 EST 2022
https://github.com/python/cpython/commit/f71a69aa9209cf67cc1060051b147d6afa379bba
commit: f71a69aa9209cf67cc1060051b147d6afa379bba
branch: main
author: Mark Shannon <mark at hotpy.org>
committer: markshannon <mark at hotpy.org>
date: 2022-02-09T12:30:26Z
summary:
bpo-46072: Output stats as markdown with collapsible sections. (GH-31228)
files:
M Python/specialize.c
M Tools/scripts/summarize_stats.py
diff --git a/Python/specialize.c b/Python/specialize.c
index 21759231d28e6..b5e4de5d6d217 100644
--- a/Python/specialize.c
+++ b/Python/specialize.c
@@ -481,112 +481,123 @@ initial_counter_value(void) {
#define SPEC_FAIL_OUT_OF_VERSIONS 3
#define SPEC_FAIL_OUT_OF_RANGE 4
#define SPEC_FAIL_EXPECTED_ERROR 5
+#define SPEC_FAIL_WRONG_NUMBER_ARGUMENTS 6
+
+#define SPEC_FAIL_LOAD_GLOBAL_NON_STRING_OR_SPLIT 18
/* Attributes */
-#define SPEC_FAIL_NON_STRING_OR_SPLIT 6
-#define SPEC_FAIL_MODULE_ATTR_NOT_FOUND 7
-#define SPEC_FAIL_OVERRIDING_DESCRIPTOR 8
-#define SPEC_FAIL_NON_OVERRIDING_DESCRIPTOR 9
-#define SPEC_FAIL_NOT_DESCRIPTOR 10
-#define SPEC_FAIL_METHOD 11
-#define SPEC_FAIL_MUTABLE_CLASS 12
-#define SPEC_FAIL_PROPERTY 13
-#define SPEC_FAIL_NON_OBJECT_SLOT 14
-#define SPEC_FAIL_READ_ONLY 15
-#define SPEC_FAIL_AUDITED_SLOT 16
-#define SPEC_FAIL_NOT_MANAGED_DICT 17
+#define SPEC_FAIL_ATTR_OVERRIDING_DESCRIPTOR 8
+#define SPEC_FAIL_ATTR_NON_OVERRIDING_DESCRIPTOR 9
+#define SPEC_FAIL_ATTR_NOT_DESCRIPTOR 10
+#define SPEC_FAIL_ATTR_METHOD 11
+#define SPEC_FAIL_ATTR_MUTABLE_CLASS 12
+#define SPEC_FAIL_ATTR_PROPERTY 13
+#define SPEC_FAIL_ATTR_NON_OBJECT_SLOT 14
+#define SPEC_FAIL_ATTR_READ_ONLY 15
+#define SPEC_FAIL_ATTR_AUDITED_SLOT 16
+#define SPEC_FAIL_ATTR_NOT_MANAGED_DICT 17
+#define SPEC_FAIL_ATTR_NON_STRING_OR_SPLIT 18
+#define SPEC_FAIL_ATTR_MODULE_ATTR_NOT_FOUND 19
/* Methods */
-#define SPEC_FAIL_IS_ATTR 15
-#define SPEC_FAIL_DICT_SUBCLASS 16
-#define SPEC_FAIL_BUILTIN_CLASS_METHOD 17
-#define SPEC_FAIL_CLASS_METHOD_OBJ 18
-#define SPEC_FAIL_OBJECT_SLOT 19
-#define SPEC_FAIL_HAS_DICT 20
-#define SPEC_FAIL_HAS_MANAGED_DICT 21
-#define SPEC_FAIL_INSTANCE_ATTRIBUTE 22
-#define SPEC_FAIL_METACLASS_ATTRIBUTE 23
-
-/* Binary subscr */
-
-#define SPEC_FAIL_ARRAY_INT 8
-#define SPEC_FAIL_ARRAY_SLICE 9
-#define SPEC_FAIL_LIST_SLICE 10
-#define SPEC_FAIL_TUPLE_SLICE 11
-#define SPEC_FAIL_STRING_INT 12
-#define SPEC_FAIL_STRING_SLICE 13
-#define SPEC_FAIL_BUFFER_INT 15
-#define SPEC_FAIL_BUFFER_SLICE 16
-#define SPEC_FAIL_SEQUENCE_INT 17
+#define SPEC_FAIL_LOAD_METHOD_OVERRIDING_DESCRIPTOR 8
+#define SPEC_FAIL_LOAD_METHOD_NON_OVERRIDING_DESCRIPTOR 9
+#define SPEC_FAIL_LOAD_METHOD_NOT_DESCRIPTOR 10
+#define SPEC_FAIL_LOAD_METHOD_METHOD 11
+#define SPEC_FAIL_LOAD_METHOD_MUTABLE_CLASS 12
+#define SPEC_FAIL_LOAD_METHOD_PROPERTY 13
+#define SPEC_FAIL_LOAD_METHOD_NON_OBJECT_SLOT 14
+#define SPEC_FAIL_LOAD_METHOD_IS_ATTR 15
+#define SPEC_FAIL_LOAD_METHOD_DICT_SUBCLASS 16
+#define SPEC_FAIL_LOAD_METHOD_BUILTIN_CLASS_METHOD 17
+#define SPEC_FAIL_LOAD_METHOD_CLASS_METHOD_OBJ 18
+#define SPEC_FAIL_LOAD_METHOD_OBJECT_SLOT 19
+#define SPEC_FAIL_LOAD_METHOD_HAS_DICT 20
+#define SPEC_FAIL_LOAD_METHOD_HAS_MANAGED_DICT 21
+#define SPEC_FAIL_LOAD_METHOD_INSTANCE_ATTRIBUTE 22
+#define SPEC_FAIL_LOAD_METHOD_METACLASS_ATTRIBUTE 23
+
+/* Binary subscr and store subscr */
+
+#define SPEC_FAIL_SUBSCR_ARRAY_INT 8
+#define SPEC_FAIL_SUBSCR_ARRAY_SLICE 9
+#define SPEC_FAIL_SUBSCR_LIST_SLICE 10
+#define SPEC_FAIL_SUBSCR_TUPLE_SLICE 11
+#define SPEC_FAIL_SUBSCR_STRING_INT 12
+#define SPEC_FAIL_SUBSCR_STRING_SLICE 13
+#define SPEC_FAIL_SUBSCR_BUFFER_INT 15
+#define SPEC_FAIL_SUBSCR_BUFFER_SLICE 16
+#define SPEC_FAIL_SUBSCR_SEQUENCE_INT 17
/* Store subscr */
-#define SPEC_FAIL_BYTEARRAY_INT 18
-#define SPEC_FAIL_BYTEARRAY_SLICE 19
-#define SPEC_FAIL_PY_SIMPLE 20
-#define SPEC_FAIL_PY_OTHER 21
-#define SPEC_FAIL_DICT_SUBCLASS_NO_OVERRIDE 22
+#define SPEC_FAIL_SUBSCR_BYTEARRAY_INT 18
+#define SPEC_FAIL_SUBSCR_BYTEARRAY_SLICE 19
+#define SPEC_FAIL_SUBSCR_PY_SIMPLE 20
+#define SPEC_FAIL_SUBSCR_PY_OTHER 21
+#define SPEC_FAIL_SUBSCR_DICT_SUBCLASS_NO_OVERRIDE 22
/* Binary add */
-#define SPEC_FAIL_NON_FUNCTION_SCOPE 11
-#define SPEC_FAIL_DIFFERENT_TYPES 12
+#define SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES 12
/* Calls */
-#define SPEC_FAIL_COMPLEX_PARAMETERS 8
-#define SPEC_FAIL_WRONG_NUMBER_ARGUMENTS 9
-#define SPEC_FAIL_CO_NOT_OPTIMIZED 10
+#define SPEC_FAIL_CALL_COMPLEX_PARAMETERS 9
+#define SPEC_FAIL_CALL_CO_NOT_OPTIMIZED 10
/* SPEC_FAIL_METHOD defined as 11 above */
-#define SPEC_FAIL_PYCFUNCTION 13
-#define SPEC_FAIL_PYCFUNCTION_WITH_KEYWORDS 14
-#define SPEC_FAIL_PYCFUNCTION_FAST_WITH_KEYWORDS 15
-#define SPEC_FAIL_PYCFUNCTION_NOARGS 16
-#define SPEC_FAIL_BAD_CALL_FLAGS 17
-#define SPEC_FAIL_CLASS 18
-#define SPEC_FAIL_PYTHON_CLASS 19
-#define SPEC_FAIL_C_METHOD_CALL 20
-#define SPEC_FAIL_BOUND_METHOD 21
+#define SPEC_FAIL_CALL_INSTANCE_METHOD 11
+#define SPEC_FAIL_CALL_CMETHOD 12
+#define SPEC_FAIL_CALL_PYCFUNCTION 13
+#define SPEC_FAIL_CALL_PYCFUNCTION_WITH_KEYWORDS 14
+#define SPEC_FAIL_CALL_PYCFUNCTION_FAST_WITH_KEYWORDS 15
+#define SPEC_FAIL_CALL_PYCFUNCTION_NOARGS 16
+#define SPEC_FAIL_CALL_BAD_CALL_FLAGS 17
+#define SPEC_FAIL_CALL_CLASS 18
+#define SPEC_FAIL_CALL_PYTHON_CLASS 19
+#define SPEC_FAIL_CALL_C_METHOD_CALL 20
+#define SPEC_FAIL_CALL_BOUND_METHOD 21
#define SPEC_FAIL_CALL_STR 22
-#define SPEC_FAIL_CLASS_NO_VECTORCALL 23
-#define SPEC_FAIL_CLASS_MUTABLE 24
-#define SPEC_FAIL_KWNAMES 25
-#define SPEC_FAIL_METHOD_WRAPPER 26
-#define SPEC_FAIL_OPERATOR_WRAPPER 27
+#define SPEC_FAIL_CALL_CLASS_NO_VECTORCALL 23
+#define SPEC_FAIL_CALL_CLASS_MUTABLE 24
+#define SPEC_FAIL_CALL_KWNAMES 25
+#define SPEC_FAIL_CALL_METHOD_WRAPPER 26
+#define SPEC_FAIL_CALL_OPERATOR_WRAPPER 27
/* COMPARE_OP */
-#define SPEC_FAIL_STRING_COMPARE 13
-#define SPEC_FAIL_NOT_FOLLOWED_BY_COND_JUMP 14
-#define SPEC_FAIL_BIG_INT 15
-#define SPEC_FAIL_COMPARE_BYTES 16
-#define SPEC_FAIL_COMPARE_TUPLE 17
-#define SPEC_FAIL_COMPARE_LIST 18
-#define SPEC_FAIL_COMPARE_SET 19
-#define SPEC_FAIL_COMPARE_BOOL 20
-#define SPEC_FAIL_COMPARE_BASEOBJECT 21
-#define SPEC_FAIL_COMPARE_FLOAT_LONG 22
-#define SPEC_FAIL_COMPARE_LONG_FLOAT 23
+#define SPEC_FAIL_COMPARE_OP_DIFFERENT_TYPES 12
+#define SPEC_FAIL_COMPARE_OP_STRING 13
+#define SPEC_FAIL_COMPARE_OP_NOT_FOLLOWED_BY_COND_JUMP 14
+#define SPEC_FAIL_COMPARE_OP_BIG_INT 15
+#define SPEC_FAIL_COMPARE_OP_BYTES 16
+#define SPEC_FAIL_COMPARE_OP_TUPLE 17
+#define SPEC_FAIL_COMPARE_OP_LIST 18
+#define SPEC_FAIL_COMPARE_OP_SET 19
+#define SPEC_FAIL_COMPARE_OP_BOOL 20
+#define SPEC_FAIL_COMPARE_OP_BASEOBJECT 21
+#define SPEC_FAIL_COMPARE_OP_FLOAT_LONG 22
+#define SPEC_FAIL_COMPARE_OP_LONG_FLOAT 23
/* FOR_ITER */
-#define SPEC_FAIL_ITER_GENERATOR 10
-#define SPEC_FAIL_ITER_COROUTINE 11
-#define SPEC_FAIL_ITER_ASYNC_GENERATOR 12
-#define SPEC_FAIL_ITER_LIST 13
-#define SPEC_FAIL_ITER_TUPLE 14
-#define SPEC_FAIL_ITER_SET 15
-#define SPEC_FAIL_ITER_STRING 16
-#define SPEC_FAIL_ITER_BYTES 17
-#define SPEC_FAIL_ITER_RANGE 18
-#define SPEC_FAIL_ITER_ITERTOOLS 19
-#define SPEC_FAIL_ITER_DICT_KEYS 20
-#define SPEC_FAIL_ITER_DICT_ITEMS 21
-#define SPEC_FAIL_ITER_DICT_VALUES 22
-#define SPEC_FAIL_ITER_ENUMERATE 23
+#define SPEC_FAIL_FOR_ITER_GENERATOR 10
+#define SPEC_FAIL_FOR_ITER_COROUTINE 11
+#define SPEC_FAIL_FOR_ITER_ASYNC_GENERATOR 12
+#define SPEC_FAIL_FOR_ITER_LIST 13
+#define SPEC_FAIL_FOR_ITER_TUPLE 14
+#define SPEC_FAIL_FOR_ITER_SET 15
+#define SPEC_FAIL_FOR_ITER_STRING 16
+#define SPEC_FAIL_FOR_ITER_BYTES 17
+#define SPEC_FAIL_FOR_ITER_RANGE 18
+#define SPEC_FAIL_FOR_ITER_ITERTOOLS 19
+#define SPEC_FAIL_FOR_ITER_DICT_KEYS 20
+#define SPEC_FAIL_FOR_ITER_DICT_ITEMS 21
+#define SPEC_FAIL_FOR_ITER_DICT_VALUES 22
+#define SPEC_FAIL_FOR_ITER_ENUMERATE 23
/* UNPACK_SEQUENCE */
-#define SPEC_FAIL_TUPLE 10
-#define SPEC_FAIL_LIST 11
+#define SPEC_FAIL_UNPACK_SEQUENCE_TUPLE 10
+#define SPEC_FAIL_UNPACK_SEQUENCE_LIST 11
static int
@@ -604,14 +615,14 @@ specialize_module_load_attr(
return -1;
}
if (dict->ma_keys->dk_kind != DICT_KEYS_UNICODE) {
- SPECIALIZATION_FAIL(opcode, SPEC_FAIL_NON_STRING_OR_SPLIT);
+ SPECIALIZATION_FAIL(opcode, SPEC_FAIL_ATTR_NON_STRING_OR_SPLIT);
return -1;
}
Py_ssize_t index = _PyDict_GetItemHint(dict, &_Py_ID(__getattr__), -1,
&value);
assert(index != DKIX_ERROR);
if (index != DKIX_EMPTY) {
- SPECIALIZATION_FAIL(opcode, SPEC_FAIL_MODULE_ATTR_NOT_FOUND);
+ SPECIALIZATION_FAIL(opcode, SPEC_FAIL_ATTR_MODULE_ATTR_NOT_FOUND);
return -1;
}
index = _PyDict_GetItemHint(dict, name, -1, &value);
@@ -721,7 +732,7 @@ specialize_dict_access(
kind == BUILTIN_CLASSMETHOD || kind == PYTHON_CLASSMETHOD);
// No descriptor, or non overriding.
if ((type->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0) {
- SPECIALIZATION_FAIL(base_op, SPEC_FAIL_NOT_MANAGED_DICT);
+ SPECIALIZATION_FAIL(base_op, SPEC_FAIL_ATTR_NOT_MANAGED_DICT);
return 0;
}
PyObject **dictptr = _PyObject_ManagedDictPointer(owner);
@@ -783,13 +794,13 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, Sp
DescriptorClassification kind = analyze_descriptor(type, name, &descr, 0);
switch(kind) {
case OVERRIDING:
- SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_OVERRIDING_DESCRIPTOR);
+ SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_OVERRIDING_DESCRIPTOR);
goto fail;
case METHOD:
- SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_METHOD);
+ SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_METHOD);
goto fail;
case PROPERTY:
- SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_PROPERTY);
+ SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_PROPERTY);
goto fail;
case OBJECT_SLOT:
{
@@ -797,7 +808,7 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, Sp
struct PyMemberDef *dmem = member->d_member;
Py_ssize_t offset = dmem->offset;
if (dmem->flags & PY_AUDIT_READ) {
- SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_AUDITED_SLOT);
+ SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_AUDITED_SLOT);
goto fail;
}
if (offset != (uint16_t)offset) {
@@ -821,10 +832,10 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, Sp
goto success;
}
case OTHER_SLOT:
- SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_NON_OBJECT_SLOT);
+ SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_NON_OBJECT_SLOT);
goto fail;
case MUTABLE:
- SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_MUTABLE_CLASS);
+ SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_MUTABLE_CLASS);
goto fail;
case GETSET_OVERRIDDEN:
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_OVERRIDDEN);
@@ -872,13 +883,13 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, S
DescriptorClassification kind = analyze_descriptor(type, name, &descr, 1);
switch(kind) {
case OVERRIDING:
- SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_OVERRIDING_DESCRIPTOR);
+ SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_OVERRIDING_DESCRIPTOR);
goto fail;
case METHOD:
- SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_METHOD);
+ SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_METHOD);
goto fail;
case PROPERTY:
- SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_PROPERTY);
+ SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_PROPERTY);
goto fail;
case OBJECT_SLOT:
{
@@ -886,7 +897,7 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, S
struct PyMemberDef *dmem = member->d_member;
Py_ssize_t offset = dmem->offset;
if (dmem->flags & READONLY) {
- SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_READ_ONLY);
+ SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_READ_ONLY);
goto fail;
}
if (offset != (uint16_t)offset) {
@@ -902,10 +913,10 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, S
}
case DUNDER_CLASS:
case OTHER_SLOT:
- SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_NON_OBJECT_SLOT);
+ SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_NON_OBJECT_SLOT);
goto fail;
case MUTABLE:
- SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_MUTABLE_CLASS);
+ SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_MUTABLE_CLASS);
goto fail;
case GETSET_OVERRIDDEN:
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_OVERRIDDEN);
@@ -947,31 +958,31 @@ load_method_fail_kind(DescriptorClassification kind)
{
switch (kind) {
case OVERRIDING:
- return SPEC_FAIL_OVERRIDING_DESCRIPTOR;
+ return SPEC_FAIL_LOAD_METHOD_OVERRIDING_DESCRIPTOR;
case METHOD:
- return SPEC_FAIL_METHOD;
+ return SPEC_FAIL_LOAD_METHOD_METHOD;
case PROPERTY:
- return SPEC_FAIL_PROPERTY;
+ return SPEC_FAIL_LOAD_METHOD_PROPERTY;
case OBJECT_SLOT:
- return SPEC_FAIL_OBJECT_SLOT;
+ return SPEC_FAIL_LOAD_METHOD_OBJECT_SLOT;
case OTHER_SLOT:
- return SPEC_FAIL_NON_OBJECT_SLOT;
+ return SPEC_FAIL_LOAD_METHOD_NON_OBJECT_SLOT;
case DUNDER_CLASS:
return SPEC_FAIL_OTHER;
case MUTABLE:
- return SPEC_FAIL_MUTABLE_CLASS;
+ return SPEC_FAIL_LOAD_METHOD_MUTABLE_CLASS;
case GETSET_OVERRIDDEN:
return SPEC_FAIL_OVERRIDDEN;
case BUILTIN_CLASSMETHOD:
- return SPEC_FAIL_BUILTIN_CLASS_METHOD;
+ return SPEC_FAIL_LOAD_METHOD_BUILTIN_CLASS_METHOD;
case PYTHON_CLASSMETHOD:
- return SPEC_FAIL_CLASS_METHOD_OBJ;
+ return SPEC_FAIL_LOAD_METHOD_CLASS_METHOD_OBJ;
case NON_OVERRIDING:
- return SPEC_FAIL_NON_OVERRIDING_DESCRIPTOR;
+ return SPEC_FAIL_LOAD_METHOD_NON_OVERRIDING_DESCRIPTOR;
case NON_DESCRIPTOR:
- return SPEC_FAIL_NOT_DESCRIPTOR;
+ return SPEC_FAIL_LOAD_METHOD_NOT_DESCRIPTOR;
case ABSENT:
- return SPEC_FAIL_INSTANCE_ATTRIBUTE;
+ return SPEC_FAIL_LOAD_METHOD_INSTANCE_ATTRIBUTE;
}
Py_UNREACHABLE();
}
@@ -995,7 +1006,7 @@ specialize_class_load_method(PyObject *owner, _Py_CODEUNIT *instr, PyObject *nam
#ifdef Py_STATS
case ABSENT:
if (_PyType_Lookup(Py_TYPE(owner), name) != NULL) {
- SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_METACLASS_ATTRIBUTE);
+ SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_METACLASS_ATTRIBUTE);
}
else {
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_EXPECTED_ERROR);
@@ -1051,13 +1062,13 @@ _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name,
if (owner_cls->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
PyObject **owner_dictptr = _PyObject_ManagedDictPointer(owner);
if (*owner_dictptr) {
- SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_HAS_MANAGED_DICT);
+ SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_HAS_MANAGED_DICT);
goto fail;
}
PyDictKeysObject *keys = ((PyHeapTypeObject *)owner_cls)->ht_cached_keys;
Py_ssize_t index = _PyDictKeys_StringLookup(keys, name);
if (index != DKIX_EMPTY) {
- SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_IS_ATTR);
+ SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_IS_ATTR);
goto fail;
}
uint32_t keys_version = _PyDictKeys_GetVersionForCurrentState(keys);
@@ -1073,7 +1084,7 @@ _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name,
*instr = _Py_MAKECODEUNIT(LOAD_METHOD_NO_DICT, _Py_OPARG(*instr));
}
else {
- SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_HAS_DICT);
+ SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_HAS_DICT);
goto fail;
}
}
@@ -1122,7 +1133,7 @@ _Py_Specialize_LoadGlobal(
PyDictKeysObject * globals_keys = ((PyDictObject *)globals)->ma_keys;
Py_ssize_t index = _PyDictKeys_StringLookup(globals_keys, name);
if (index == DKIX_ERROR) {
- SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_NON_STRING_OR_SPLIT);
+ SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_LOAD_GLOBAL_NON_STRING_OR_SPLIT);
goto fail;
}
if (index != DKIX_EMPTY) {
@@ -1144,7 +1155,7 @@ _Py_Specialize_LoadGlobal(
PyDictKeysObject * builtin_keys = ((PyDictObject *)builtins)->ma_keys;
index = _PyDictKeys_StringLookup(builtin_keys, name);
if (index == DKIX_ERROR) {
- SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_NON_STRING_OR_SPLIT);
+ SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_LOAD_GLOBAL_NON_STRING_OR_SPLIT);
goto fail;
}
if (index != (uint16_t)index) {
@@ -1183,34 +1194,34 @@ binary_subscr_fail_kind(PyTypeObject *container_type, PyObject *sub)
{
if (container_type == &PyUnicode_Type) {
if (PyLong_CheckExact(sub)) {
- return SPEC_FAIL_STRING_INT;
+ return SPEC_FAIL_SUBSCR_STRING_INT;
}
if (PySlice_Check(sub)) {
- return SPEC_FAIL_STRING_SLICE;
+ return SPEC_FAIL_SUBSCR_STRING_SLICE;
}
return SPEC_FAIL_OTHER;
}
else if (strcmp(container_type->tp_name, "array.array") == 0) {
if (PyLong_CheckExact(sub)) {
- return SPEC_FAIL_ARRAY_INT;
+ return SPEC_FAIL_SUBSCR_ARRAY_INT;
}
if (PySlice_Check(sub)) {
- return SPEC_FAIL_ARRAY_SLICE;
+ return SPEC_FAIL_SUBSCR_ARRAY_SLICE;
}
return SPEC_FAIL_OTHER;
}
else if (container_type->tp_as_buffer) {
if (PyLong_CheckExact(sub)) {
- return SPEC_FAIL_BUFFER_INT;
+ return SPEC_FAIL_SUBSCR_BUFFER_INT;
}
if (PySlice_Check(sub)) {
- return SPEC_FAIL_BUFFER_SLICE;
+ return SPEC_FAIL_SUBSCR_BUFFER_SLICE;
}
return SPEC_FAIL_OTHER;
}
else if (container_type->tp_as_sequence) {
if (PyLong_CheckExact(sub) && container_type->tp_as_sequence->sq_item) {
- return SPEC_FAIL_SEQUENCE_INT;
+ return SPEC_FAIL_SUBSCR_SEQUENCE_INT;
}
}
return SPEC_FAIL_OTHER;
@@ -1224,10 +1235,10 @@ static int
function_kind(PyCodeObject *code) {
int flags = code->co_flags;
if ((flags & (CO_VARKEYWORDS | CO_VARARGS)) || code->co_kwonlyargcount) {
- return SPEC_FAIL_COMPLEX_PARAMETERS;
+ return SPEC_FAIL_CALL_COMPLEX_PARAMETERS;
}
if ((flags & CO_OPTIMIZED) == 0) {
- return SPEC_FAIL_CO_NOT_OPTIMIZED;
+ return SPEC_FAIL_CALL_CO_NOT_OPTIMIZED;
}
return SIMPLE_FUNCTION;
}
@@ -1244,7 +1255,7 @@ _Py_Specialize_BinarySubscr(
goto success;
}
SPECIALIZATION_FAIL(BINARY_SUBSCR,
- PySlice_Check(sub) ? SPEC_FAIL_LIST_SLICE : SPEC_FAIL_OTHER);
+ PySlice_Check(sub) ? SPEC_FAIL_SUBSCR_LIST_SLICE : SPEC_FAIL_OTHER);
goto fail;
}
if (container_type == &PyTuple_Type) {
@@ -1253,7 +1264,7 @@ _Py_Specialize_BinarySubscr(
goto success;
}
SPECIALIZATION_FAIL(BINARY_SUBSCR,
- PySlice_Check(sub) ? SPEC_FAIL_TUPLE_SLICE : SPEC_FAIL_OTHER);
+ PySlice_Check(sub) ? SPEC_FAIL_SUBSCR_TUPLE_SLICE : SPEC_FAIL_OTHER);
goto fail;
}
if (container_type == &PyDict_Type) {
@@ -1319,7 +1330,7 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
}
else if (PySlice_Check(sub)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_LIST_SLICE);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_LIST_SLICE);
goto fail;
}
else {
@@ -1336,7 +1347,7 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
PyMappingMethods *as_mapping = container_type->tp_as_mapping;
if (as_mapping && (as_mapping->mp_ass_subscript
== PyDict_Type.tp_as_mapping->mp_ass_subscript)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_DICT_SUBCLASS_NO_OVERRIDE);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_DICT_SUBCLASS_NO_OVERRIDE);
goto fail;
}
if (PyObject_CheckBuffer(container)) {
@@ -1345,10 +1356,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
else if (strcmp(container_type->tp_name, "array.array") == 0) {
if (PyLong_CheckExact(sub)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_ARRAY_INT);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_ARRAY_INT);
}
else if (PySlice_Check(sub)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_ARRAY_SLICE);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_ARRAY_SLICE);
}
else {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_OTHER);
@@ -1356,10 +1367,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
else if (PyByteArray_CheckExact(container)) {
if (PyLong_CheckExact(sub)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BYTEARRAY_INT);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BYTEARRAY_INT);
}
else if (PySlice_Check(sub)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BYTEARRAY_SLICE);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BYTEARRAY_SLICE);
}
else {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_OTHER);
@@ -1367,10 +1378,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
else {
if (PyLong_CheckExact(sub)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BUFFER_INT);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BUFFER_INT);
}
else if (PySlice_Check(sub)) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BUFFER_SLICE);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BUFFER_SLICE);
}
else {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_OTHER);
@@ -1384,10 +1395,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
PyCodeObject *code = (PyCodeObject *)func->func_code;
int kind = function_kind(code);
if (kind == SIMPLE_FUNCTION) {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_PY_SIMPLE);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_PY_SIMPLE);
}
else {
- SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_PY_OTHER);
+ SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_PY_OTHER);
}
goto fail;
}
@@ -1411,7 +1422,7 @@ specialize_class_call(
{
PyTypeObject *tp = _PyType_CAST(callable);
if (tp->tp_new == PyBaseObject_Type.tp_new) {
- SPECIALIZATION_FAIL(CALL, SPEC_FAIL_PYTHON_CLASS);
+ SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_PYTHON_CLASS);
return -1;
}
if (tp->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) {
@@ -1434,10 +1445,10 @@ specialize_class_call(
return 0;
}
SPECIALIZATION_FAIL(CALL, tp == &PyUnicode_Type ?
- SPEC_FAIL_CALL_STR : SPEC_FAIL_CLASS_NO_VECTORCALL);
+ SPEC_FAIL_CALL_STR : SPEC_FAIL_CALL_CLASS_NO_VECTORCALL);
return -1;
}
- SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CLASS_MUTABLE);
+ SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_CLASS_MUTABLE);
return -1;
}
@@ -1448,19 +1459,19 @@ builtin_call_fail_kind(int ml_flags)
switch (ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O |
METH_KEYWORDS | METH_METHOD)) {
case METH_VARARGS:
- return SPEC_FAIL_PYCFUNCTION;
+ return SPEC_FAIL_CALL_PYCFUNCTION;
case METH_VARARGS | METH_KEYWORDS:
- return SPEC_FAIL_PYCFUNCTION_WITH_KEYWORDS;
+ return SPEC_FAIL_CALL_PYCFUNCTION_WITH_KEYWORDS;
case METH_FASTCALL | METH_KEYWORDS:
- return SPEC_FAIL_PYCFUNCTION_FAST_WITH_KEYWORDS;
+ return SPEC_FAIL_CALL_PYCFUNCTION_FAST_WITH_KEYWORDS;
case METH_NOARGS:
- return SPEC_FAIL_PYCFUNCTION_NOARGS;
+ return SPEC_FAIL_CALL_PYCFUNCTION_NOARGS;
/* This case should never happen with PyCFunctionObject -- only
PyMethodObject. See zlib.compressobj()'s methods for an example.
*/
case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
default:
- return SPEC_FAIL_BAD_CALL_FLAGS;
+ return SPEC_FAIL_CALL_BAD_CALL_FLAGS;
}
}
#endif
@@ -1473,7 +1484,7 @@ specialize_method_descriptor(
int nargs, PyObject *kwnames, SpecializedCacheEntry *cache)
{
if (kwnames) {
- SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
+ SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (_list_append == NULL) {
@@ -1528,7 +1539,7 @@ specialize_py_call(
PyCodeObject *code = (PyCodeObject *)func->func_code;
int kind = function_kind(code);
if (kwnames) {
- SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
+ SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (kind != SIMPLE_FUNCTION) {
@@ -1585,7 +1596,7 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
METH_KEYWORDS | METH_METHOD)) {
case METH_O: {
if (kwnames) {
- SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
+ SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (nargs != 1) {
@@ -1606,7 +1617,7 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
}
case METH_FASTCALL: {
if (kwnames) {
- SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
+ SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (nargs == 2) {
@@ -1641,26 +1652,23 @@ static int
call_fail_kind(PyObject *callable)
{
if (PyInstanceMethod_Check(callable)) {
- return SPEC_FAIL_METHOD;
+ return SPEC_FAIL_CALL_INSTANCE_METHOD;
}
else if (PyMethod_Check(callable)) {
- return SPEC_FAIL_METHOD;
+ return SPEC_FAIL_CALL_BOUND_METHOD;
}
// builtin method
else if (PyCMethod_Check(callable)) {
- return SPEC_FAIL_METHOD;
+ return SPEC_FAIL_CALL_CMETHOD;
}
else if (PyType_Check(callable)) {
- return SPEC_FAIL_CLASS;
+ return SPEC_FAIL_CALL_CLASS;
}
else if (Py_TYPE(callable) == &PyWrapperDescr_Type) {
- return SPEC_FAIL_OPERATOR_WRAPPER;
+ return SPEC_FAIL_CALL_OPERATOR_WRAPPER;
}
else if (Py_TYPE(callable) == &_PyMethodWrapper_Type) {
- return SPEC_FAIL_METHOD_WRAPPER;
- }
- else if (Py_TYPE(callable) == &PyMethod_Type) {
- return SPEC_FAIL_BOUND_METHOD;
+ return SPEC_FAIL_CALL_METHOD_WRAPPER;
}
return SPEC_FAIL_OTHER;
}
@@ -1716,7 +1724,7 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
case NB_ADD:
case NB_INPLACE_ADD:
if (!Py_IS_TYPE(lhs, Py_TYPE(rhs))) {
- SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_DIFFERENT_TYPES);
+ SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES);
goto failure;
}
if (PyUnicode_CheckExact(lhs)) {
@@ -1742,7 +1750,7 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
case NB_MULTIPLY:
case NB_INPLACE_MULTIPLY:
if (!Py_IS_TYPE(lhs, Py_TYPE(rhs))) {
- SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_DIFFERENT_TYPES);
+ SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES);
goto failure;
}
if (PyLong_CheckExact(lhs)) {
@@ -1759,7 +1767,7 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
case NB_SUBTRACT:
case NB_INPLACE_SUBTRACT:
if (!Py_IS_TYPE(lhs, Py_TYPE(rhs))) {
- SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_DIFFERENT_TYPES);
+ SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES);
goto failure;
}
if (PyLong_CheckExact(lhs)) {
@@ -1796,30 +1804,30 @@ compare_op_fail_kind(PyObject *lhs, PyObject *rhs)
{
if (Py_TYPE(lhs) != Py_TYPE(rhs)) {
if (PyFloat_CheckExact(lhs) && PyLong_CheckExact(rhs)) {
- return SPEC_FAIL_COMPARE_FLOAT_LONG;
+ return SPEC_FAIL_COMPARE_OP_FLOAT_LONG;
}
if (PyLong_CheckExact(lhs) && PyFloat_CheckExact(rhs)) {
- return SPEC_FAIL_COMPARE_LONG_FLOAT;
+ return SPEC_FAIL_COMPARE_OP_LONG_FLOAT;
}
- return SPEC_FAIL_DIFFERENT_TYPES;
+ return SPEC_FAIL_COMPARE_OP_DIFFERENT_TYPES;
}
if (PyBytes_CheckExact(lhs)) {
- return SPEC_FAIL_COMPARE_BYTES;
+ return SPEC_FAIL_COMPARE_OP_BYTES;
}
if (PyTuple_CheckExact(lhs)) {
- return SPEC_FAIL_COMPARE_TUPLE;
+ return SPEC_FAIL_COMPARE_OP_TUPLE;
}
if (PyList_CheckExact(lhs)) {
- return SPEC_FAIL_COMPARE_LIST;
+ return SPEC_FAIL_COMPARE_OP_LIST;
}
if (PySet_CheckExact(lhs) || PyFrozenSet_CheckExact(lhs)) {
- return SPEC_FAIL_COMPARE_SET;
+ return SPEC_FAIL_COMPARE_OP_SET;
}
if (PyBool_Check(lhs)) {
- return SPEC_FAIL_COMPARE_BOOL;
+ return SPEC_FAIL_COMPARE_OP_BOOL;
}
if (Py_TYPE(lhs)->tp_richcompare == PyBaseObject_Type.tp_richcompare) {
- return SPEC_FAIL_COMPARE_BASEOBJECT;
+ return SPEC_FAIL_COMPARE_OP_BASEOBJECT;
}
return SPEC_FAIL_OTHER;
}
@@ -1847,7 +1855,7 @@ _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs,
int next_opcode = _Py_OPCODE(instr[1]);
if (next_opcode != POP_JUMP_IF_FALSE && next_opcode != POP_JUMP_IF_TRUE) {
// Can't ever combine, so don't don't bother being adaptive.
- SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_NOT_FOLLOWED_BY_COND_JUMP);
+ SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_COMPARE_OP_NOT_FOLLOWED_BY_COND_JUMP);
*instr = _Py_MAKECODEUNIT(COMPARE_OP, adaptive->original_oparg);
goto failure;
}
@@ -1872,13 +1880,13 @@ _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs,
goto success;
}
else {
- SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_BIG_INT);
+ SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_COMPARE_OP_BIG_INT);
goto failure;
}
}
if (PyUnicode_CheckExact(lhs)) {
if (op != Py_EQ && op != Py_NE) {
- SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_STRING_COMPARE);
+ SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_COMPARE_OP_STRING);
goto failure;
}
else {
@@ -1901,48 +1909,48 @@ int
_PySpecialization_ClassifyIterator(PyObject *iter)
{
if (PyGen_CheckExact(iter)) {
- return SPEC_FAIL_ITER_GENERATOR;
+ return SPEC_FAIL_FOR_ITER_GENERATOR;
}
if (PyCoro_CheckExact(iter)) {
- return SPEC_FAIL_ITER_COROUTINE;
+ return SPEC_FAIL_FOR_ITER_COROUTINE;
}
if (PyAsyncGen_CheckExact(iter)) {
- return SPEC_FAIL_ITER_ASYNC_GENERATOR;
+ return SPEC_FAIL_FOR_ITER_ASYNC_GENERATOR;
}
PyTypeObject *t = _Py_TYPE(iter);
if (t == &PyListIter_Type) {
- return SPEC_FAIL_ITER_LIST;
+ return SPEC_FAIL_FOR_ITER_LIST;
}
if (t == &PyTupleIter_Type) {
- return SPEC_FAIL_ITER_TUPLE;
+ return SPEC_FAIL_FOR_ITER_TUPLE;
}
if (t == &PyDictIterKey_Type) {
- return SPEC_FAIL_ITER_DICT_KEYS;
+ return SPEC_FAIL_FOR_ITER_DICT_KEYS;
}
if (t == &PyDictIterValue_Type) {
- return SPEC_FAIL_ITER_DICT_VALUES;
+ return SPEC_FAIL_FOR_ITER_DICT_VALUES;
}
if (t == &PyDictIterItem_Type) {
- return SPEC_FAIL_ITER_DICT_ITEMS;
+ return SPEC_FAIL_FOR_ITER_DICT_ITEMS;
}
if (t == &PySetIter_Type) {
- return SPEC_FAIL_ITER_SET;
+ return SPEC_FAIL_FOR_ITER_SET;
}
if (t == &PyUnicodeIter_Type) {
- return SPEC_FAIL_ITER_STRING;
+ return SPEC_FAIL_FOR_ITER_STRING;
}
if (t == &PyBytesIter_Type) {
- return SPEC_FAIL_ITER_BYTES;
+ return SPEC_FAIL_FOR_ITER_BYTES;
}
if (t == &PyRangeIter_Type) {
- return SPEC_FAIL_ITER_RANGE;
+ return SPEC_FAIL_FOR_ITER_RANGE;
}
if (t == &PyEnum_Type) {
- return SPEC_FAIL_ITER_ENUMERATE;
+ return SPEC_FAIL_FOR_ITER_ENUMERATE;
}
if (strncmp(t->tp_name, "itertools", 8) == 0) {
- return SPEC_FAIL_ITER_ITERTOOLS;
+ return SPEC_FAIL_FOR_ITER_ITERTOOLS;
}
return SPEC_FAIL_OTHER;
}
@@ -1951,10 +1959,10 @@ int
_PySpecialization_ClassifySequence(PyObject *seq)
{
if (PyTuple_CheckExact(seq)) {
- return SPEC_FAIL_TUPLE;
+ return SPEC_FAIL_UNPACK_SEQUENCE_TUPLE;
}
if (PyList_CheckExact(seq)) {
- return SPEC_FAIL_LIST;
+ return SPEC_FAIL_UNPACK_SEQUENCE_LIST;
}
return SPEC_FAIL_OTHER;
}
diff --git a/Tools/scripts/summarize_stats.py b/Tools/scripts/summarize_stats.py
index 1271c194e96a1..da0bab2390f3d 100644
--- a/Tools/scripts/summarize_stats.py
+++ b/Tools/scripts/summarize_stats.py
@@ -5,6 +5,7 @@
import collections
import os.path
import opcode
+from datetime import date
if os.name == "nt":
DEFAULT_DIR = "c:\\temp\\py_stats\\"
@@ -24,37 +25,53 @@
TOTAL = "specialization.deferred", "specialization.hit", "specialization.miss", "execution_count"
-def print_specialization_stats(name, family_stats):
+def print_specialization_stats(name, family_stats, defines):
if "specializable" not in family_stats:
return
total = sum(family_stats.get(kind, 0) for kind in TOTAL)
if total == 0:
return
- print(name+":")
- for key in sorted(family_stats):
- if key.startswith("specialization.failure_kinds"):
- continue
- if key.startswith("specialization."):
+ with Section(name, 3, f"specialization stats for {name} family"):
+ rows = []
+ for key in sorted(family_stats):
+ if key.startswith("specialization.failure_kinds"):
+ continue
+ if key.startswith("specialization."):
+ label = key[len("specialization."):]
+ elif key == "execution_count":
+ label = "unquickened"
+ else:
+ label = key
+ if key not in ("specialization.success", "specialization.failure", "specializable"):
+ rows.append((f"{label:>12}", f"{family_stats[key]:>12}", f"{100*family_stats[key]/total:0.1f}%"))
+ emit_table(("Kind", "Count", "Ratio"), rows)
+ print_title("Specialization attempts", 4)
+ total_attempts = 0
+ for key in ("specialization.success", "specialization.failure"):
+ total_attempts += family_stats.get(key, 0)
+ rows = []
+ for key in ("specialization.success", "specialization.failure"):
label = key[len("specialization."):]
- elif key == "execution_count":
- label = "unquickened"
- if key not in ("specialization.success", "specialization.failure"):
- print(f"{label:>12}:{family_stats[key]:>12} {100*family_stats[key]/total:0.1f}%")
- for key in ("specialization.success", "specialization.failure"):
- label = key[len("specialization."):]
- print(f" {label}:{family_stats.get(key, 0):>12}")
- total_failures = family_stats.get("specialization.failure", 0)
- failure_kinds = [ 0 ] * 30
- for key in family_stats:
- if not key.startswith("specialization.failure_kind"):
- continue
- _, index = key[:-1].split("[")
- index = int(index)
- failure_kinds[index] = family_stats[key]
- for index, value in enumerate(failure_kinds):
- if not value:
- continue
- print(f" kind {index:>2}: {value:>8} {100*value/total_failures:0.1f}%")
+ label = label[0].upper() + label[1:]
+ val = family_stats.get(key, 0)
+ rows.append((label, val, f"{100*val/total_attempts:0.1f}%"))
+ emit_table(("", "Count", "Ratio"), rows)
+ total_failures = family_stats.get("specialization.failure", 0)
+ failure_kinds = [ 0 ] * 30
+ for key in family_stats:
+ if not key.startswith("specialization.failure_kind"):
+ continue
+ _, index = key[:-1].split("[")
+ index = int(index)
+ failure_kinds[index] = family_stats[key]
+ failures = [(value, index) for (index, value) in enumerate(failure_kinds)]
+ failures.sort(reverse=True)
+ rows = []
+ for value, index in failures:
+ if not value:
+ continue
+ rows.append((kind_to_text(index, defines, name), value, f"{100*value/total_failures:0.1f}%"))
+ emit_table(("Failure kind", "Count", "Ratio"), rows)
def gather_stats():
stats = collections.Counter()
@@ -76,6 +93,31 @@ def extract_opcode_stats(stats):
opcode_stats[int(n)][rest.strip(".")] = value
return opcode_stats
+def parse_kinds(spec_src):
+ defines = collections.defaultdict(list)
+ for line in spec_src:
+ line = line.strip()
+ if not line.startswith("#define SPEC_FAIL_"):
+ continue
+ line = line[len("#define SPEC_FAIL_"):]
+ name, val = line.split()
+ defines[int(val.strip())].append(name.strip())
+ return defines
+
+def pretty(defname):
+ return defname.replace("_", " ").lower()
+
+def kind_to_text(kind, defines, opname):
+ if kind < 7:
+ return pretty(defines[kind][0])
+ if opname.endswith("ATTR"):
+ opname = "ATTR"
+ if opname.endswith("SUBSCR"):
+ opname = "SUBSCR"
+ for name in defines[kind]:
+ if name.startswith(opname):
+ return pretty(name[len(opname)+1:])
+ return "kind " + str(kind)
def categorized_counts(opcode_stats):
basic = 0
@@ -104,57 +146,131 @@ def categorized_counts(opcode_stats):
basic += count
return basic, not_specialized, specialized
+def print_title(name, level=2):
+ print("#"*level, name)
+ print()
+
+class Section:
+
+ def __init__(self, title, level=2, summary=None):
+ self.title = title
+ self.level = level
+ if summary is None:
+ self.summary = title.lower()
+ else:
+ self.summary = summary
+
+ def __enter__(self):
+ print_title(self.title, self.level)
+ print("<details>")
+ print("<summary>", self.summary, "</summary>")
+ print()
+ return self
+
+ def __exit__(*args):
+ print()
+ print("</details>")
+ print()
+
+def emit_table(header, rows):
+ width = len(header)
+ print("|", " | ".join(header), "|")
+ print("|", " | ".join(["---"]*width), "|")
+ for row in rows:
+ if width is not None and len(row) != width:
+ raise ValueError("Wrong number of elements in row '" + str(rows) + "'")
+ print("|", " | ".join(str(i) for i in row), "|")
+ print()
+
+def emit_execution_counts(opcode_stats, total):
+ with Section("Execution counts", summary="execution counts for all instructions"):
+ counts = []
+ for i, opcode_stat in enumerate(opcode_stats):
+ if "execution_count" in opcode_stat:
+ count = opcode_stat['execution_count']
+ miss = 0
+ if "specializable" not in opcode_stat:
+ miss = opcode_stat.get("specialization.miss")
+ counts.append((count, opname[i], miss))
+ counts.sort(reverse=True)
+ cumulative = 0
+ rows = []
+ for (count, name, miss) in counts:
+ cumulative += count
+ if miss:
+ miss = f"{100*miss/count:0.1f}%"
+ else:
+ miss = ""
+ rows.append((name, count, f"{100*count/total:0.1f}%",
+ f"{100*cumulative/total:0.1f}%", miss))
+ emit_table(
+ ("Name", "Count", "Self", "Cumulative", "Miss ratio"),
+ rows
+ )
+
+
+def emit_specialization_stats(opcode_stats):
+ spec_path = os.path.join(os.path.dirname(__file__), "../../Python/specialize.c")
+ with open(spec_path) as spec_src:
+ defines = parse_kinds(spec_src)
+ with Section("Specialization stats", summary="specialization stats by family"):
+ for i, opcode_stat in enumerate(opcode_stats):
+ name = opname[i]
+ print_specialization_stats(name, opcode_stat, defines)
+
+def emit_specialization_overview(opcode_stats, total):
+ basic, not_specialized, specialized = categorized_counts(opcode_stats)
+ with Section("Specialization effectiveness"):
+ emit_table(("Instructions", "Count", "Ratio"), (
+ ("Basic", basic, f"{basic*100/total:0.1f}%"),
+ ("Not specialized", not_specialized, f"{not_specialized*100/total:0.1f}%"),
+ ("Specialized", specialized, f"{specialized*100/total:0.1f}%"),
+ ))
+
+def emit_call_stats(stats):
+ with Section("Call stats", summary="Inlined calls and frame stats"):
+ total = 0
+ for key, value in stats.items():
+ if "Calls to" in key:
+ total += value
+ rows = []
+ for key, value in stats.items():
+ if "Calls to" in key:
+ rows.append((key, value, f"{100*value/total:0.1f}%"))
+ for key, value in stats.items():
+ if key.startswith("Frame"):
+ rows.append((key, value, f"{100*value/total:0.1f}%"))
+ emit_table(("", "Count", "Ratio"), rows)
+
+def emit_object_stats(stats):
+ with Section("Object stats", summary="allocations, frees and dict materializatons"):
+ total = stats.get("Object new values")
+ rows = []
+ for key, value in stats.items():
+ if key.startswith("Object"):
+ if "materialize" in key:
+ materialize = f"{100*value/total:0.1f}%"
+ else:
+ materialize = ""
+ label = key[6:].strip()
+ label = label[0].upper() + label[1:]
+ rows.append((label, value, materialize))
+ emit_table(("", "Count", "Ratio"), rows)
+
def main():
stats = gather_stats()
opcode_stats = extract_opcode_stats(stats)
- print("Execution counts:")
- counts = []
total = 0
for i, opcode_stat in enumerate(opcode_stats):
if "execution_count" in opcode_stat:
- count = opcode_stat['execution_count']
- miss = 0
- if "specializable" not in opcode_stat:
- miss = opcode_stat.get("specialization.miss")
- counts.append((count, opname[i], miss))
- total += count
- counts.sort(reverse=True)
- cummulative = 0
- for (count, name, miss) in counts:
- cummulative += count
- print(f"{name}: {count} {100*count/total:0.1f}% {100*cummulative/total:0.1f}%")
- if miss:
- print(f" Misses: {miss} {100*miss/count:0.1f}%")
- print("Specialization stats:")
- for i, opcode_stat in enumerate(opcode_stats):
- name = opname[i]
- print_specialization_stats(name, opcode_stat)
- basic, not_specialized, specialized = categorized_counts(opcode_stats)
- print("Specialization effectiveness:")
- print(f" Base instructions {basic} {basic*100/total:0.1f}%")
- print(f" Not specialized {not_specialized} {not_specialized*100/total:0.1f}%")
- print(f" Specialized {specialized} {specialized*100/total:0.1f}%")
- print("Call stats:")
- total = 0
- for key, value in stats.items():
- if "Calls to" in key:
- total += value
- for key, value in stats.items():
- if "Calls to" in key:
- print(f" {key}: {value} {100*value/total:0.1f}%")
- for key, value in stats.items():
- if key.startswith("Frame"):
- print(f" {key}: {value} {100*value/total:0.1f}%")
- print("Object stats:")
- total = stats.get("Object new values")
- for key, value in stats.items():
- if key.startswith("Object"):
- if "materialize" in key:
- print(f" {key}: {value} {100*value/total:0.1f}%")
- else:
- print(f" {key}: {value}")
- total = 0
-
+ total += opcode_stat['execution_count']
+ emit_execution_counts(opcode_stats, total)
+ emit_specialization_stats(opcode_stats)
+ emit_specialization_overview(opcode_stats, total)
+ emit_call_stats(stats)
+ emit_object_stats(stats)
+ print("---")
+ print("Stats gathered on:", date.today())
if __name__ == "__main__":
main()
More information about the Python-checkins
mailing list