[issue4258] Use 30-bit digits instead of 15-bit digits for Python integers.

Objects/longobject.c

 /* Long (arbitrary precision) integer object implementation */
 
 /* XXX The functional organization of this file is terrible */
 
 #include "Python.h"
 #include "longintrepr.h"
+#include "structseq.h"
 
 #include <ctype.h>
 #include <stddef.h>
 
 #ifndef NSMALLPOSINTS
 #define NSMALLPOSINTS           257
 #endif
 #ifndef NSMALLNEGINTS
 #define NSMALLNEGINTS           5
 #endif
@@ skipping 180 matching lines @@
         if (!(abs_ival >> PyLong_SHIFT)) {
                 v = _PyLong_New(1);
                 if (v) {
                         Py_SIZE(v) = sign;
                         v->ob_digit[0] = Py_SAFE_DOWNCAST(
                                 abs_ival, unsigned long, digit);
                 }
                 return (PyObject*)v;
         }
 
+#if PyLONG_SHIFT==15
         /* 2 digits */
         if (!(abs_ival >> 2*PyLong_SHIFT)) {
                 v = _PyLong_New(2);
                 if (v) {
                         Py_SIZE(v) = 2*sign;
                         v->ob_digit[0] = Py_SAFE_DOWNCAST(
                                 abs_ival & PyLong_MASK, unsigned long, digit);
                         v->ob_digit[1] = Py_SAFE_DOWNCAST(
                               abs_ival >> PyLong_SHIFT, unsigned long, digit);
                 }
                 return (PyObject*)v;
         }
+#endif
 
         /* Larger numbers: loop to determine number of digits */
         t = abs_ival;
         while (t) {
                 ++ndigits;
                 t >>= PyLong_SHIFT;
         }
         v = _PyLong_New(ndigits);
         if (v != NULL) {
                 digit *p = v->ob_digit;
@@ skipping 2628 matching lines @@
         return NULL;
 }
 
 static PyObject *
 long_mul(PyLongObject *a, PyLongObject *b)
 {
         PyLongObject *z;
 
         CHECK_BINOP(a, b);
 
+        /* fast path for single-digit multiplication */
         if (ABS(Py_SIZE(a)) <= 1 && ABS(Py_SIZE(b)) <= 1) {
-                PyObject *r;
-                r = PyLong_FromLong(MEDIUM_VALUE(a)*MEDIUM_VALUE(b));
-                return r;
+                /* XXX benchmark this! Is is worth keeping? */

[Martin v. Löwis, 2009/02/17 22:39:18]

Why not PyLong_FromLongLong if available (no special case if not)?

[dickinsm, 2009/02/18 17:06:33]

Yes, PyLong_FromLongLong would make sense.  If this is not available,
we still need to make sure that CHECK_SMALL_INT gets called.

+                twodigits absz;
+                int sign;
+                sign = Py_SIZE(a) * Py_SIZE(b);
+                if (sign == 0)
+                        return PyLong_FromLong(0L);
+                absz = (twodigits)a->ob_digit[0] * b->ob_digit[0];
+                if (absz < PyLong_BASE) {
+                        CHECK_SMALL_INT((sdigit)(sign*absz));
+                        z = _PyLong_New(1);
+                        if (z != NULL) {
+                                Py_SIZE(z) = sign;
+                                z->ob_digit[0] = (digit)absz;
+                        }
+                }
+                else {
+                        z = _PyLong_New(2);
+                        if (z != NULL) {
+                                Py_SIZE(z) = 2*sign;
+                                z->ob_digit[0] = (digit)(absz & PyLong_MASK);
+                                assert(absz >>= 2*PyLong_SHIFT == 0);
+                                z->ob_digit[1] = (digit)(absz >> PyLong_SHIFT);
+                        }
+                }
+                return (PyObject *)z;
         }
 
         z = k_mul(a, b);
         /* Negate if exactly one of the inputs is negative. */
         if (((Py_SIZE(a) ^ Py_SIZE(b)) < 0) && z)
                 NEGATE(z);
         return (PyObject *)z;
 }
 
 /* The / and % operators are now defined in terms of divmod().
@@ skipping 1103 matching lines @@
         0,                                      /* tp_dict */
         0,                                      /* tp_descr_get */
         0,                                      /* tp_descr_set */
         0,                                      /* tp_dictoffset */
         0,                                      /* tp_init */
         0,                                      /* tp_alloc */
         long_new,                               /* tp_new */
         PyObject_Del,                           /* tp_free */
 };
 
+static PyTypeObject Int_InfoType;
+
+PyDoc_STRVAR(int_info__doc__,
+"sys.int_info\n\
+\n\
+A struct sequence that holds information about Python's\n\
+internal representation of integers.  The attributes are read only.");
+
+static PyStructSequence_Field int_info_fields[] = {
+        {"bits_per_digit", "size of a digit in bits"},
+        {"sizeof_digit", "size in bytes of the C type used to "
+                         "represent a digit"},
+        {NULL, NULL}
+};
+
+static PyStructSequence_Desc int_info_desc = {
+        "sys.int_info",   /* name */
+        int_info__doc__,  /* doc */
+        int_info_fields,  /* fields */
+        2                 /* number of fields */
+};
+
+PyObject *
+PyLong_GetInfo(void)
+{
+        PyObject* int_info;
+        int field = 0;
+        int_info = PyStructSequence_New(&Int_InfoType);
+        if (int_info == NULL)
+                return NULL;
+        PyStructSequence_SET_ITEM(int_info, field++, PyLong_FromLong(PyLong_SHIFT));
+        PyStructSequence_SET_ITEM(int_info, field++, PyLong_FromLong(sizeof(digit)));
+        if (PyErr_Occurred()) {
+                Py_CLEAR(int_info);
+                return NULL;
+        }
+        return int_info;
+}
+
 int
 _PyLong_Init(void)
 {
 #if NSMALLNEGINTS + NSMALLPOSINTS > 0
         int ival, size;
         PyLongObject *v = small_ints;
 
         for (ival = -NSMALLNEGINTS; ival <  NSMALLPOSINTS; ival++, v++) {
                 size = (ival < 0) ? -1 : ((ival == 0) ? 0 : 1);
                 if (Py_TYPE(v) == &PyLong_Type) {
@@ skipping 12 matching lines @@
                         assert(Py_SIZE(op) == size);
                         assert(v->ob_digit[0] == abs(ival));
                 }
                 else {
                         PyObject_INIT(v, &PyLong_Type);
                 }
                 Py_SIZE(v) = size;
                 v->ob_digit[0] = abs(ival);
         }
 #endif
+        /* initialize int_info */
+        if (Int_InfoType.tp_name == 0)
+                PyStructSequence_InitType(&Int_InfoType, &int_info_desc);
+
         return 1;
 }
 
 void
 PyLong_Fini(void)
 {
         /* Integers are currently statically allocated. Py_DECREF is not
            needed, but Python must forget about the reference or multiple
            reinitializations will fail. */
 #if NSMALLNEGINTS + NSMALLPOSINTS > 0
         int i;
         PyLongObject *v = small_ints;
         for (i = 0; i < NSMALLNEGINTS + NSMALLPOSINTS; i++, v++) {
                 _Py_DEC_REFTOTAL;
                 _Py_ForgetReference((PyObject*)v);
         }
 #endif
 }