def f(d): va = lltype.malloc(T, d, flavor='raw', zero=True) vb = lltype.malloc(T, d, flavor='raw', zero=True) for j in range(d): va[j] = rffi.r_int(j) vb[j] = rffi.r_int(j) i = 0 while i < d: myjitdriver.jit_merge_point() if i < 0: raise IndexError if i >= d: raise IndexError a = va[i] if i < 0: raise IndexError if i >= d: raise IndexError b = vb[i] ec = intmask(a) + intmask(b) if i < 0: raise IndexError if i >= d: raise IndexError va[i] = rffi.r_int(ec) i += 1 lltype.free(va, flavor='raw') lltype.free(vb, flavor='raw') return 0
def assert_keypress(sut, mocked_sdl_event_queue, stub_events, sdl_key, char): # given keydown = stub_events.malloc(RSDL.KeyboardEvent) keydown.c_type = RSDL.KEYDOWN keydown.c_keysym.c_sym = rffi.r_int(sdl_key) textinput = stub_events.malloc(RSDL.TextInputEvent) textinput.c_type = RSDL.TEXTINPUT rffi.str2chararray( str(char) + '\x00', textinput.c_text, RSDL.TEXTINPUTEVENT_TEXT_SIZE) keyup = stub_events.malloc(RSDL.KeyboardEvent) keyup.c_type = RSDL.KEYUP keyup.c_keysym.c_sym = rffi.r_int(sdl_key) mocked_sdl_event_queue.append(keydown) mocked_sdl_event_queue.append(textinput) mocked_sdl_event_queue.append(keyup) # when first_event = sut.get_next_event() second_event = sut.get_next_event() third_event = sut.get_next_event() # then assert_keyevent_array(first_event, ord(char.upper()), display.EventKeyDown, 0) assert_keyevent_array(second_event, ord(char), display.EventKeyChar, 0) assert_keyevent_array(third_event, ord(char.upper()), display.EventKeyUp, 0)
def f(d): va = lltype.malloc(T, d, flavor='raw', zero=True) vb = lltype.malloc(T, d, flavor='raw', zero=True) for j in range(d): va[j] = rffi.r_int(j) vb[j] = rffi.r_int(j) i = 0 while i < d: myjitdriver.jit_merge_point() if i < 0: raise IndexError if i >= d: raise IndexError a = va[i] if i < 0: raise IndexError if i >= d: raise IndexError b = vb[i] ec = intmask(a)+intmask(b) if i < 0: raise IndexError if i >= d: raise IndexError va[i] = rffi.r_int(ec) i += 1 lltype.free(va, flavor='raw') lltype.free(vb, flavor='raw') return 0
def to_str(self, base=10): assert 2 <= base <= 62 l = c_mpz_sizeinbase(self.value, rffi.r_int(base)) + 2 p = lltype.malloc(rffi.CCHARP.TO, l, flavor='raw') c_mpz_get_str(p, rffi.r_int(base), self.value) result = rffi.charp2str(p) lltype.free(p, flavor='raw') return result
def assert_updated_metrics(width, height): stub_window_event.c_event = RSDL.WINDOWEVENT_RESIZED stub_window_event.c_data1 = rffi.r_int(width) stub_window_event.c_data2 = rffi.r_int(height) mocked_sdl_event_queue.append(stub_window_event) result = sut.get_next_event() # TODO: decide whether no events or windowmetric events should be raised assert sut.width == width assert sut.height == height
def test_entering_captital_letters(sut, mocked_sdl_event_queue, stub_events, stub_mod_state): # when # shift down shift_down = stub_events.malloc(RSDL.KeyboardEvent) shift_down.c_type = RSDL.KEYDOWN shift_down.c_keysym.c_sym = rffi.r_int(RSDL.K_LSHIFT) mocked_sdl_event_queue.append(shift_down) stub_mod_state.set(RSDL.KMOD_SHIFT) sqShiftDown = sut.get_next_event() # A down a_down = stub_events.malloc(RSDL.KeyboardEvent) a_down.c_type = RSDL.KEYDOWN a_down.c_keysym.c_sym = rffi.r_int(RSDL.K_a) mocked_sdl_event_queue.append(a_down) sqADown = sut.get_next_event() # A entered a_textinput = stub_events.malloc(RSDL.TextInputEvent) a_textinput.c_type = RSDL.TEXTINPUT rffi.str2chararray('A\x00', a_textinput.c_text, RSDL.TEXTINPUTEVENT_TEXT_SIZE) mocked_sdl_event_queue.append(a_textinput) sqAStroke = sut.get_next_event() # repeat A entered mocked_sdl_event_queue.append(a_down) mocked_sdl_event_queue.append(a_textinput) sqADown2 = sut.get_next_event() sqAStroke2 = sut.get_next_event() # A up a_up = stub_events.malloc(RSDL.KeyboardEvent) a_up.c_type = RSDL.KEYUP a_up.c_keysym.c_sym = rffi.r_int(RSDL.K_a) mocked_sdl_event_queue.append(a_up) sqAUp = sut.get_next_event() # shift up shift_up = stub_events.malloc(RSDL.KeyboardEvent) shift_up.c_type = RSDL.KEYUP shift_up.c_keysym.c_sym = rffi.r_int(RSDL.K_LSHIFT) mocked_sdl_event_queue.append(shift_up) stub_mod_state.set(RSDL.KMOD_NONE) sqShiftUp = sut.get_next_event() # then assert_keyevent_array(sqShiftDown, key_constants.SHIFT, display.EventKeyDown, display.ShiftKeyBit) assert_keyevent_array(sqADown, ord('A'), display.EventKeyDown, display.ShiftKeyBit) assert_keyevent_array(sqAStroke, ord('A'), display.EventKeyChar, display.ShiftKeyBit) assert_keyevent_array(sqADown2, ord('A'), display.EventKeyDown, display.ShiftKeyBit) assert_keyevent_array(sqAStroke2, ord('A'), display.EventKeyChar, display.ShiftKeyBit) assert_keyevent_array(sqAUp, ord('A'), display.EventKeyUp, display.ShiftKeyBit) assert_keyevent_array(sqShiftUp, key_constants.SHIFT, display.EventKeyUp, 0)
def test_keyboard_chords(sut, mocked_sdl_event_queue, stub_events, stub_mod_state): # when # CTRL down ctrl_down = stub_events.malloc(RSDL.KeyboardEvent) ctrl_down.c_type = RSDL.KEYDOWN ctrl_down.c_keysym.c_sym = rffi.r_int(RSDL.K_LCTRL) mocked_sdl_event_queue.append(ctrl_down) stub_mod_state.set(RSDL.KMOD_CTRL) sqCtrlDown = sut.get_next_event() # A down a_down = stub_events.malloc(RSDL.KeyboardEvent) a_down.c_type = RSDL.KEYDOWN a_down.c_keysym.c_sym = rffi.r_int(RSDL.K_a) mocked_sdl_event_queue.append(a_down) sqADown = sut.get_next_event() # A entered if system.IS_LINUX: # on linux, we don't get this a_stroke = stub_events.malloc(RSDL.TextInputEvent) a_stroke.c_type = RSDL.TEXTINPUT rffi.str2chararray('a\x00', a_stroke.c_text, RSDL.TEXTINPUTEVENT_TEXT_SIZE) mocked_sdl_event_queue.append(a_stroke) sqAStroke = sut.get_next_event() # repeat A mocked_sdl_event_queue.append(a_down) sqADown2 = sut.get_next_event() if system.IS_LINUX: # on linux, we don't get this a_stroke = stub_events.malloc(RSDL.TextInputEvent) a_stroke.c_type = RSDL.TEXTINPUT rffi.str2chararray('a\x00', a_stroke.c_text, RSDL.TEXTINPUTEVENT_TEXT_SIZE) mocked_sdl_event_queue.append(a_stroke) sqAStroke2 = sut.get_next_event() # A up a_up = stub_events.malloc(RSDL.KeyboardEvent) a_up.c_type = RSDL.KEYUP a_up.c_keysym.c_sym = rffi.r_int(RSDL.K_a) mocked_sdl_event_queue.append(a_up) sqAUp = sut.get_next_event() # CTRL up ctrl_up = stub_events.malloc(RSDL.KeyboardEvent) ctrl_up.c_type = RSDL.KEYUP ctrl_up.c_keysym.c_sym = rffi.r_int(RSDL.K_LCTRL) mocked_sdl_event_queue.append(ctrl_up) stub_mod_state.set(RSDL.KMOD_NONE) sqCtrlUp = sut.get_next_event() # then assert_keyevent_array(sqCtrlDown, key_constants.CTRL, display.EventKeyDown, display.CtrlKeyBit) assert_keyevent_array(sqADown, ord('A'), display.EventKeyDown, display.CtrlKeyBit) assert_keyevent_array(sqAStroke, ord('a'), display.EventKeyChar, display.CtrlKeyBit) assert_keyevent_array(sqADown2, ord('A'), display.EventKeyDown, display.CtrlKeyBit) assert_keyevent_array(sqAStroke2, ord('a'), display.EventKeyChar, display.CtrlKeyBit) assert_keyevent_array(sqAUp, ord('A'), display.EventKeyUp, display.CtrlKeyBit) assert_keyevent_array(sqCtrlUp, key_constants.CTRL, display.EventKeyUp, 0)
def msg_recv(socket): result = [] morep = rffi.lltype.malloc(rffi.INTP.TO, 1, flavor='raw') morep[0] = rffi.r_int(1) more_sizep = rffi.lltype.malloc(rffi.UINTP.TO, 1, flavor='raw') more_sizep[0] = rffi.r_uint(rffi.sizeof(rffi.INT)) while int(morep[0]): part = rffi.lltype.malloc(rzmq.msg_t.TO, flavor='raw') rc = rzmq.msg_init(part) assert rc == 0 msg_size = rzmq.msg_recv(part, socket, 0) assert msg_size != -1 result.append(rffi.charpsize2str(rzmq.msg_data(part), msg_size)) rc = rzmq.getsockopt(socket, rzmq.RCVMORE, morep, more_sizep) assert rc == 0 rc = rzmq.msg_close(part) assert rc == 0 return result
def assert_updated_metrics(width, height, check_destroy, assert_destroyed_last=True): stub_window_event.c_event = RSDL.WINDOWEVENT_RESIZED stub_window_event.c_data1 = rffi.r_int(width) stub_window_event.c_data2 = rffi.r_int(height) mocked_sdl_event_queue.append(stub_window_event) result = sut.get_next_event() stub_screen_texture_creation.reverse() if check_destroy: call = stub_screen_texture_creation.pop() assert call['function'] == RSDL.DestroyTexture assert call['is_last_created_texture'] == assert_destroyed_last call = stub_screen_texture_creation.pop() assert call['function'] == RSDL.CreateTexture assert call['width'] == width assert call['height'] == height
def to_str(self, base=10): assert 2 <= base <= 62 expp = lltype.malloc(MP_EXP_TP.TO, 1, flavor='raw') n = int(self.prec * log(2) / log(10)) l = n + 2 strp = lltype.malloc(rffi.CCHARP.TO, l, flavor='raw') c_mpf_get_str(strp, expp, rffi.r_int(base), rffi.r_size_t(n), self.value) result = rffi.charp2str(strp) exp = expp[0] lltype.free(strp, flavor='raw') lltype.free(expp, flavor='raw') # format result if result.startswith('-'): sign = '-' result = result[1:] else: sign = '' if 1 <= exp <= 6: pos = exp exp = '' result = result + (pos-len(result)) * '0' elif -4 <= exp <= 0: pos = 1 result = '0' * (1-exp) + result exp = '' else: pos = 1 exp = '*^' + str(exp-1) # TODO: precision return sign + result[:pos] + '.' + result[pos:] + exp
def str2Integer(value, base=10): assert isinstance(value, str) assert 2 <= base <= 62 result = Integer() p = rffi.str2charp(value) retcode = c_mpz_set_str(result.value, p, rffi.r_int(base)) assert retcode == 0 rffi.free_charp(p) return result
def str2Rational(value, base=10): assert isinstance(value, str) assert 2 <= base <= 62 result = Rational() p = rffi.str2charp(value) retcode = c_mpq_set_str(result.value, p, rffi.r_int(base)) assert retcode == 0 c_mpq_canonicalize(result.value) rffi.free_charp(p) return result
def str2Real(value, prec, base=10): assert isinstance(value, str) assert 2 <= base <= 62 result = Real(prec) p = rffi.str2charp(value) # we pass negative base so that the exponent is intepreted as decimal retcode = c_mpf_set_str(result.value, p, rffi.r_int(-base)) assert retcode == 0 rffi.free_charp(p) return result
def to_str(self, base=10): assert 2 <= base <= 62 # find the required length num = lltype.malloc(MPZ_STRUCT, flavor='raw') den = lltype.malloc(MPZ_STRUCT, flavor='raw') c_mpq_get_num(num, self.value) c_mpq_get_den(den, self.value) l = (c_mpz_sizeinbase(num, rffi.r_int(base)) + c_mpz_sizeinbase(den, rffi.r_int(base)) + 3) lltype.free(num, flavor='raw') lltype.free(den, flavor='raw') # get the str p = lltype.malloc(rffi.CCHARP.TO, l, flavor='raw') c_mpq_get_str(p, base, self.value) result = rffi.charp2str(p) lltype.free(p, flavor='raw') return result
def test_keyboard_chords(sut, mocked_sdl_event_queue, stub_events, stub_mod_state): # when # CTRL down ctrl_down = stub_events.malloc(RSDL.KeyboardEvent) ctrl_down.c_type = RSDL.KEYDOWN ctrl_down.c_keysym.c_sym = rffi.r_int(RSDL.K_LCTRL) mocked_sdl_event_queue.append(ctrl_down) stub_mod_state.set(RSDL.KMOD_CTRL) sqCtrlDown = sut.get_next_event() # A down a_down = stub_events.malloc(RSDL.KeyboardEvent) a_down.c_type = RSDL.KEYDOWN a_down.c_keysym.c_sym = rffi.r_int(RSDL.K_a) mocked_sdl_event_queue.append(a_down) sqADown = sut.get_next_event() # A entered sqAStroke = sut.get_next_event() # repeat A mocked_sdl_event_queue.append(a_down) sqADown2 = sut.get_next_event() sqAStroke2 = sut.get_next_event() # A up a_up = stub_events.malloc(RSDL.KeyboardEvent) a_up.c_type = RSDL.KEYUP a_up.c_keysym.c_sym = rffi.r_int(RSDL.K_a) mocked_sdl_event_queue.append(a_up) sqAUp = sut.get_next_event() # CTRL up ctrl_up = stub_events.malloc(RSDL.KeyboardEvent) ctrl_up.c_type = RSDL.KEYUP ctrl_up.c_keysym.c_sym = rffi.r_int(RSDL.K_LCTRL) mocked_sdl_event_queue.append(ctrl_up) stub_mod_state.set(RSDL.KMOD_NONE) sqCtrlUp = sut.get_next_event() # then assert_keyevent_array(sqCtrlDown, key_constants.CTRL, display.EventKeyDown, display.CtrlKeyBit) assert_keyevent_array(sqADown, ord('A'), display.EventKeyDown, display.CtrlKeyBit) assert_keyevent_array(sqAStroke, ord('a'), display.EventKeyChar, display.CtrlKeyBit) assert_keyevent_array(sqADown2, ord('A'), display.EventKeyDown, display.CtrlKeyBit) assert_keyevent_array(sqAStroke2, ord('a'), display.EventKeyChar, display.CtrlKeyBit) assert_keyevent_array(sqAUp, ord('A'), display.EventKeyUp, display.CtrlKeyBit) assert_keyevent_array(sqCtrlUp, key_constants.CTRL, display.EventKeyUp, 0)
def eventloop(self): ''' Poll each socket in turn and respond to any messages. For long running evaluations the heartbeat message may be sent too late ''' pollitem = rffi.lltype.malloc(rzmq.pollitem_t, flavor='raw') pollitem.c_events = rffi.r_short(rzmq.POLLIN) while True: # Shell pollitem.c_socket = self.shell rc = rzmq.poll(pollitem, rffi.r_int(1), rffi.r_long(100)) if rc > 0: rlogging.debug('shell message') request = self.msg_recv(self.shell) self.msg_send( self.iopub, self.construct_message( # report kernel busy request[0], request[3], '{"execution_state":"busy"}', 'status')) self.shell_msg(request) self.msg_send( self.iopub, self.construct_message( # report kernel idle request[0], request[3], '{"execution_state":"idle"}', 'status')) # Control pollitem.c_socket = self.control while rzmq.poll(pollitem, rffi.r_int(1), rffi.r_long(1)) > 0: rlogging.debug('control message') request = self.msg_recv(self.control) self.control_msg(request) # HB pollitem.c_socket = self.hb while rzmq.poll(pollitem, rffi.r_int(1), rffi.r_long(1)) > 0: rlogging.debug('hearbeat message') request = self.msg_recv(self.hb) self.hb_msg(request)
def assert_keydownup(display_under_test, mocked_sdl_event_queue, stub_events, sdl_key, char): assert char.isupper() or not char.isalpha(), \ "asserted char for KeyDown and KeyUp must be uppercase" # given keydown = stub_events.malloc(RSDL.KeyboardEvent) keydown.c_type = RSDL.KEYDOWN keydown.c_keysym.c_sym = rffi.r_int(sdl_key) keyup = stub_events.malloc(RSDL.KeyboardEvent) keyup.c_type = RSDL.KEYUP keyup.c_keysym.c_sym = rffi.r_int(sdl_key) mocked_sdl_event_queue.append(keydown) mocked_sdl_event_queue.append(keyup) # when sqKeyDown = display_under_test.get_next_event() sqKeyStroke = display_under_test.get_next_event() sqKeyUp = display_under_test.get_next_event() # then assert_keyevent_array(sqKeyDown, ord(char), display.EventKeyDown, 0) assert_keyevent_array(sqKeyStroke, ord(char), display.EventKeyChar, 0) assert_keyevent_array(sqKeyUp, ord(char), display.EventKeyUp, 0)
def assert_keypress(sut, mocked_sdl_event_queue, stub_events, sdl_key, char): # given keydown = stub_events.malloc(RSDL.KeyboardEvent) keydown.c_type = RSDL.KEYDOWN keydown.c_keysym.c_sym = rffi.r_int(sdl_key) textinput = stub_events.malloc(RSDL.TextInputEvent) textinput.c_type = RSDL.TEXTINPUT rffi.str2chararray(str(char) + '\x00', textinput.c_text, RSDL.TEXTINPUTEVENT_TEXT_SIZE) keyup = stub_events.malloc(RSDL.KeyboardEvent) keyup.c_type = RSDL.KEYUP keyup.c_keysym.c_sym = rffi.r_int(sdl_key) mocked_sdl_event_queue.append(keydown) mocked_sdl_event_queue.append(textinput) mocked_sdl_event_queue.append(keyup) # when first_event = sut.get_next_event() second_event = sut.get_next_event() third_event = sut.get_next_event() # then assert_keyevent_array(first_event, ord(char.upper()), display.EventKeyDown, 0) assert_keyevent_array(second_event, ord(char), display.EventKeyChar, 0) assert_keyevent_array(third_event, ord(char.upper()), display.EventKeyUp, 0)
def eventloop(self): ''' Poll each socket in turn and respond to any messages. For long running evaluations the heartbeat message may be sent too late ''' pollitem = rffi.lltype.malloc(rzmq.pollitem_t, flavor='raw') pollitem.c_events = rffi.r_short(rzmq.POLLIN) while True: # Shell pollitem.c_socket = self.shell rc = rzmq.poll(pollitem, rffi.r_int(1), rffi.r_long(100)) if rc > 0: rlogging.debug('shell message') request = self.msg_recv(self.shell) self.msg_send(self.iopub, self.construct_message( # report kernel busy request[0], request[3], '{"execution_state":"busy"}', 'status')) self.shell_msg(request) self.msg_send(self.iopub, self.construct_message( # report kernel idle request[0], request[3], '{"execution_state":"idle"}', 'status')) # Control pollitem.c_socket = self.control while rzmq.poll(pollitem, rffi.r_int(1), rffi.r_long(1)) > 0: rlogging.debug('control message') request = self.msg_recv(self.control) self.control_msg(request) # HB pollitem.c_socket = self.hb while rzmq.poll(pollitem, rffi.r_int(1), rffi.r_long(1)) > 0: rlogging.debug('hearbeat message') request = self.msg_recv(self.hb) self.hb_msg(request)
def f(d): i = 0 va = lltype.malloc(T, d, flavor="raw", zero=True) vb = lltype.malloc(T, d, flavor="raw", zero=True) vc = lltype.malloc(T, d, flavor="raw", zero=True) for j in range(d): va[j] = rffi.r_int(j) vb[j] = rffi.r_int(j) while i < d: myjitdriver.jit_merge_point() a = va[i] b = vb[i] ec = intmask(a) + intmask(b) vc[i] = rffi.r_int(ec) i += 1 res = 0 for j in range(d): res += intmask(vc[j]) lltype.free(va, flavor="raw") lltype.free(vb, flavor="raw") lltype.free(vc, flavor="raw") return res
def record_damage(self, x, y, w, h): FLIP_RECT.c_x = rffi.r_int(x) FLIP_RECT.c_y = rffi.r_int(y) FLIP_RECT.c_w = rffi.r_int(min(w + 1, self.width - x)) FLIP_RECT.c_h = rffi.r_int(min(h + 1, self.height - y)) RSDL.UnionRect(FLIP_RECT, RENDER_RECT, RENDER_RECT)
def full_damage(self): RENDER_RECT.c_x = rffi.r_int(0) RENDER_RECT.c_y = rffi.r_int(0) RENDER_RECT.c_w = rffi.r_int(self.width) RENDER_RECT.c_h = rffi.r_int(self.height)
def reset_damage(self): RENDER_RECT.c_x = rffi.r_int(0) RENDER_RECT.c_y = rffi.r_int(0) RENDER_RECT.c_w = rffi.r_int(0) RENDER_RECT.c_h = rffi.r_int(0)
class VectorizeTests(object): enable_opts = 'intbounds:rewrite:virtualize:string:earlyforce:pure:heap:unroll' def setup_method(self, method): if not self.supports_vector_ext(): py.test.skip("this cpu %s has no implemented vector backend" % CPU) # FLOAT UNARY @pytest.mark.parametrize('func', [lambda v: abs(v), lambda v: -v], ids=['abs', 'neg']) @given(la=st.lists(st.floats(), min_size=10, max_size=150)) 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() # FLOAT BINARY 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_float_binary(test_func, func, type): return pytest.mark.parametrize('func,type', [(func, type)])( given(data=st.data())(test_func)) vec_float_binary = functools.partial(_vec_float_binary, _vector_simple_float) test_vec_float_add = \ vec_float_binary(lambda a,b: a+b, rffi.DOUBLE) test_vec_float_sub = \ vec_float_binary(lambda a,b: a-b, rffi.DOUBLE) test_vec_float_mul = \ vec_float_binary(lambda a,b: a*b, rffi.DOUBLE) test_vec_float_cmp_eq = \ vec_float_binary(lambda a,b: a == b, rffi.DOUBLE) test_vec_float_cmp_ne = \ vec_float_binary(lambda a,b: a != b, rffi.DOUBLE) 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() def vec_int_arith(test_func, arith_func, type): size = rffi.sizeof(type) bits = size * 8 assert 0 <= bits <= 64 integers = st.integers(min_value=-2**(bits - 1), max_value=2**(bits - 1) - 1) @given(st.lists(integers, min_size=10, max_size=15)) @settings(max_examples=20) def tf(self, la): return test_func(self, arith_func, type, la) return tf vec_int_arith = functools.partial(vec_int_arith, _vector_simple_int) test_vec_simple_int_signed_add = \ vec_int_arith(lambda a,b: intmask(a+b), rffi.SIGNED) test_vec_simple_int_int_add = \ vec_int_arith(lambda a,b: intmask(r_int(a)+r_int(b)), rffi.INT) test_vec_simple_int_short_add = \ vec_int_arith(lambda a,b: intmask(r_int(a)+r_int(b)), rffi.SHORT) test_vec_simple_int_signed_sub = \ vec_int_arith(lambda a,b: intmask(a-b), rffi.SIGNED) test_vec_simple_int_sub_int = \ vec_int_arith(lambda a,b: intmask(r_int(a)-r_int(b)), rffi.INT) test_vec_simple_int_sub_short = \ vec_int_arith(lambda a,b: intmask(r_int(a)-r_int(b)), rffi.SHORT) test_vec_simple_int_signed_and = \ vec_int_arith(lambda a,b: intmask(a)&intmask(b), rffi.SIGNED) test_vec_simple_int_int_and = \ vec_int_arith(lambda a,b: intmask(a)&intmask(b), rffi.INT) test_vec_simple_int_short_and = \ vec_int_arith(lambda a,b: intmask(a)&intmask(b), rffi.SHORT) test_vec_simple_int_or_signed = \ vec_int_arith(lambda a,b: intmask(a)|intmask(b), rffi.SIGNED) test_vec_simple_int_or_int = \ vec_int_arith(lambda a,b: intmask(a)|intmask(b), rffi.INT) test_vec_simple_int_or_short = \ vec_int_arith(lambda a,b: intmask(a)|intmask(b), rffi.SHORT) test_vec_simple_int_xor_signed = \ vec_int_arith(lambda a,b: intmask(a)^intmask(b), rffi.SIGNED) test_vec_simple_int_xor_int = \ vec_int_arith(lambda a,b: intmask(a)^intmask(b), rffi.INT) test_vec_simple_int_xor_short = \ vec_int_arith(lambda a,b: intmask(a)^intmask(b), rffi.SHORT) test_vec_simple_int_int_cmp_eq = \ vec_int_arith(lambda a,b: a == b, rffi.SIGNED) test_vec_simple_int_int_cmp_ne = \ vec_int_arith(lambda a,b: a == b, rffi.SIGNED) @py.test.mark.parametrize('i', [1, 2, 3, 4, 9]) def test_vec_register_too_small_vector(self, i): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) T = lltype.Array(rffi.SHORT, hints={'nolength': True}) def g(d, va, vb): i = 0 while i < d: myjitdriver.jit_merge_point() a = va[i] b = vb[i] ec = intmask(intmask(a) + intmask(b)) va[i] = rffi.r_short(ec) i += 1 def f(d): i = 0 va = lltype.malloc(T, d + 100, flavor='raw', zero=True) vb = lltype.malloc(T, d + 100, flavor='raw', zero=True) for j in range(d + 100): va[j] = rffi.r_short(1) vb[j] = rffi.r_short(2) g(d + 100, va, vb) g(d, va, vb) # this iteration might not fit into the vector register res = intmask(va[d]) lltype.free(va, flavor='raw') lltype.free(vb, flavor='raw') return res res = self.meta_interp(f, [i], vec=True) assert res == f(i) == 3 def test_vec_max(self): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) def fmax(v1, v2): return v1 if v1 >= v2 or math.isnan(v2) else v2 T = lltype.Array(rffi.DOUBLE, hints={'nolength': True}) def f(d): i = 0 va = lltype.malloc(T, d, flavor='raw', zero=True) for j in range(d): va[j] = float(j) va[13] = 128.0 m = -128.0 while i < d: myjitdriver.jit_merge_point() a = va[i] m = fmax(a, m) i += 1 lltype.free(va, flavor='raw') return m res = self.meta_interp(f, [30], vec=True) assert res == f(30) == 128 @py.test.mark.parametrize( 'type,func,init,insert,at,count,breaks', # all [ (rffi.DOUBLE, lambda x: not bool(x), 1.0, None, -1, 32, False), (rffi.DOUBLE, lambda x: x == 0.0, 1.0, None, -1, 33, False), (rffi.DOUBLE, lambda x: x == 0.0, 1.0, 0.0, 33, 34, True), (rffi.DOUBLE, lambda x: x == 0.0, 1.0, 0.1, 4, 34, False), (lltype.Signed, lambda x: not bool(x), 1, None, -1, 32, False), (lltype.Signed, lambda x: not bool(x), 1, 0, 14, 32, True), (lltype.Signed, lambda x: not bool(x), 1, 0, 15, 31, True), (lltype.Signed, lambda x: not bool(x), 1, 0, 4, 30, True), (lltype.Signed, lambda x: x == 0, 1, None, -1, 33, False), (lltype.Signed, lambda x: x == 0, 1, 0, 33, 34, True), # any (rffi.DOUBLE, lambda x: x != 0.0, 0.0, 1.0, 33, 35, True), (rffi.DOUBLE, lambda x: x != 0.0, 0.0, 1.0, -1, 36, False), (rffi.DOUBLE, lambda x: bool(x), 0.0, 1.0, 33, 37, True), (rffi.DOUBLE, lambda x: bool(x), 0.0, 1.0, -1, 38, False), (lltype.Signed, lambda x: x != 0, 0, 1, 33, 35, True), (lltype.Signed, lambda x: x != 0, 0, 1, -1, 36, False), (lltype.Signed, lambda x: bool(x), 0, 1, 33, 37, True), (lltype.Signed, lambda x: bool(x), 0, 1, -1, 38, False), (rffi.INT, lambda x: intmask(x) != 0, rffi.r_int(0), rffi.r_int(1), 33, 35, True), (rffi.INT, lambda x: intmask(x) != 0, rffi.r_int(0), rffi.r_int(1), -1, 36, False), (rffi.INT, lambda x: bool(intmask(x)), rffi.r_int(0), rffi.r_int(1), 33, 37, True), (rffi.INT, lambda x: bool(intmask(x)), rffi.r_int(0), rffi.r_int(1), -1, 38, False), ]) def test_bool_reduction(self, type, func, init, insert, at, count, breaks): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) T = lltype.Array(type, hints={'nolength': True}) def f(d): va = lltype.malloc(T, d, flavor='raw', zero=True) for i in range(d): va[i] = init if at != -1: va[at] = insert i = 0 nobreak = False while i < d: myjitdriver.jit_merge_point() b = func(va[i]) if b: assert b break i += 1 else: nobreak = True lltype.free(va, flavor='raw') return not nobreak res = self.meta_interp(f, [count], vec=True) assert res == f(count) == breaks def vec_reduce(strat, arith_func, tp): @pytest.mark.parametrize('func, tp', [(arith_func, tp)]) @given(la=st.lists(strat, min_size=11, max_size=150)) 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() return _vec_reduce test_vec_int_sum = vec_reduce( st.integers(min_value=-2**(64 - 1), max_value=2**(64 - 1) - 1), lambda a, b: lltype.intmask(lltype.intmask(a) + lltype.intmask(b)), lltype.Signed) small_floats = st.floats(min_value=-100, max_value=100, allow_nan=False, allow_infinity=False) test_vec_float_sum = vec_reduce(small_floats, lambda a, b: a + b, rffi.DOUBLE) # PRECISION loss, because the numbers are accumulated (associative, commutative properties must hold) # you can end up a small number and a huge number that is finally multiplied losing precision # test_vec_float_prod = vec_reduce(small_floats, lambda a,b: a*b, rffi.DOUBLE) def test_constant_expand(self): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) T = lltype.Array(rffi.DOUBLE, hints={'nolength': True}) def f(d): va = lltype.malloc(T, d, flavor='raw', zero=True) i = 0 while i < d: myjitdriver.jit_merge_point() va[i] = va[i] + 34.5 i += 1 val = va[0] lltype.free(va, flavor='raw') return val res = self.meta_interp(f, [60], vec=True) assert res == f(60) == 34.5 def test_constant_expand_vec_all(self): myjitdriver = JitDriver(greens=[], reds='auto') T = lltype.Array(rffi.DOUBLE, hints={'nolength': True}) def f(d): va = lltype.malloc(T, d, flavor='raw', zero=True) i = 0 while i < d: myjitdriver.jit_merge_point() if not (i < d): raise IndexError va[i] = va[i] + 34.5 i += 1 val = va[0] lltype.free(va, flavor='raw') return val res = self.meta_interp(f, [60], vec=True, vec_all=True) assert res == f(60) == 34.5 @py.test.mark.parametrize('type,value', [(rffi.DOUBLE, 58.4547), (lltype.Signed, 2300000), (rffi.INT, 4321), (rffi.SHORT, 9922), (rffi.SIGNEDCHAR, -127)]) def test_variable_expand(self, type, value): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) T = lltype.Array(type, hints={'nolength': True}) def f(d, variable): va = lltype.malloc(T, d, flavor='raw', zero=True) i = 0 while i < d: myjitdriver.jit_merge_point() va[i] = rffi.cast(type, variable) i += 1 val = va[d // 2] lltype.free(va, flavor='raw') return val res = self.meta_interp(f, [60, value], vec=True) assert res == f(60, value) == value @py.test.mark.parametrize('vec,vec_all', [(False, True), (True, False), (True, True), (False, False)]) def test_accum(self, vec, vec_all): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=vec) T = lltype.Array(rffi.DOUBLE) def f(d, value): va = lltype.malloc(T, d, flavor='raw', zero=True) for i in range(d): va[i] = value r = 0 i = 0 k = d + 2 # in this case a guard k <= d is inserted which fails right away! while i < d: myjitdriver.jit_merge_point() if not (i < k): k -= 1 r += va[i] i += 1 lltype.free(va, flavor='raw') return r res = self.meta_interp(f, [60, 0.5], vec=vec, vec_all=vec_all) assert res == f(60, 0.5) == 60 * 0.5 @py.test.mark.parametrize('i', [15]) def test_array_bounds_check_elimination(self, i): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) T = lltype.Array(rffi.INT, hints={'nolength': True}) def f(d): va = lltype.malloc(T, d, flavor='raw', zero=True) vb = lltype.malloc(T, d, flavor='raw', zero=True) for j in range(d): va[j] = rffi.r_int(j) vb[j] = rffi.r_int(j) i = 0 while i < d: myjitdriver.jit_merge_point() if i < 0: raise IndexError if i >= d: raise IndexError a = va[i] if i < 0: raise IndexError if i >= d: raise IndexError b = vb[i] ec = intmask(a) + intmask(b) if i < 0: raise IndexError if i >= d: raise IndexError va[i] = rffi.r_int(ec) i += 1 lltype.free(va, flavor='raw') lltype.free(vb, flavor='raw') return 0 res = self.meta_interp(f, [i], vec=True) assert res == f(i) @py.test.mark.parametrize('size', [12]) def test_body_multiple_accesses(self, size): myjitdriver = JitDriver(greens=[], reds='auto') T = lltype.Array(rffi.CHAR, hints={'nolength': True}) def f(size): vector_a = malloc(T, size) vector_b = malloc(T, size) i = 0 while i < size: myjitdriver.jit_merge_point() # should unroll and group them correctly c1 = vector_a[i] c2 = vector_a[i + 1] c3 = vector_a[i + 2] # vector_b[i] = c1 vector_b[i + 1] = c2 vector_b[i + 2] = c3 i += 3 free(vector_a) free(vector_b) return 0 res = self.meta_interp(f, [size], vec=True, vec_all=True) assert res == f(size) def test_max_byte(self): myjitdriver = JitDriver(greens=[], reds='auto') T = lltype.Array(rffi.SIGNEDCHAR, hints={'nolength': True}) def f(size): vector_a = malloc(T, size) for i in range(size): vector_a[i] = rffi.r_signedchar(1) for i in range(size / 2, size): vector_a[i] = rffi.r_signedchar(i) i = 0 max = -127 while i < size: myjitdriver.jit_merge_point() a = intmask(vector_a[i]) a = a & 255 if a > max: max = a i += 1 free(vector_a) return max res = self.meta_interp(f, [128], vec=True, vec_all=True) assert res == f(128) def combinations(types, operators): import itertools size = 22 class Typ(object): def __init__(self, type, storecast, loadcast): self.type = type self.storecast = storecast self.loadcast = loadcast def __repr__(self): return self.type.replace(".", "_") sizes = [22] for t1, t2, t3, op, size in itertools.product(types, types, types, operators, sizes): yield (size, Typ(*t1), Typ(*t2), Typ(*t3), op[0], op[1]) types = [ ('rffi.DOUBLE', 'float', 'float'), ('rffi.SIGNED', 'int', 'int'), #('rffi.FLOAT', 'rffi.r_singlefloat', 'float'), ] operators = [ ('add', '+'), ] for size, typ1, typ2, typ3, opname, op in combinations(types, operators): _source = """ def test_binary_operations_{name}(self): myjitdriver = JitDriver(greens = [], reds = 'auto') T1 = lltype.Array({type_a}, hints={{'nolength': True}}) T2 = lltype.Array({type_b}, hints={{'nolength': True}}) T3 = lltype.Array({type_c}, hints={{'nolength': True}}) def f(size): vector_a = lltype.malloc(T1, size, flavor='raw') vector_b = lltype.malloc(T2, size, flavor='raw') vector_c = lltype.malloc(T3, size, flavor='raw') for i in range(size): vector_a[i] = {type_a_storecast}(1) for i in range(size): vector_b[i] = {type_b_storecast}(1) for i in range(size): vector_c[i] = {type_c_storecast}(1) i = 0 while i < size: myjitdriver.jit_merge_point() a = {type_a_loadcast}(vector_a[i]) b = {type_b_loadcast}(vector_b[i]) c = (a {op} b) vector_c[i] = {type_c_storecast}(c) i += 1 lltype.free(vector_a, flavor='raw') lltype.free(vector_b, flavor='raw') c = {type_c_loadcast}(0.0) for i in range(size): c += {type_c_loadcast}(vector_c[i]) lltype.free(vector_c, flavor='raw') return c res = self.meta_interp(f, [{size}], vec=True, vec_all=True) assert res == f({size}) """ env = { 'type_a': typ1.type, 'type_b': typ2.type, 'type_c': typ3.type, 'type_a_loadcast': typ1.loadcast, 'type_b_loadcast': typ2.loadcast, 'type_c_loadcast': typ3.loadcast, 'type_a_storecast': typ1.storecast, 'type_b_storecast': typ2.storecast, 'type_c_storecast': typ3.storecast, 'size': size, 'name': str(typ1) + '__' + str(typ2) + '__' + str(typ3) + \ '__' + str(size) + '__' + opname, 'op': op, } formatted = _source.format(**env) exec(py.code.Source(formatted).compile()) def test_binary_operations_aa(self): myjitdriver = JitDriver(greens=[], reds='auto') T1 = lltype.Array(rffi.DOUBLE, hints={'nolength': True}) T3 = lltype.Array(rffi.SIGNED, hints={'nolength': True}) def f(size): vector_a = lltype.malloc(T1, size, flavor='raw', zero=True) vector_b = lltype.malloc(T1, size, flavor='raw', zero=True) vector_c = lltype.malloc(T3, size, flavor='raw', zero=True) i = 0 while i < size: myjitdriver.jit_merge_point() a = (vector_a[i]) b = (vector_b[i]) c = (a + b) vector_c[i] = int(c) i += 1 free(vector_a) free(vector_b) #c = 0.0 #for i in range(size): # c += vector_c[i] lltype.free(vector_c, flavor='raw') return 0 res = self.meta_interp(f, [22], vec=True, vec_all=True) assert res == f(22) def test_guard_test_location_assert(self): myjitdriver = JitDriver(greens=[], reds='auto') T1 = lltype.Array(rffi.SIGNED, hints={'nolength': True}) def f(size): vector_a = lltype.malloc(T1, size, flavor='raw', zero=True) for i in range(size): vector_a[i] = 0 i = 0 breaks = 0 while i < size: myjitdriver.jit_merge_point() a = vector_a[i] if a: breaks = 1 break del a i += 1 lltype.free(vector_a, flavor='raw') return breaks res = self.meta_interp(f, [22], vec=True, vec_all=True) assert res == f(22) def run_unpack(self, unpack, vector_type, assignments, float=True): vars = {'v': 0, 'f': 0, 'i': 0} def newvar(type): c = vars[type] vars[type] = c + 1 if type == 'v': return type + str(c) + vector_type return type + str(c) targettoken = TargetToken() finaldescr = BasicFinalDescr(1) args = [] args_values = [] pack = [] suffix = 'f' if float else 'i' for var, vals in assignments.items(): v = newvar('v') pack.append('%s = vec_%s()' % (v, suffix)) for i, val in enumerate(vals): args_values.append(val) f = newvar(suffix) args.append(f) count = 1 # create a new variable vo = v v = newvar('v') pack.append('%s = vec_pack_%s(%s, %s, %d, %d)' % \ (v, suffix, vo, f, i, count)) vars['x'] = v packs = '\n '.join(pack) resvar = suffix + '{' + suffix + '}' # format the resoperations, take care that the lhs of = # is formated later with a new variable name unpackops = unpack if isinstance(unpack, str): unpackops = [unpack] unpacksf = [] for up in unpackops: lhs, rhs = up.split("=") rhsf = rhs.format(**vars) newvar('i') newvar('f') newvar('v') lhsf = lhs.format(**vars) unpacksf.append(lhsf + '=' + rhsf) unpacks = '\n '.join(unpacksf) source = ''' [{args}] label({args}, descr=targettoken) {packs} {unpacks} finish({resvar}, descr=finaldescr) '''.format(args=','.join(args), packs=packs, unpacks=unpacks, resvar=resvar.format(**vars)) print(source) return self._compile_and_run(source, args_values, float, ns={ 'targettoken': targettoken, 'finaldescr': finaldescr }) def _compile_and_run(self, source, args_values, float=True, ns={}): loop = parse(source, namespace=ns) cpu = self.CPUClass(rtyper=None, stats=None) cpu.setup_once() # looptoken = JitCellToken() cpu.compile_loop(loop.inputargs, loop.operations, looptoken) #import pdb; pdb.set_trace() deadframe = cpu.execute_token(looptoken, *args_values) print(source) if float: return cpu.get_float_value(deadframe, 0) else: return cpu.get_int_value(deadframe, 0) def test_unpack_f(self): # double unpack assert self.run_unpack("f{f} = vec_unpack_f({x}, 0, 1)", "[2xf64]", {'x': (1.2, -1.0)}) == 1.2 assert self.run_unpack("f{f} = vec_unpack_f({x}, 1, 1)", "[2xf64]", {'x': (50.33, 4321.0)}) == 4321.0 def test_unpack_i64(self): # int64 assert self.run_unpack("i{i} = vec_unpack_i({x}, 1, 1)", "[2xi64]", {'x': (14, 15)}, float=False) == 15 assert self.run_unpack("i{i} = vec_unpack_i({x}, 0, 1)", "[2xi64]", {'x': (11, 12)}, float=False) == 11 def test_unpack_i(self): for i in range(16): # i8 op = "i{i} = vec_unpack_i({x}, %d, 1)" % i assert self.run_unpack(op, "[16xi8]", {'x': [127,1]*8}, float=False) == \ (127 if i%2==0 else 1) # i16 if i < 8: assert self.run_unpack(op, "[8xi16]", {'x': [2**15-1,0]*4}, float=False) == \ (2**15-1 if i%2==0 else 0) # i32 if i < 4: assert self.run_unpack(op, "[4xi32]", {'x': [2**31-1,0]*4}, float=False) == \ (2**31-1 if i%2==0 else 0) def test_unpack_several(self): values = [1, 2, 3, 4] for i, v in enumerate(values): j = (i // 2) * 2 op = [ "v{v}[2xi32] = vec_unpack_i({x}, %d, 2)" % j, "i{i} = vec_unpack_i(v{v}[2xi32], %d, 1)" % (i % 2) ] assert self.run_unpack(op, "[4xi32]", {'x': values}, float=False) == v values = [1, 2, 3, 4, 5, 6, 7, 8] for i, v in enumerate(values): j = (i // 4) * 4 op = [ "v{v}[4xi16] = vec_unpack_i({x}, %d, 4)" % j, "i{i} = vec_unpack_i(v{v}[4xi16], %d, 1)" % (i % 4) ] assert self.run_unpack(op, "[8xi16]", {'x': values}, float=False) == v values = [1, 2, 3, 4, 5, 6, 7, 8] * 2 for i, v in enumerate(values): j = (i // 8) * 8 op = [ "v{v}[8xi8] = vec_unpack_i({x}, %d, 8)" % j, "i{i} = vec_unpack_i(v{v}[8xi8], %d, 1)" % (i % 8) ] assert self.run_unpack(op, "[16xi8]", {'x': values}, float=False) == v def test_int32_float_casts(self): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) def f(bytecount, va, vb, vc): i = 0 j = 0 while i < bytecount: myjitdriver.jit_merge_point() a = raw_storage_getitem(rffi.INT, va, j) b = raw_storage_getitem(rffi.DOUBLE, vb, i) c = rffi.cast(rffi.DOUBLE, a) + b raw_storage_setitem(vc, i, c) j += 4 i += 8 count = 32 va = alloc_raw_storage(4 * count, zero=True) vb = alloc_raw_storage(8 * count, zero=True) for i, v in enumerate([1, 2, 3, 4] * (count / 4)): raw_storage_setitem(va, i * 4, rffi.cast(rffi.INT, v)) for i, v in enumerate([-1.0, -2.0, -3.0, -4.0] * (count / 4)): raw_storage_setitem(vb, i * 8, rffi.cast(rffi.DOUBLE, v)) vc = alloc_raw_storage(8 * count, zero=True) self.meta_interp(f, [8 * count, va, vb, vc], vec=True) for i in range(count): assert raw_storage_getitem(rffi.DOUBLE, vc, i * 8) == 0.0 free_raw_storage(va) free_raw_storage(vb) free_raw_storage(vc) def test_float_int32_casts(self): myjitdriver = JitDriver(greens=[], reds='auto', vectorize=True) def f(bytecount, va, vb, vc): i = 0 j = 0 while j < bytecount: myjitdriver.jit_merge_point() a = raw_storage_getitem(rffi.DOUBLE, va, j) b = raw_storage_getitem(rffi.INT, vb, i) c = a + rffi.cast(rffi.DOUBLE, b) raw_storage_setitem(vc, j, c) i += 4 j += 8 count = 32 va = alloc_raw_storage(8 * count, zero=True) vb = alloc_raw_storage(4 * count, zero=True) for i, v in enumerate([1.0, 2.0, 3.0, 4.0] * (count / 4)): raw_storage_setitem(va, i * 8, rffi.cast(rffi.DOUBLE, v)) for i, v in enumerate([-1, -2, -3, -4] * (count / 4)): raw_storage_setitem(vb, i * 4, rffi.cast(rffi.INT, v)) vc = alloc_raw_storage(8 * count, zero=True) self.meta_interp(f, [8 * count, va, vb, vc], vec=True) for i in range(count): assert raw_storage_getitem(rffi.DOUBLE, vc, i * 8) == 0.0 free_raw_storage(va) free_raw_storage(vb) free_raw_storage(vc)