Beispiel #1
0
    def _vector_float_unary(self, func, type, data):
        func = always_inline(func)

        size = rffi.sizeof(type)
        myjitdriver = JitDriver(greens = [], reds = 'auto', vectorize=True)
        def f(bytecount, va, vc):
            i = 0
            while i < bytecount:
                myjitdriver.jit_merge_point()
                a = raw_storage_getitem(type,va,i)
                c = func(a)
                raw_storage_setitem(vc, i, rffi.cast(type,c))
                i += size

        la = data.draw(st.lists(st.floats(), min_size=10, max_size=150))
        l = len(la)

        rawstorage = RawStorage()
        va = rawstorage.new(la, type)
        vc = rawstorage.new(None, type, size=l)
        self.meta_interp(f, [l*size, va, vc], vec=True)

        for i in range(l):
            c = raw_storage_getitem(type,vc,i*size)
            r = func(la[i])
            assert isclose(r, c)

        rawstorage.clear()
Beispiel #2
0
    def _vector_simple_int(self, func, type, la):
        oldfunc = func
        func = always_inline(func)

        size = rffi.sizeof(type)
        myjitdriver = JitDriver(greens = [], reds = 'auto', vectorize=True)
        def f(bytecount, va, vb, vc):
            i = 0
            while i < bytecount:
                myjitdriver.jit_merge_point()
                a = raw_storage_getitem(type,va,i)
                b = raw_storage_getitem(type,vb,i)
                c = func(a,b)
                raw_storage_setitem(vc, i, rffi.cast(type,c))
                i += size

        l = len(la)
        lb = list(reversed(la))[:]

        rawstorage = RawStorage()
        va = rawstorage.new(la, type)
        vb = rawstorage.new(lb, type)
        vc = rawstorage.new(None, type, size=l)
        self.meta_interp(f, [l*size, va, vb, vc], vec=True)

        for i in range(l):
            c = raw_storage_getitem(type,vc,i*size)
            assert rffi.cast(type, oldfunc(la[i], lb[i])) == c

        rawstorage.clear()
Beispiel #3
0
    def _vec_reduce(self, strat, func, type, data):
        func = always_inline(func)

        size = rffi.sizeof(type)
        myjitdriver = JitDriver(greens = [], reds = 'auto', vectorize=True)
        def f(accum, bytecount, v):
            i = 0
            while i < bytecount:
                myjitdriver.jit_merge_point()
                e = raw_storage_getitem(type,v,i)
                accum = func(accum,e)
                i += size
            return accum

        la = data.draw(st.lists(strat, min_size=10, max_size=150))
        #la = [1.0] * 10
        l = len(la)

        accum = data.draw(strat)
        rawstorage = RawStorage()
        va = rawstorage.new(la, type)
        res = self.meta_interp(f, [accum, l*size, va], vec=True)

        assert isclose(rffi.cast(type, res), f(accum, l*size, va))

        rawstorage.clear()
Beispiel #4
0
    def test_vector_float_unary(self, func, la):
        func = always_inline(func)
        tp = rffi.DOUBLE

        size = rffi.sizeof(tp)
        myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True)

        def f(bytecount, va, vc):
            i = 0
            while i < bytecount:
                myjitdriver.jit_merge_point()
                a = raw_storage_getitem(tp, va, i)
                c = func(a)
                raw_storage_setitem(vc, i, rffi.cast(tp, c))
                i += size

        l = len(la)
        rawstorage = RawStorage()
        va = rawstorage.new(la, tp)
        vc = rawstorage.new(None, tp, size=l)
        self.meta_interp(f, [l * size, va, vc], vec=True)

        for i in range(l):
            c = raw_storage_getitem(tp, vc, i * size)
            r = func(la[i])
            assert isclose(r, c)

        rawstorage.clear()
Beispiel #5
0
        def _vec_reduce(self, func, tp, la):
            func = always_inline(func)

            size = rffi.sizeof(tp)
            myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True)

            def f(accum, bytecount, v):
                i = 0
                while i < bytecount:
                    myjitdriver.jit_merge_point()
                    e = raw_storage_getitem(tp, v, i)
                    accum = func(accum, e)
                    i += size
                return accum

            accum = la[0]
            la = la[1:]
            l = len(la)
            rawstorage = RawStorage()
            va = rawstorage.new(la, tp)
            res = self.meta_interp(f, [accum, l * size, va], vec=True)

            assert isclose(rffi.cast(tp, res), f(accum, l * size, va))

            rawstorage.clear()
Beispiel #6
0
    def _vector_simple_int(self, func, type, la):
        oldfunc = func
        func = always_inline(func)

        size = rffi.sizeof(type)
        myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True)

        def f(bytecount, va, vb, vc):
            i = 0
            while i < bytecount:
                myjitdriver.jit_merge_point()
                a = raw_storage_getitem(type, va, i)
                b = raw_storage_getitem(type, vb, i)
                c = func(a, b)
                raw_storage_setitem(vc, i, rffi.cast(type, c))
                i += size

        l = len(la)
        lb = list(reversed(la))[:]

        rawstorage = RawStorage()
        va = rawstorage.new(la, type)
        vb = rawstorage.new(lb, type)
        vc = rawstorage.new(None, type, size=l)
        self.meta_interp(f, [l * size, va, vb, vc], vec=True)

        for i in range(l):
            c = raw_storage_getitem(type, vc, i * size)
            assert rffi.cast(type, oldfunc(la[i], lb[i])) == c

        rawstorage.clear()
Beispiel #7
0
    def _vector_simple_float(self, func, type, data):
        func = always_inline(func)

        size = rffi.sizeof(rffi.DOUBLE)
        myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True)

        def f(bytecount, va, vb, vc):
            i = 0
            while i < bytecount:
                myjitdriver.jit_merge_point()
                a = raw_storage_getitem(type, va, i)
                b = raw_storage_getitem(type, vb, i)
                c = func(a, b)
                raw_storage_setitem(vc, i, rffi.cast(type, c))
                i += size

        la = data.draw(st.lists(st.floats(), min_size=10, max_size=150))
        l = len(la)
        lb = data.draw(st.lists(st.floats(), min_size=l, max_size=l))

        rawstorage = RawStorage()
        va = rawstorage.new(la, type)
        vb = rawstorage.new(lb, type)
        vc = rawstorage.new(None, type, size=l)
        self.meta_interp(f, [l * size, va, vb, vc], vec=True)

        for i in range(l):
            c = raw_storage_getitem(type, vc, i * size)
            r = rffi.cast(type, func(la[i], lb[i]))
            assert isclose(r, c)

        rawstorage.clear()
    def _vec_reduce(self, strat, func, type, data):
        func = always_inline(func)

        size = rffi.sizeof(type)
        myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True)

        def f(accum, bytecount, v):
            i = 0
            while i < bytecount:
                myjitdriver.jit_merge_point()
                e = raw_storage_getitem(type, v, i)
                accum = func(accum, e)
                i += size
            return accum

        la = data.draw(st.lists(strat, min_size=10, max_size=150))
        #la = [1.0] * 10
        l = len(la)

        accum = data.draw(strat)
        rawstorage = RawStorage()
        va = rawstorage.new(la, type)
        res = self.meta_interp(f, [accum, l * size, va], vec=True)

        assert isclose(rffi.cast(type, res), f(accum, l * size, va))

        rawstorage.clear()