FUSEError Performance

In [1]:

    %load_ext cython

# Regular class vs extensions class¶

In [12]:

    %%cython
    cimport cython

    cdef class FUSEErrorExt(Exception):
        '''
        This exception may be raised by request handlers to indicate that
        the requested operation could not be carried out. The system call
        that resulted in the request (if any) will then fail with error
        code *errno_*.
        '''

        # If we call this variable "errno", we will get syntax errors
        # during C compilation (maybe something else declares errno as
        # a macro?)
        cdef int errno_

        property errno:
            '''Error code to return to client process'''
            def __get__(self):
                return self.errno_
            def __set__(self, val):
                self.errno_ = val

        def __init__(self, errno):
            self.errno_ = errno

    warning: /home/nikratio/.cache/ipython/cython/_cython_magic_f3365cad4f189403d0322b37c637671e.pyx:8:5: freelists cannot be used on subtypes, only the base class can manage them

In [4]:

    class FUSEErrorInt(Exception):
        def __init__(self, errno):
            self.errno = errno

In [5]:

    def test_ext():
        a = 0
        for i in range(100):
            try:
                raise FUSEErrorExt(i)
            except FUSEErrorExt as exc:
                a += exc.errno
            except:
                print('This should not happen')
        return a

    def test_int():
        a = 0
        for i in range(100):
            try:
                raise FUSEErrorInt(i)
            except FUSEErrorInt as exc:
                a += exc.errno
            except:
                print('This should not happen')
        return a

In [6]:

    assert test_ext() == test_int()
    %timeit test_ext()
    %timeit test_int()

    The slowest run took 8.54 times longer than the fastest. This could mean that an intermediate result is being cached.
    10000 loops, best of 3: 36 µs per loop
    10000 loops, best of 3: 57.9 µs per loop

# Instantiation vs Factory Function with Cache¶

(Unfortunately we cannot use @cython.freelist for derived classes)

In [7]:

    cache = dict()
    def getError(errno):
        try:
            return cache[errno]
        except KeyError:
            cache[errno] = FUSEErrorExt(errno)
            return cache[errno]

    def test_ext_cached():
        a = 0
        for i in range(100):
            try:
                raise getError(i)
            except FUSEErrorExt as exc:
                a += exc.errno
            except:
                print('This should not happen')
        return a

In [8]:

    assert test_ext() == test_ext_cached()
    %timeit test_ext()
    %timeit test_ext_cached()

    10000 loops, best of 3: 32.7 µs per loop
    10000 loops, best of 3: 32.4 µs per loop

## Catching Exception vs Ordinary Return¶

In [9]:

    def handler(i):
        return getError(i)

    def test_ext_direct():
        a = 0
        for i in range(100):
            res = handler(i)
            if isinstance(res, FUSEErrorExt):
                a += res.errno
        return a

In [10]:

    assert test_ext_cached() == test_ext_direct()
    %timeit test_ext_cached()
    %timeit test_ext_direct()

    The slowest run took 5.52 times longer than the fastest. This could mean that an intermediate result is being cached.
    10000 loops, best of 3: 32.4 µs per loop
    10000 loops, best of 3: 28.4 µs per loop

In [ ]: