tune PyLong optimisations at (gcc) assembly level so that they prefer the most...

tune PyLong optimisations at (gcc) assembly level so that they prefer the most common case of a single-digit

Cython/Utility/ModuleSetupCode.c

@@ -183,6 +183,10 @@
   #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
 #endif
 
+#define __Pyx_sst_abs(value) \
+    (sizeof(int) >= sizeof(Py_ssize_t) ? abs(value) : \
+     (sizeof(long) >= sizeof(Py_ssize_t) ? labs(value) : llabs(value)))
+
 /* inline attribute */
 #ifndef CYTHON_INLINE
   #if defined(__GNUC__)

Cython/Utility/Optimize.c

@@ -449,12 +449,16 @@ static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject
 #endif
     if (likely(PyLong_CheckExact(exp))) {
         #if CYTHON_USE_PYLONG_INTERNALS
-        switch (Py_SIZE(exp)) {
-            case  0: shiftby = 0; break;
-            case  1: shiftby = ((PyLongObject*)exp)->ob_digit[0]; break;
-            default:
-                if (unlikely(Py_SIZE(exp) < 0)) goto fallback;
-                shiftby = PyLong_AsSsize_t(exp); break;
+        const Py_ssize_t size = Py_SIZE(exp);
+        // tuned to optimise branch prediction
+        if (likely(size == 1)) {
+            shiftby = ((PyLongObject*)exp)->ob_digit[0];
+        } else if (size == 0) {
+            return PyInt_FromLong(1L);
+        } else if (unlikely(size < 0)) {
+            goto fallback;
+        } else {
+            shiftby = PyLong_AsSsize_t(exp);
         }
         #else
         shiftby = PyLong_AsSsize_t(exp);
@@ -563,26 +567,26 @@ static PyObject* __Pyx_PyInt_{{op}}{{order}}(PyObject *op1, PyObject *op2, CYTHO
         long x, {{ival}};
         const digit* digits = ((PyLongObject*){{pyval}})->ob_digit;
         const Py_ssize_t size = Py_SIZE({{pyval}});
-        switch (size) {
-            case  0: {{ival}} = 0; break;
-            case -1: {{if c_op != '%'}}
-                {{ival}} = -(sdigit)digits[0]; break;
-                {{endif}}
-                // fall through to positive calculation for '%'
-            case  1: {{ival}} = digits[0]; break;
-            {{for _size in (2, 3, 4)}}
-            {{for _case in (-_size, _size)}}
-            case {{_case}}: {{if c_op != '%' or _case > 0}}
-                if (8 * sizeof(long) - 1 > {{_size}} * PyLong_SHIFT{{if op == 'TrueDivide'}} && {{_size-1}} * PyLong_SHIFT < 53{{endif}}) {
-                    {{ival}} = {{'-' if _case < 0 else ''}}(long) {{pylong_join(_size, 'digits')}};
-                    break;
-                }
-                {{endif}}
-                // in negative case, fall through to positive calculation for '%'
-                // if size doesn't fit into a long anymore, fall through to default
-            {{endfor}}
-            {{endfor}}
-            default: return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+        // handle most common case first to avoid indirect branch and optimise branch prediction
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            {{ival}} = likely(size) ? digits[0] : 0;
+            {{if c_op != '%'}}if (size == -1) {{ival}} = -{{ival}};{{endif}}
+        } else {
+            switch (size) {
+                {{for _size in (2, 3, 4)}}
+                {{for _case in (-_size, _size)}}
+                case {{_case}}: {{if c_op != '%' or _case > 0}}
+                    if (8 * sizeof(long) - 1 > {{_size}} * PyLong_SHIFT{{if op == 'TrueDivide'}} && {{_size-1}} * PyLong_SHIFT < 53{{endif}}) {
+                        {{ival}} = {{'-' if _case < 0 else ''}}(long) {{pylong_join(_size, 'digits')}};
+                        break;
+                    }
+                    {{endif}}
+                    // in negative case, fall through to positive calculation for '%'
+                    // if size doesn't fit into a long anymore, fall through to default
+                {{endfor}}
+                {{endfor}}
+                default: return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+            }
         }
         {{if c_op == '%'}}
             x = a % b;

Cython/Utility/TypeConversion.c

@@ -297,23 +297,23 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
     #if CYTHON_USE_PYLONG_INTERNALS
     const digit* digits = ((PyLongObject*)b)->ob_digit;
     const Py_ssize_t size = Py_SIZE(b);
-    switch (size) {
-       case  0: return 0;
-       case  1: return digits[0];
-       case -1: return -(sdigit) digits[0];
-       default:
-          // move the substantially less common cases out of the way
-          switch (size) {
-             {{for _size in (2, 3, 4)}}
-             {{for _case in (_size, -_size)}}
-             case {{_case}}:
-               if (8 * sizeof(Py_ssize_t) > {{_size}} * PyLong_SHIFT) {
-                 return (Py_ssize_t) {{pylong_join(_size, 'digits', 'size_t')}};
-               }
-               break;
-             {{endfor}}
-             {{endfor}}
-          }
+    // handle most common case first to avoid indirect branch and optimise branch prediction
+    if (likely(__Pyx_sst_abs(size) <= 1)) {
+        ival = likely(size) ? digits[0] : 0;
+        if (size == -1) ival = -ival;
+        return ival;
+    } else {
+      switch (size) {
+         {{for _size in (2, 3, 4)}}
+         {{for _case in (_size, -_size)}}
+         case {{_case}}:
+           if (8 * sizeof(Py_ssize_t) > {{_size}} * PyLong_SHIFT) {
+             return (Py_ssize_t) {{pylong_join(_size, 'digits', 'size_t')}};
+           }
+           break;
+         {{endfor}}
+         {{endfor}}
+      }
     }
     #endif
     return PyLong_AsSsize_t(b);