Simplify and speed up interpreter for f-strings. Split FORMAT_VALUE opcode into CONVERT_VALUE, FORMAT_SIMPLE and FORMAT_WITH_SPEC.

Compiler can then emit optimal sequence for each format expression.

Author: markshannon

Include/opcode.h

@@ -16,7 +16,7 @@
 _have_code = (types.MethodType, types.FunctionType, types.CodeType,
               classmethod, staticmethod, type)
 
-FORMAT_VALUE = opmap['FORMAT_VALUE']
+CONVERT_VALUE = opmap['CONVERT_VALUE']
 FORMAT_VALUE_CONVERTERS = (
     (None, ''),
     (str, 'str'),
@@ -415,13 +415,9 @@ def _get_instructions_bytes(code, varname_from_oparg=None,
             elif op in hascompare:
                 argval = cmp_op[arg]
                 argrepr = argval
-            elif op == FORMAT_VALUE:
-                argval, argrepr = FORMAT_VALUE_CONVERTERS[arg & 0x3]
-                argval = (argval, bool(arg & 0x4))
-                if argval[1]:
-                    if argrepr:
-                        argrepr += ', '
-                    argrepr += 'with format'
+            elif op == CONVERT_VALUE:
+                argval = (None, str, repr, ascii)[arg]
+                argrepr = ('', 'str', 'repr', 'ascii')[arg]
             elif op == MAKE_FUNCTION:
                 argrepr = ', '.join(s for i, s in enumerate(MAKE_FUNCTION_FLAGS)
                                     if arg & (1<<i))

Lib/dis.py

@@ -330,6 +330,7 @@ def _write_atomic(path, data, mode=0o666):
 #                         this might affected the first line number #32911)
 #     Python 3.8a1  3400 (move frame block handling to compiler #17611)
 #     Python 3.8a1  3401 (add END_ASYNC_FOR #33041)
+#     Python 3.8a1  3402 (more efficient bytecodes for f-strings #33092)
 #     Python 3.8a1  3410 (PEP570 Python Positional-Only Parameters #36540)
 #     Python 3.8b2  3411 (Reverse evaluation order of key: value in dict
 #                         comprehensions #35224)

Lib/importlib/_bootstrap_external.py

@@ -90,7 +90,11 @@ def jabs_op(name, op):
 
 def_op('POP_EXCEPT_AND_RERAISE', 37)
 
+def_op('FORMAT_SIMPLE', 40)
+def_op('FORMAT_WITH_SPEC', 41)
+
 def_op('WITH_EXCEPT_START', 49)
+
 def_op('GET_AITER', 50)
 def_op('GET_ANEXT', 51)
 def_op('BEFORE_ASYNC_WITH', 52)
@@ -202,10 +206,11 @@ def jabs_op(name, op):
 def_op('MAP_ADD', 147)
 def_op('LOAD_CLASSDEREF', 148)
 hasfree.append(148)
+def_op('CONVERT_VALUE', 149)
 
 def_op('MATCH_CLASS', 152)
 
-def_op('FORMAT_VALUE', 155)
+
 def_op('BUILD_CONST_KEY_MAP', 156)
 def_op('BUILD_STRING', 157)
 

Lib/opcode.py

@@ -334,20 +334,22 @@ def _fstring(a, b, c, d):
 
 dis_fstring = """\
 %3d           0 LOAD_FAST                0 (a)
-              2 FORMAT_VALUE             0
+              2 FORMAT_SIMPLE
               4 LOAD_CONST               1 (' ')
               6 LOAD_FAST                1 (b)
               8 LOAD_CONST               2 ('4')
-             10 FORMAT_VALUE             4 (with format)
+             10 FORMAT_WITH_SPEC
              12 LOAD_CONST               1 (' ')
              14 LOAD_FAST                2 (c)
-             16 FORMAT_VALUE             2 (repr)
-             18 LOAD_CONST               1 (' ')
-             20 LOAD_FAST                3 (d)
-             22 LOAD_CONST               2 ('4')
-             24 FORMAT_VALUE             6 (repr, with format)
-             26 BUILD_STRING             7
-             28 RETURN_VALUE
+             16 CONVERT_VALUE            2 (repr)
+             18 FORMAT_SIMPLE
+             20 LOAD_CONST               1 (' ')
+             22 LOAD_FAST                3 (d)
+             24 CONVERT_VALUE            2 (repr)
+             26 LOAD_CONST               2 ('4')
+             28 FORMAT_WITH_SPEC
+             30 BUILD_STRING             7
+             32 RETURN_VALUE
 """ % (_fstring.__code__.co_firstlineno + 1,)
 
 def _tryfinally(a, b):

Lib/test/test_dis.py

@@ -0,0 +1,3 @@
+Simplify and speed up interpreter for f-strings. Removes ``FORMAT_VALUE``
+opcode. Add ``CONVERT_VALUE``, ``FORMAT_SIMPLE`` and ``FORMAT_WITH_SPEC`` opcode.
+Compiler emits more efficient sequence for each format expression.

Misc/NEWS.d/next/Core and Builtins/2018-03-17-05-36-19.bpo-33092.jZfBZd.rst

@@ -99,6 +99,14 @@ static void format_kwargs_error(PyThreadState *, PyObject *func, PyObject *kwarg
 static void format_awaitable_error(PyThreadState *, PyTypeObject *, int, int);
 static int get_exception_handler(PyCodeObject *, int, int*, int*, int*);
 
+typedef PyObject *(*convertion_func_ptr)(PyObject *);
+
+static const convertion_func_ptr CONVERSION_FUNCTIONS[4] = {
+    [FVC_STR] = PyObject_Str,
+    [FVC_REPR] = PyObject_Repr,
+    [FVC_ASCII] = PyObject_ASCII
+};
+
 #define NAME_ERROR_MSG \
     "name '%.200s' is not defined"
 #define UNBOUNDLOCAL_ERROR_MSG \
@@ -4346,7 +4354,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
                 oparg = cache->adaptive.original_oparg;
                 STAT_DEC(LOAD_METHOD, unquickened);
                 JUMP_TO_INSTRUCTION(LOAD_METHOD);
-            }            
+            }
         }
 
         TARGET(LOAD_METHOD_CACHED): {
@@ -4364,7 +4372,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
             assert(cache1->tp_version != 0);
             assert(self_cls->tp_dictoffset >= 0);
             assert(Py_TYPE(self_cls)->tp_dictoffset > 0);
-            
+
             // inline version of _PyObject_GetDictPtr for offset >= 0
             PyObject *dict = self_cls->tp_dictoffset != 0 ?
                 *(PyObject **) ((char *)self + self_cls->tp_dictoffset) : NULL;
@@ -4627,62 +4635,47 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
             DISPATCH();
         }
 
