http://bugs.python.org/issue2459 -- speed up loops

Python/ceval.c

 
 /* Execute compiled code */
 
 /* XXX TO DO:
    XXX speed up searching for keywords by using a dictionary
    XXX document it!
    */
 
 /* enable more aggressive intra-module optimizations, where available */
 #define PY_LOCAL_AGGRESSIVE
@@ skipping 93 matching lines @@
 #ifdef LLTRACE
 static int lltrace;
 static int prtrace(PyObject *, char *);
 #endif
 static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
                       int, PyObject *);
 static int call_trace_protected(Py_tracefunc, PyObject *,
                                  PyFrameObject *, int, PyObject *);
 static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
 static int maybe_call_line_trace(Py_tracefunc, PyObject *,
-                                  PyFrameObject *, int *, int *, int *);
+                                 PyFrameObject *, int *, int *, int *, int *);
 
 static PyObject * apply_slice(PyObject *, PyObject *, PyObject *);
 static int assign_slice(PyObject *, PyObject *,
                         PyObject *, PyObject *);
 static PyObject * cmp_outcome(int, PyObject *, PyObject *);
 static PyObject * import_from(PyObject *, PyObject *);
 static int import_all_from(PyObject *, PyObject *);
 static PyObject * build_class(PyObject *, PyObject *, PyObject *);
 static int exec_statement(PyFrameObject *,
                           PyObject *, PyObject *, PyObject *);
@@ skipping 556 matching lines @@
         register PyObject *u;
         register PyObject *t;
         register PyObject *stream = NULL;    /* for PRINT opcodes */
         register PyObject **fastlocals, **freevars;
         PyObject *retval = NULL;        /* Return value */
         PyThreadState *tstate = PyThreadState_GET();
         PyCodeObject *co;
 
         /* when tracing we set things up so that
 
-               not (instr_lb <= current_bytecode_offset < instr_ub)
+               instr_lb <= current_bytecode_offset < instr_ub
 
-           is true when the line being executed has changed.  The
-           initial values are such as to make this false the first
-           time it is tested. */
+           is false when the line being executed may have changed.
+           The initial values are such as to make this false the first
+           time it is tested. Then maybe_call_line_trace calls
+           PyCode_CheckLineNumber() to check if the line has actually
+           changed. */
         int instr_ub = -1, instr_lb = 0, instr_prev = -1;
+        int cur_line = 0;
 
         unsigned char *first_instr;
         PyObject *names;
         PyObject *consts;
 #if defined(Py_DEBUG) || defined(LLTRACE)
         /* Make it easier to find out where we are with a debugger */
         char *filename;
 #endif
 
 /* Tuple access macros */
@@ skipping 71 matching lines @@
         they were a single new opcode with the bodies combined.
 
     If collecting opcode statistics, your choices are to either keep the
         predictions turned-on and interpret the results as if some opcodes
         had been combined or turn-off predictions so that the opcode frequency
         counter updates for both opcodes.
 */
 
 #ifdef DYNAMIC_EXECUTION_PROFILE
 #define PREDICT(op)             if (0) goto PRED_##op
+#define PREDICT_WITH_SIGNALS(op)  if (0) goto PRED_##op
 #else
 #define PREDICT(op)             if (*next_instr == op) goto PRED_##op
+#define PREDICT_WITH_SIGNALS(op) \
+        if (*next_instr == op && --_Py_Ticker > 0) goto PRED_##op
 #endif
 
 #define PREDICTED(op)           PRED_##op: next_instr++
 #define PREDICTED_WITH_ARG(op)  PRED_##op: oparg = PEEKARG(); next_instr += 3
 
 /* Stack manipulation macros */
 
 /* The stack can grow at most MAXINT deep, as co_nlocals and
    co_stacksize are ints. */
 #define STACK_LEVEL()   ((int)(stack_pointer - f->f_valuestack))
