Issue python#26110: Add LOAD_METHOD/CALL_METHOD opcodes.

Special thanks to INADA Naoki for pushing the patch through
the last mile, Serhiy Storchaka for reviewing the code, and to
Victor Stinner for suggesting the idea (originally implemented
in the PyPy project).

Author: 1st1

Doc/whatsnew/3.7.rst

@@ -92,6 +92,11 @@ Improved Modules
 Optimizations
 =============
 
+* Added two new opcodes: ``LOAD_METHOD`` and ``CALL_METHOD`` to avoid
+  instantiation of bound method objects for method calls, which results
+  in method calls being faster up to 20%.
+  (Contributed by Yury Selivanov and INADA Naoki in :issue:`26110`.)
+
 
 Build and C API Changes
 =======================

Include/opcode.h

@@ -126,6 +126,8 @@ extern "C" {
 #define BUILD_CONST_KEY_MAP     156
 #define BUILD_STRING            157
 #define BUILD_TUPLE_UNPACK_WITH_CALL 158
+#define LOAD_METHOD             160
+#define CALL_METHOD             161
 
 /* EXCEPT_HANDLER is a special, implicit block type which is created when
    entering an except handler. It is not an opcode but we define it here

Lib/importlib/_bootstrap_external.py

@@ -240,6 +240,7 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.6b1  3377 (set __class__ cell from type.__new__ #23722)
 #     Python 3.6b2  3378 (add BUILD_TUPLE_UNPACK_WITH_CALL #28257)
 #     Python 3.6rc1 3379 (more thorough __class__ validation #23722)
+#     Python 3.7a0  3390 (add LOAD_METHOD and CALL_METHOD opcodes)
 #
 # MAGIC must change whenever the bytecode emitted by the compiler may no
 # longer be understood by older implementations of the eval loop (usually
@@ -248,7 +249,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3379).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3390).to_bytes(2, 'little') + b'\r\n'
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
 _PYCACHE = '__pycache__'

Lib/opcode.py

@@ -212,4 +212,7 @@ def jabs_op(name, op):
 def_op('BUILD_STRING', 157)
 def_op('BUILD_TUPLE_UNPACK_WITH_CALL', 158)
 
+name_op('LOAD_METHOD', 160)
+def_op('CALL_METHOD', 161)
+
 del def_op, name_op, jrel_op, jabs_op

Lib/test/test_syntax.py

@@ -207,6 +207,33 @@
 ...  # doctest: +ELLIPSIS
 () [('a000', 0), ('a001', 1), ('a002', 2), ..., ('a298', 298), ('a299', 299)]
 
+>>> class C:
+...     def meth(self, *args):
+...         return args
+>>> obj = C()
+>>> obj.meth(
+...   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+...   20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+...   38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+...   56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
+...   74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+...   92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
+...   108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
+...   122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
+...   136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+...   150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
+...   164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
+...   178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+...   192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
+...   206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
+...   220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
+...   234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
+...   248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
+...   262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
+...   276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
+...   290, 291, 292, 293, 294, 295, 296, 297, 298, 299)  # doctest: +ELLIPSIS
+(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ..., 297, 298, 299)
+
 >>> f(lambda x: x[0] = 3)
 Traceback (most recent call last):
 SyntaxError: lambda cannot contain assignment

Misc/NEWS

@@ -174,6 +174,9 @@ Core and Builtins
 - Issue #28721: Fix asynchronous generators aclose() and athrow() to
   handle StopAsyncIteration propagation properly.
 
+- Issue #26110: Speed-up method calls: add LOAD_METHOD and CALL_METHOD
+  opcodes.
+
 Library
 -------
 

Objects/object.c

@@ -1025,11 +1025,99 @@ _PyObject_NextNotImplemented(PyObject *self)
     return NULL;
 }
 
-/* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
+
+/* Specialized version of _PyObject_GenericGetAttrWithDict
+   specifically for the LOAD_METHOD opcode.
+
+   Return 1 if a method is found, 0 if it's a regular attribute
+   from __dict__ or something returned by using a descriptor
+   protocol.
+
+   `method` will point to the resolved attribute or NULL.  In the
+   latter case, an error will be set.
+*/
+int
+_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
+{
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    PyObject *attr;
+    int meth_found = 0;
+
+    assert(*method == NULL);
+
+    if (Py_TYPE(obj)->tp_getattro != PyObject_GenericGetAttr
+            || !PyUnicode_Check(name)) {
+        *method = PyObject_GetAttr(obj, name);
+        return 0;
+    }
+
+    if (tp->tp_dict == NULL && PyType_Ready(tp) < 0)
+        return 0;
+
+    descr = _PyType_Lookup(tp, name);
+    if (descr != NULL) {
+        Py_INCREF(descr);
+        if (PyFunction_Check(descr)) {
+            /* A python method. */
+            meth_found = 1;
+        } else {
+            f = descr->ob_type->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                *method = f(descr, obj, (PyObject *)obj->ob_type);
+                Py_DECREF(descr);
+                return 0;
+            }
+        }
+    }
+
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = PyDict_GetItem(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            *method = attr;
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            return 0;
+        }
+        Py_DECREF(dict);
+    }
+
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+
+    if (f != NULL) {
+        *method = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        return 0;
+    }
+
+    if (descr != NULL) {
+        *method = descr;
+        return 0;
+    }
+
+    PyErr_Format(PyExc_AttributeError,
+                 "'%.50s' object has no attribute '%U'",
+                 tp->tp_name, name);
+    return 0;
+}
+
+/* Generic GetAttr functions - put these in your tp_[gs]etattro slot. */
 
 PyObject *
 _PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name, PyObject *dict)
 {
+    /* Make sure the logic of _PyObject_GetMethod is in sync with
+       this method.
+    */
+
     PyTypeObject *tp = Py_TYPE(obj);
     PyObject *descr = NULL;
     PyObject *res = NULL;

PC/launcher.c

@@ -1090,6 +1090,7 @@ static PYC_MAGIC magic_values[] = {
     { 3250, 3310, L"3.4" },
     { 3320, 3351, L"3.5" },
     { 3360, 3379, L"3.6" },
+    { 3390, 3399, L"3.7" },
     { 0 }
 };
 

Python/ceval.c

@@ -30,6 +30,9 @@
 #define CHECKEXC 1      /* Double-check exception checking */
 #endif
 
+/* Private API for the LOAD_METHOD opcode. */
+extern int _PyObject_GetMethod(PyObject *, PyObject *, PyObject **);
+
 typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
 
 /* Forward declarations */
@@ -3225,6 +3228,100 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
             DISPATCH();
         }
 