-        TARGET(FORMAT_VALUE): {
-            /* Handles f-string value formatting. */
+        TARGET(CONVERT_VALUE): {
             PyObject *result;
-            PyObject *fmt_spec;
-            PyObject *value;
-            PyObject *(*conv_fn)(PyObject *);
-            int which_conversion = oparg & FVC_MASK;
-            int have_fmt_spec = (oparg & FVS_MASK) == FVS_HAVE_SPEC;
-
-            fmt_spec = have_fmt_spec ? POP() : NULL;
-            value = POP();
-
-            /* See if any conversion is specified. */
-            switch (which_conversion) {
-            case FVC_NONE:  conv_fn = NULL;           break;
-            case FVC_STR:   conv_fn = PyObject_Str;   break;
-            case FVC_REPR:  conv_fn = PyObject_Repr;  break;
-            case FVC_ASCII: conv_fn = PyObject_ASCII; break;
-            default:
-                _PyErr_Format(tstate, PyExc_SystemError,
-                              "unexpected conversion flag %d",
-                              which_conversion);
+            PyObject *value = POP();
+            convertion_func_ptr  conv_fn;
+            assert(oparg >= FVC_STR && oparg <= FVC_ASCII);
+            conv_fn = CONVERSION_FUNCTIONS[oparg];
+            result = conv_fn(value);
+            Py_DECREF(value);
+            if (result == NULL) {
                 goto error;
             }
+            PUSH(result);
+            DISPATCH();
+        }
 
-            /* If there's a conversion function, call it and replace
-               value with that result. Otherwise, just use value,
-               without conversion. */
-            if (conv_fn != NULL) {
-                result = conv_fn(value);
-                Py_DECREF(value);
+        TARGET(FORMAT_SIMPLE): {
+            PyObject *value = TOP();
+            /* If value is a unicode object, then we know the result
+             * of format(value) is value itself. */
+            if (!PyUnicode_CheckExact(value)) {
+                PyObject *result = PyObject_Format(value, NULL);
                 if (result == NULL) {
-                    Py_XDECREF(fmt_spec);
                     goto error;
                 }
-                value = result;
-            }
-
-            /* If value is a unicode object, and there's no fmt_spec,
-               then we know the result of format(value) is value
-               itself. In that case, skip calling format(). I plan to
-               move this optimization in to PyObject_Format()
-               itself. */
-            if (PyUnicode_CheckExact(value) && fmt_spec == NULL) {
-                /* Do nothing, just transfer ownership to result. */
-                result = value;
-            } else {
-                /* Actually call format(). */
-                result = PyObject_Format(value, fmt_spec);
+                SET_TOP(result);
                 Py_DECREF(value);
-                Py_XDECREF(fmt_spec);
-                if (result == NULL) {
-                    goto error;
-                }
             }
+            DISPATCH();
+        }
 
+        TARGET(FORMAT_WITH_SPEC): {
+            PyObject *fmt_spec = POP();
+            PyObject *value = POP();
+            PyObject *result;
+            /* Call format(). */
+            result = PyObject_Format(value, fmt_spec);
+            Py_DECREF(value);
+            Py_DECREF(fmt_spec);
+            if (result == NULL) {
+                goto error;
+            }
             PUSH(result);
             DISPATCH();
         }

Programs/test_frozenmain.h

@@ -1231,10 +1231,12 @@ stack_effect(int opcode, int oparg, int jump)
             return 0;
         case END_ASYNC_FOR:
             return -4;
-        case FORMAT_VALUE:
-            /* 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 CONVERT_VALUE:
+            return 0;
+        case FORMAT_WITH_SPEC:
+            return -1;
+        case FORMAT_SIMPLE:
+            return 0;
         case LOAD_METHOD:
             return 1;
         case LOAD_ASSERTION_ERROR:
@@ -4486,26 +4488,26 @@ compiler_formatted_value(struct compiler *c, expr_ty e)
 
     /* The expression to be formatted. */
     VISIT(c, expr, e->v.FormattedValue.value);
-
-    switch (conversion) {
-    case 's': oparg = FVC_STR;   break;
-    case 'r': oparg = FVC_REPR;  break;
-    case 'a': oparg = FVC_ASCII; break;
-    case -1:  oparg = FVC_NONE;  break;
-    default:
+    if (e->v.FormattedValue.conversion != -1) {
+        switch (e->v.FormattedValue.conversion) {
+        case 's': oparg = FVC_STR;   break;
+        case 'r': oparg = FVC_REPR;  break;
+        case 'a': oparg = FVC_ASCII; break;
+        default:
         PyErr_Format(PyExc_SystemError,
                      "Unrecognized conversion character %d", conversion);
-        return 0;
+            return 0;
+        }
+        ADDOP_I(c, CONVERT_VALUE, oparg);
     }
     if (e->v.FormattedValue.format_spec) {
-        /* Evaluate the format spec, and update our opcode arg. */
+        /* Evaluate the format spec, and emit format opcode. */
         VISIT(c, expr, e->v.FormattedValue.format_spec);
-        oparg |= FVS_HAVE_SPEC;
+        ADDOP(c, FORMAT_WITH_SPEC);
+    } else {
+        ADDOP(c, FORMAT_SIMPLE);
     }
 
-    /* And push our opcode and oparg */
-    ADDOP_I(c, FORMAT_VALUE, oparg);
-
     return 1;
 }