@@ skipping 101 matching lines @@
            this wasn't always true before 2.3!  PyFrame_New now sets
            f->f_lasti to -1 (i.e. the index *before* the first instruction)
            and YIELD_VALUE doesn't fiddle with f_lasti any more.  So this
            does work.  Promise.
 
            When the PREDICT() macros are enabled, some opcode pairs follow in
            direct succession without updating f->f_lasti.  A successful
            prediction effectively links the two codes together as if they
            were a single new opcode; accordingly,f->f_lasti will point to
            the first code in the pair (for instance, GET_ITER followed by
-           FOR_ITER is effectively a single opcode and f->f_lasti will point
-           at to the beginning of the combined pair.)
+           JUMP_FORWARD is effectively a single opcode and f->f_lasti will
+           point at to the beginning of the combined pair.)
         */
         next_instr = first_instr + f->f_lasti + 1;
         stack_pointer = f->f_stacktop;
         assert(stack_pointer != NULL);
         f->f_stacktop = NULL;   /* remains NULL unless yield suspends frame */
 
 #ifdef LLTRACE
         lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
 #endif
 #if defined(Py_DEBUG) || defined(LLTRACE)
@@ skipping 97 matching lines @@
 
                 if (_Py_TracingPossible &&
                     tstate->c_tracefunc != NULL && !tstate->tracing) {
                         /* see maybe_call_line_trace
                            for expository comments */
                         f->f_stacktop = stack_pointer;
 
                         err = maybe_call_line_trace(tstate->c_tracefunc,
                                                     tstate->c_traceobj,
                                                     f, &instr_lb, &instr_ub,
-                                                    &instr_prev);
+                                                    &instr_prev, &cur_line);
                         /* Reload possibly changed frame fields */
                         JUMPTO(f->f_lasti);
                         if (f->f_stacktop != NULL) {
                                 stack_pointer = f->f_stacktop;
                                 f->f_stacktop = NULL;
                         }
                         if (err) {
                                 /* trace function raised an exception */
                                 goto on_error;
                         }
@@ skipping 377 matching lines @@
                         SET_TOP(x);
                         if (x != NULL) continue;
                         break;
 
                 case LIST_APPEND:
                         w = POP();
                         v = stack_pointer[-oparg];
                         err = PyList_Append(v, w);
                         Py_DECREF(w);
                         if (err == 0) {
-                                PREDICT(JUMP_ABSOLUTE);
+                                PREDICT(FOR_ITER);
                                 continue;
                         }
                         break;
 
                 case INPLACE_POWER:
                         w = POP();
                         v = TOP();
                         x = PyNumber_InPlacePower(v, w, Py_None);
                         Py_DECREF(v);
                         Py_DECREF(w);
@@ skipping 847 matching lines @@
                 case IMPORT_FROM:
                         w = GETITEM(names, oparg);
                         v = TOP();
                         READ_TIMESTAMP(intr0);
                         x = import_from(v, w);
                         READ_TIMESTAMP(intr1);
                         PUSH(x);
                         if (x != NULL) continue;
                         break;
 
+                PREDICTED_WITH_ARG(JUMP_FORWARD);
                 case JUMP_FORWARD:
                         JUMPBY(oparg);
                         goto fast_next_opcode;
 
                 PREDICTED_WITH_ARG(POP_JUMP_IF_FALSE);
                 case POP_JUMP_IF_FALSE:
                         w = POP();
                         if (w == Py_True) {
                                 Py_DECREF(w);
                                 goto fast_next_opcode;
                         }
                         if (w == Py_False) {
                                 Py_DECREF(w);
                                 JUMPTO(oparg);
+#if FAST_LOOPS  /* See JUMP_ABSOLUTE for a description of this define */
                                 goto fast_next_opcode;
+#else
+                                continue;
+#endif
                         }
                         err = PyObject_IsTrue(w);
                         Py_DECREF(w);
                         if (err > 0)
                                 err = 0;
-                        else if (err == 0)
+                        else if (err == 0) {
                                 JUMPTO(oparg);
+#if FAST_LOOPS  /* See JUMP_ABSOLUTE for a description of this define */
+                                goto fast_next_opcode;
+#endif
+                        }
                         else
                                 break;
                         continue;
 
                 PREDICTED_WITH_ARG(POP_JUMP_IF_TRUE);
                 case POP_JUMP_IF_TRUE:
                         w = POP();
                         if (w == Py_False) {
                                 Py_DECREF(w);
                                 goto fast_next_opcode;
                         }
                         if (w == Py_True) {
                                 Py_DECREF(w);
                                 JUMPTO(oparg);
+#if FAST_LOOPS  /* See JUMP_ABSOLUTE for a description of this define */
                                 goto fast_next_opcode;
+#else
+                                continue;
+#endif
                         }
                         err = PyObject_IsTrue(w);
                         Py_DECREF(w);
                         if (err > 0) {
                                 err = 0;
                                 JUMPTO(oparg);
+#if FAST_LOOPS  /* See JUMP_ABSOLUTE for a description of this define */
+                                goto fast_next_opcode;
+#endif
                         }
                         else if (err == 0)
                                 ;
                         else
                                 break;
                         continue;
 
                 case JUMP_IF_FALSE_OR_POP:
                         w = TOP();
                         if (w == Py_True) {
@@ skipping 34 matching lines @@
                                 JUMPTO(oparg);
                         }
                         else if (err == 0) {
                                 STACKADJ(-1);
                                 Py_DECREF(w);
                         }
                         else
                                 break;
                         continue;
 
