merged in code object caching branch

Cython/Compiler/ModuleNode.py

@@ -1895,6 +1895,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         code.put_decref_clear(Naming.empty_tuple,
                               PyrexTypes.py_object_type,
                               nanny=False)
+        code.putln("/*--- Code object cache cleanup code ---*/")
+        code.globalstate.use_utility_code(
+            UtilityCode.load_cached("CodeObjectCache", "ModuleSetupCode.c"))
+        code.putln('%s();' % Naming.global_code_object_cache_clear)
 #        for entry in env.pynum_entries:
 #            code.put_decref_clear(entry.cname,
 #                                  PyrexTypes.py_object_type,

Cython/Compiler/Naming.py

@@ -99,6 +99,10 @@ binding_cfunc    = pyrex_prefix + "binding_PyCFunctionType"
 fused_func_prefix = pyrex_prefix + 'fuse_'
 quick_temp_cname = pyrex_prefix + "temp" # temp variable for quick'n'dirty temping
 
+global_code_object_cache_find = pyrex_prefix + 'find_code_object'
+global_code_object_cache_insert = pyrex_prefix + 'insert_code_object'
+global_code_object_cache_clear = pyrex_prefix + 'clear_code_object_cache'
+
 genexpr_id_ref = 'genexpr'
 
 line_c_macro = "__LINE__"

Cython/Compiler/Nodes.py

@@ -8634,6 +8634,8 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 
 #------------------------------------------------------------------------------------
 