+        TARGET(LOAD_METHOD) {
+            /* Designed to work in tamdem with CALL_METHOD. */
+            PyObject *name = GETITEM(names, oparg);
+            PyObject *obj = TOP();
+            PyObject *meth = NULL;
+
+            int meth_found = _PyObject_GetMethod(obj, name, &meth);
+
+            SET_TOP(meth);  /* Replace `obj` on top; OK if NULL. */
+            if (meth == NULL) {
+                /* Most likely attribute wasn't found. */
+                Py_DECREF(obj);
+                goto error;
+            }
+
+            if (meth_found) {
+                /* The method object is now on top of the stack.
+                   Push `obj` back to the stack, so that the stack
+                   layout would be:
+
+                       method | obj | arg1 | ... | argN
+                */
+                PUSH(obj);
+            }
+            else {
+                /* Not a method (but a regular attr, or something
+                   was returned by a descriptor protocol).  Push
+                   NULL to the top of the stack, to signal
+                   CALL_METHOD that it's not a method call.
+                */
+                Py_DECREF(obj);
+                PUSH(NULL);
+            }
+            DISPATCH();
+        }
+
+        TARGET(CALL_METHOD) {
+            /* Designed to work in tamdem with LOAD_METHOD. */
+            PyObject **sp, *res, *obj;
+
+            sp = stack_pointer;
+
+            obj = PEEK(oparg + 1);
+            if (obj == NULL) {
+                /* `obj` is NULL when LOAD_METHOD thinks that it's not
+                   a method call.  Swap the NULL and callable.
+
+                   Stack layout:
+
+                       ... | callable | NULL | arg1 | ... | argN
+                                                           ^- TOP()
+                                              ^- (-oparg)
+                                       ^- (-oparg-1)
+                              ^- (-oparg-2)
+
+                   after the next line it will be:
+
+                       ... | callable | callable | arg1 | ... | argN
+                                                                ^- TOP()
+                                                   ^- (-oparg)
+                                        ^- (-oparg-1)
+                              ^- (-oparg-2)
+
+                   Right side `callable` will be POPed by call_funtion.
+                   Left side `callable` will be POPed manually later
+                   (one of "callbale" refs on the stack is borrowed.)
+                */
+                SET_VALUE(oparg + 1, PEEK(oparg + 2));
+                res = call_function(&sp, oparg, NULL);
+                stack_pointer = sp;
+                (void)POP(); /* POP the left side callable. */
+            }
+            else {
+                /* This is a method call.  Stack layout:
+
+                     ... | method | obj | arg1 | ... | argN
+                                                        ^- TOP()
+                                           ^- (-oparg)
+                                     ^- (-oparg-1)
+
+                  `obj` and `method` will be POPed by call_function.
+                  We'll be passing `oparg + 1` to call_function, to
+                  make it accept the `obj` as a first argument.
+                */
+                res = call_function(&sp, oparg + 1, NULL);
+                stack_pointer = sp;
+            }
+
+            PUSH(res);
+            if (res == NULL)
+                goto error;
+            DISPATCH();
+        }
+
         PREDICTED(CALL_FUNCTION);
         TARGET(CALL_FUNCTION) {
             PyObject **sp, *res;

Python/compile.c

@@ -1040,6 +1040,8 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
             return -oparg;
         case CALL_FUNCTION:
             return -oparg;
+        case CALL_METHOD:
+            return -oparg-1;
         case CALL_FUNCTION_KW:
             return -oparg-1;
         case CALL_FUNCTION_EX:
@@ -1078,6 +1080,8 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
             /* If there's a fmt_spec on the stack, we go from 2->1,
                else 1->1. */
             return (oparg & FVS_MASK) == FVS_HAVE_SPEC ? -1 : 0;
+        case LOAD_METHOD:
+            return 1;
         default:
             return PY_INVALID_STACK_EFFECT;
     }