-                PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
                 case JUMP_ABSOLUTE:
                         JUMPTO(oparg);
 #if FAST_LOOPS
                         /* Enabling this path speeds-up all while and for-loops by bypassing
                            the per-loop checks for signals.  By default, this should be turned-off
                            because it prevents detection of a control-break in tight loops like
                            "while 1: pass".  Compile with this option turned-on when you need
                            the speed-up and do not need break checking inside tight loops (ones
                            that contain only instructions ending with goto fast_next_opcode).
                         */
                         goto fast_next_opcode;
 #else
                         continue;
 #endif
 
                 case GET_ITER:
                         /* before: [obj]; after [getiter(obj)] */
                         v = TOP();
                         x = PyObject_GetIter(v);
                         Py_DECREF(v);
                         if (x != NULL) {
                                 SET_TOP(x);
-                                PREDICT(FOR_ITER);
+                                PREDICT(JUMP_FORWARD);
                                 continue;
                         }
                         STACKADJ(-1);
                         break;
 
                 PREDICTED_WITH_ARG(FOR_ITER);
                 case FOR_ITER:
                         /* before: [iter]; after: [iter, iter()] *or* [] */
                         v = TOP();
                         x = (*v->ob_type->tp_iternext)(v);
                         if (x != NULL) {
                                 PUSH(x);
-                                PREDICT(STORE_FAST);
+                                JUMPTO(oparg);
+                                /* STORE_FAST is a fast_next_opcode so we must be careful
+                                   about not blocking signals in an empty loop. */
+                                PREDICT_WITH_SIGNALS(STORE_FAST);
                                 PREDICT(UNPACK_SEQUENCE);
                                 continue;
                         }
                         if (PyErr_Occurred()) {
                                 if (!PyErr_ExceptionMatches(
                                                 PyExc_StopIteration))
                                         break;
                                 PyErr_Clear();
                         }
                         /* iterator ended normally */
-                        x = v = POP();
+                        x = v = POP();
                         Py_DECREF(v);
-                        JUMPBY(oparg);
                         continue;
 
                 case BREAK_LOOP:
                         why = WHY_BREAK;
                         goto fast_block_end;
 
                 case CONTINUE_LOOP:
                         retval = PyInt_FromLong(oparg);
                         if (!retval) {
                                 x = NULL;
@@ skipping 1134 matching lines @@
                                || (tstate->c_profilefunc != NULL));
         result = PyObject_Call(func, args, NULL);
         tstate->tracing = save_tracing;
         tstate->use_tracing = save_use_tracing;
         return result;
 }
 
 static int
 maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
                       PyFrameObject *frame, int *instr_lb, int *instr_ub,
-                      int *instr_prev)
+                      int *instr_prev, int *cur_line)
 {
         int result = 0;
 
         /* If the last instruction executed isn't in the current
            instruction window, reset the window.  If the last
            instruction happens to fall at the start of a line or if it
            represents a jump backwards, call the trace function.
         */
         if ((frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub)) {
                 int line;
                 PyAddrPair bounds;
 
                 line = PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
                                               &bounds);
-                if (line >= 0) {
+                if (line >= 0 && line != *cur_line) {
                         frame->f_lineno = line;
                         result = call_trace(func, obj, frame,
                                             PyTrace_LINE, Py_None);
                 }
                 *instr_lb = bounds.ap_lower;
                 *instr_ub = bounds.ap_upper;
+                *cur_line = line;
         }
         else if (frame->f_lasti <= *instr_prev) {
                 result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
         }
         *instr_prev = frame->f_lasti;
         return result;
 }
 
 void
 PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
@@ skipping 1142 matching lines @@
                         Py_DECREF(l);
                         return NULL;
                 }
                 PyList_SetItem(l, i, x);
         }
         return l;
 #endif
 }
 
 #endif