+code_object_cache_utility_code = UtilityCode.load_cached("CodeObjectCache", "ModuleSetupCode.c")
+
 traceback_utility_code = UtilityCode(
     proto = """
 static void __Pyx_AddTraceback(const char *funcname, int %(CLINENO)s,
@@ -8709,9 +8711,13 @@ static void __Pyx_AddTraceback(const char *funcname, int %(CLINENO)s,
     PyObject *py_globals = 0;
     PyFrameObject *py_frame = 0;
 
-    py_code = __Pyx_CreateCodeObjectForTraceback(
-        funcname, %(CLINENO)s, %(LINENO)s, %(FILENAME)s);
-    if (!py_code) goto bad;
+    py_code = %(FINDCODEOBJECT)s(%(CLINENO)s ? %(CLINENO)s : %(LINENO)s);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, %(CLINENO)s, %(LINENO)s, %(FILENAME)s);
+        if (!py_code) goto bad;
+        %(INSERTCODEOBJECT)s(%(CLINENO)s ? %(CLINENO)s : %(LINENO)s, py_code);
+    }
     py_globals = PyModule_GetDict(%(GLOBALS)s);
     if (!py_globals) goto bad;
     py_frame = PyFrame_New(
@@ -8733,9 +8739,12 @@ bad:
     'CFILENAME': Naming.cfilenm_cname,
     'CLINENO':  Naming.clineno_cname,
     'GLOBALS': Naming.module_cname,
+    'FINDCODEOBJECT' : Naming.global_code_object_cache_find,
+    'INSERTCODEOBJECT' : Naming.global_code_object_cache_insert,
     'EMPTY_TUPLE' : Naming.empty_tuple,
     'EMPTY_BYTES' : Naming.empty_bytes,
-})
+},
+requires=[code_object_cache_utility_code])
 
 #------------------------------------------------------------------------------------
 

Cython/Utility/ModuleSetupCode.c

@@ -219,6 +219,126 @@
   #define __Pyx_DOCSTR(n)  (n)
 #endif
 
+/////////////// CodeObjectCache.proto ///////////////
+
+typedef struct {
+    int code_line;
+    PyCodeObject* code_object;
+} __Pyx_CodeObjectCacheEntry;
+
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static void __pyx_clear_code_object_cache(void);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+
+/////////////// CodeObjectCache ///////////////
+// Note that errors are simply ignored in the code below.
+// This is just a cache, if a lookup or insertion fails - so what?
+
+static void __pyx_clear_code_object_cache(void) {
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    int count = __pyx_code_cache.count;
+    int i;
+    if (entries == NULL) {
+        return;
+    }
+    __pyx_code_cache.count = 0;
+    __pyx_code_cache.max_count = 0;
+    __pyx_code_cache.entries = NULL;
+    for (i=0; i<count; i++) {
+        Py_DECREF(entries[i].code_object);
+    }
+    PyMem_Free(entries);
+}
+
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = (start + end) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, new_max*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
 
 /////////////// CheckBinaryVersion.proto ///////////////
 

tests/run/code_object_cache.pyx

+# mode: run
+# tag: except
+
+# test the code object cache that is being used in exception raising
+
+### low level tests
+
+cdef extern from *:
+    # evil hack to access the internal utility function
+    ctypedef struct PyCodeObject
+    ctypedef struct __Pyx_CodeObjectCacheEntry:
+        int code_line
+        PyCodeObject* code_object
+    int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line)
+
+def test_lowlevel_bisect2(*indices):
+    """
+    >>> test_lowlevel_bisect2(1, 2, 3, 4, 5, 6)
+    [0, 0, 1, 1, 2, 2]
+    """
+    cdef __Pyx_CodeObjectCacheEntry* cache = [
+        __Pyx_CodeObjectCacheEntry(2, NULL),
+        __Pyx_CodeObjectCacheEntry(4, NULL),
+        ]
+    return [ __pyx_bisect_code_objects(cache, 2, i)
+             for i in indices ]
+
+def test_lowlevel_bisect5(*indices):
+    """
+    >>> test_lowlevel_bisect5(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+    [0, 1, 2, 2, 2, 3, 3, 3, 4, 5, 5]
+    """
+    cdef __Pyx_CodeObjectCacheEntry* cache = [
+        __Pyx_CodeObjectCacheEntry(1, NULL),
+        __Pyx_CodeObjectCacheEntry(2, NULL),
+        __Pyx_CodeObjectCacheEntry(5, NULL),
+        __Pyx_CodeObjectCacheEntry(8, NULL),
+        __Pyx_CodeObjectCacheEntry(9, NULL),
+        ]
+    return [ __pyx_bisect_code_objects(cache, 5, i)
+             for i in indices ]
+
+def test_lowlevel_bisect6(*indices):
+    """
+    >>> test_lowlevel_bisect6(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+    [0, 0, 1, 2, 2, 2, 3, 3, 4, 5, 5, 5, 6]
+    """
+    cdef __Pyx_CodeObjectCacheEntry* cache = [
+        __Pyx_CodeObjectCacheEntry(2, NULL),
+        __Pyx_CodeObjectCacheEntry(3, NULL),
+        __Pyx_CodeObjectCacheEntry(6, NULL),
+        __Pyx_CodeObjectCacheEntry(8, NULL),
+        __Pyx_CodeObjectCacheEntry(9, NULL),
+        __Pyx_CodeObjectCacheEntry(12, NULL),
+        ]
+    return [ __pyx_bisect_code_objects(cache, 6, i)
+             for i in indices ]
+
+### Python level tests
+
+import sys
+
+def tb():
+    return sys.exc_info()[-1]
+
+def raise_keyerror():
+    raise KeyError
+
+def check_code_object_identity_recursively(tb1, tb2):
+    if tb1 is None or tb2 is None:
+        return
+    code1, code2 = tb1.tb_frame.f_code, tb2.tb_frame.f_code
+    if code1 is not code2:
+        print('%s != %s' % (code1, code2))
+    check_code_object_identity_recursively(tb1.tb_next, tb2.tb_next)
+
+def assert_simple_code_object_reuse():
+    """
+    >>> try: assert_simple_code_object_reuse()
+    ... except KeyError: t1 = tb()
+    >>> try: assert_simple_code_object_reuse()
+    ... except KeyError: t2 = tb()
+    >>> check_code_object_identity_recursively(t1.tb_next, t2.tb_next)
+    """
+    raise KeyError
+
+def assert_multi_step_code_object_reuse(recursions=0):
+    """
+    >>> for depth in range(5):
+    ...     try: assert_multi_step_code_object_reuse(depth)
+    ...     except KeyError: t1 = tb()
+    ...     try: assert_multi_step_code_object_reuse(depth)
+    ...     except KeyError: t2 = tb()
+    ...     check_code_object_identity_recursively(t1.tb_next, t2.tb_next)
+    """
+    if recursions:
+        assert_multi_step_code_object_reuse(recursions-1)
+    else:
+        raise_keyerror()