@@ -3399,9 +3403,42 @@ compiler_compare(struct compiler *c, expr_ty e)
     return 1;
 }
 
+static int
+maybe_optimize_method_call(struct compiler *c, expr_ty e)
+{
+    Py_ssize_t argsl, i;
+    expr_ty meth = e->v.Call.func;
+    asdl_seq *args = e->v.Call.args;
+
+    /* Check that the call node is an attribute access, and that
+       the call doesn't have keyword parameters. */
+    if (meth->kind != Attribute_kind || meth->v.Attribute.ctx != Load ||
+            asdl_seq_LEN(e->v.Call.keywords))
+        return -1;
+
+    /* Check that there are no *varargs types of arguments. */
+    argsl = asdl_seq_LEN(args);
+    for (i = 0; i < argsl; i++) {
+        expr_ty elt = asdl_seq_GET(args, i);
+        if (elt->kind == Starred_kind) {
+            return -1;
+        }
+    }
+
+    /* Alright, we can optimize the code. */
+    VISIT(c, expr, meth->v.Attribute.value);
+    ADDOP_NAME(c, LOAD_METHOD, meth->v.Attribute.attr, names);
+    VISIT_SEQ(c, expr, e->v.Call.args);
+    ADDOP_I(c, CALL_METHOD, asdl_seq_LEN(e->v.Call.args));
+    return 1;
+}
+
 static int
 compiler_call(struct compiler *c, expr_ty e)
 {
+    if (maybe_optimize_method_call(c, e) > 0)
+        return 1;
+
     VISIT(c, expr, e->v.Call.func);
     return compiler_call_helper(c, 0,
                                 e->v.Call.args,