Author: Tim Felgentreff <[email protected]>
Branch: 64bit
Changeset: r578:1246e0869fc3
Date: 2014-01-13 17:12 +0100
http://bitbucket.org/pypy/lang-smalltalk/changeset/1246e0869fc3/
Log: use untagged integers wherever possible, fix most tests
diff --git a/spyvm/constants.py b/spyvm/constants.py
--- a/spyvm/constants.py
+++ b/spyvm/constants.py
@@ -1,3 +1,4 @@
+import sys
from rpython.rlib.jit import elidable
from spyvm.tool.bitmanipulation import splitter
@@ -145,9 +146,9 @@
from rpython.rlib.rarithmetic import LONG_BIT
TAGGED_MAXINT = 2 ** (LONG_BIT - 2) - 1
TAGGED_MININT = -2 ** (LONG_BIT - 2)
-
TAGGED_MASK = int(2 ** (LONG_BIT - 1) - 1)
-
+MAXINT = sys.maxint
+MININT = -sys.maxint-1
# Entries into SO_SPECIAL_SELECTORS_ARRAY:
#(#+ 1 #- 1 #< 1 #> 1 #<= 1 #>= 1 #= 1 #~= 1 #* 1 #/ 1 #\\ 1 #@ 1 #bitShift: 1
#// 1 #bitAnd: 1 #bitOr: 1 #at: 1 #at:put: 2 #size 0 #next 0 #nextPut: 1 #atEnd
0 #== 1 #class 0 #blockCopy: 1 #value 0 #value: 1 #do: 1 #new 0 #new: 1 #x 0 #y
0)
diff --git a/spyvm/interpreter.py b/spyvm/interpreter.py
--- a/spyvm/interpreter.py
+++ b/spyvm/interpreter.py
@@ -43,7 +43,6 @@
self.space = space
self.image = image
self.image_name = image_name
- self.startup_time = time.time()
self.max_stack_depth = max_stack_depth
self.remaining_stack_depth = max_stack_depth
self._loop = False
@@ -204,7 +203,7 @@
def time_now(self):
import time
from rpython.rlib.rarithmetic import intmask
- return intmask(int((time.time() - self.startup_time) * 1000) &
constants.TAGGED_MASK)
+ return intmask(int(time.time() * 1000) - self.image.startup_time)
def padding(self, symbol=' '):
return symbol * (self.max_stack_depth - self.remaining_stack_depth)
diff --git a/spyvm/iproxy.py b/spyvm/iproxy.py
new file mode 100644
--- /dev/null
+++ b/spyvm/iproxy.py
@@ -0,0 +1,11 @@
+from spyvm.system import IS_64BIT
+
+if not IS_64BIT:
+ from spyvm import interpreter_proxy
+ IProxy = interpreter_proxy._InterpreterProxy()
+else:
+ from spyvm.error import PrimitiveFailedError
+ class _InterpreterProxy():
+ def call(self, signature, interp, s_frame, argcount, s_method):
+ raise PrimitiveFailedError
+ IProxy = _InterpreterProxy()
diff --git a/spyvm/model.py b/spyvm/model.py
--- a/spyvm/model.py
+++ b/spyvm/model.py
@@ -188,8 +188,9 @@
def unwrap_uint(self, space):
val = self.value
- if val < 0:
- raise error.UnwrappingError("got negative integer")
+ # if val < 0:
+ # raise error.UnwrappingError("got negative integer")
+ # XXX: Assume that caller knows what he does
return r_uint(val)
@@ -399,7 +400,7 @@
else:
# bounds-check for primitive access is done in the primitive
assert n0 == 1
- return space.wrap_positive_1word_int(intmask(r))
+ return space.wrap_positive_1word_int(intmask(r_uint32(r)))
def store(self, space, n0, w_obj):
from rpython.rlib.rstruct.ieee import float_unpack, float_pack
@@ -756,14 +757,21 @@
byte0 = ord(self.getchar(byte_index0))
byte1 = ord(self.getchar(byte_index0 + 1)) << 8
if byte1 & 0x8000 != 0:
- byte1 = intmask(-65536 | byte1) # -65536 = 0xffff0000
+ byte1 = intmask(intmask(r_uint32(0xffff0000)) |
intmask(r_uint32(byte1)))
return space.wrap_int(byte1 | byte0)
def short_atput0(self, space, index0, w_value):
from rpython.rlib.rarithmetic import int_between
i_value = space.unwrap_int(w_value)
- if not int_between(-32768, i_value, 0x8000):
- raise error.PrimitiveFailedError
+ if constants.LONG_BIT == 64:
+ if (not int_between(0, i_value, 0x8000) and
+ not int_between(0, i_value ^ (0xffffffff), 0x8000)):
+ raise error.PrimitiveFailedError
+ elif constants.LONG_BIT == 32:
+ if not int_between(-0x8000, i_value, 0x8000):
+ raise error.PrimitiveFailedError
+ else:
+ raise NotImplementedError
byte_index0 = index0 * 2
byte0 = i_value & 0xff
byte1 = (i_value & 0xff00) >> 8
@@ -894,20 +902,27 @@
else:
short = (word >> 16) & 0xffff
if short & 0x8000 != 0:
- short = -65536 | short # -65536 = 0xffff0000
- return space.wrap_int(intmask(short))
+ short = intmask(r_uint32(0xffff0000)) | short
+ return space.wrap_int(intmask(r_uint32(short)))
def short_atput0(self, space, index0, w_value):
- from rpython.rlib.rarithmetic import int_between
+ from rpython.rlib.rarithmetic import int_between, widen
i_value = space.unwrap_int(w_value)
- if not int_between(-32768, i_value, 0x8000):
- raise error.PrimitiveFailedError
+ if constants.LONG_BIT == 64:
+ if (not int_between(0, i_value, 0x8000) and
+ not int_between(0, i_value ^ (0xffffffff), 0x8000)):
+ raise error.PrimitiveFailedError
+ elif constants.LONG_BIT == 32:
+ if not int_between(-0x8000, i_value, 0x8000):
+ raise error.PrimitiveFailedError
+ else:
+ raise NotImplementedError
word_index0 = index0 / 2
- word = intmask(self.getword(word_index0))
+ word = intmask(r_uint32(self.getword(word_index0)))
if index0 % 2 == 0:
- word = (word & -65536) | (i_value & 0xffff) # -65536 = 0xffff0000
+ word = intmask(r_uint32((word & widen(r_uint32(0xffff0000))) |
(i_value & 0xffff)))
else:
- word = (i_value << 16) | (word & 0xffff)
+ word = intmask(r_uint32((i_value << 16) | (word & 0xffff)))
value = r_uint(word)
self.setword(word_index0, value)
@@ -938,10 +953,10 @@
if self.words is None:
return self.c_words
else:
- from spyvm.iproxy import sqIntArrayPtr
+ from spyvm.iproxy import IProxy
size = self.size()
old_words = self.words
- c_words = self.c_words = lltype.malloc(sqIntArrayPtr.TO, size,
flavor='raw')
+ c_words = self.c_words = lltype.malloc(IProxy.sqIntArrayPtr.TO,
size, flavor='raw')
for i in range(size):
c_words[i] = intmask(old_words[i])
self.words = None
diff --git a/spyvm/objspace.py b/spyvm/objspace.py
--- a/spyvm/objspace.py
+++ b/spyvm/objspace.py
@@ -201,45 +201,23 @@
def wrap_int(self, val):
from spyvm import constants
assert isinstance(val, int)
- if int_between(constants.TAGGED_MININT, val,
- constants.TAGGED_MAXINT + 1):
- return model.W_SmallInteger(val)
- # We can't build large integers here, because we don't know what to do
- # with negativ vals: raise an error or interpret them as 4-byte
positive?
- raise WrappingError("integer too large to fit into a tagged pointer")
+ # We don't use tagging
+ return model.W_SmallInteger(val)
def wrap_uint(self, val):
from rpython.rlib.objectmodel import we_are_translated
if not we_are_translated():
- assert val <= 0xFFFFFFFF
+ assert val <= (2**constants.LONG_BIT) - 1
if val < 0:
raise WrappingError("negative integer")
- if val >= 0:
- try:
- return self.wrap_positive_1word_int(intmask(val))
- except WrappingError:
- pass
- # XXX this code sucks
- import math
- bytes_len = int(math.log(val) / math.log(0xff)) + 1
- if bytes_len <= 4:
+ else:
return self.wrap_positive_1word_int(intmask(val))
- else:
- return self._wrap_uint_loop(val, bytes_len)
-
- @jit.unroll_safe
- def _wrap_uint_loop(self, val, bytes_len):
- w_result = model.W_BytesObject(self,
- self.classtable['w_LargePositiveInteger'], bytes_len)
- for i in range(bytes_len):
- w_result.setchar(i, chr(intmask((val >> i*8) & 255)))
- return w_result
def wrap_positive_1word_int(self, val):
# This will always return a positive value.
# XXX: For now, we assume that val is at most 1word, i.e. overflows are
- # checked for before wrapping.
- if int_between(0, val, constants.TAGGED_MAXINT + 1):
+ # checked for before wrapping. Also, we ignore tagging.
+ if int_between(0, val, constants.MAXINT):
return model.W_SmallInteger(val)
else:
return model.W_LargePositiveInteger1Word(val)
diff --git a/spyvm/primitives.py b/spyvm/primitives.py
--- a/spyvm/primitives.py
+++ b/spyvm/primitives.py
@@ -471,7 +471,9 @@
s_class = w_cls.as_class_get_shadow(interp.space)
if s_class.isvariable():
raise PrimitiveFailedError()
- return s_class.new()
+ w_inst = s_class.new()
+ s_frame.store_instance(w_cls, w_inst)
+ return w_inst
@expose_primitive(NEW_WITH_ARG, unwrap_spec=[object, int])
def func(interp, s_frame, w_cls, size):
@@ -480,9 +482,11 @@
if not s_class.isvariable() and size != 0:
raise PrimitiveFailedError()
try:
- return s_class.new(size)
+ w_inst = s_class.new(size)
except MemoryError:
raise PrimitiveFailedError
+ s_frame.store_instance(w_cls, w_inst)
+ return w_inst
@expose_primitive(ARRAY_BECOME_ONE_WAY, unwrap_spec=[object, object])
def func(interp, s_frame, w_obj1, w_obj2):
@@ -538,7 +542,7 @@
match_w = []
from rpython.rlib import rgc
- if USES_STM:
+ if not USES_STM:
roots = [gcref for gcref in rgc.get_rpy_roots() if gcref]
pending = roots[:]
while pending:
@@ -887,9 +891,9 @@
elif signature[0] == "VMDebugging":
from spyvm.plugins.vmdebugging import DebuggingPlugin
return DebuggingPlugin.call(signature[1], interp, s_frame, argcount,
s_method)
- else:
- from spyvm.iproxy import IProxy
- return IProxy.call(signature, interp, s_frame, argcount, s_method)
+ # else:
+ # from spyvm.iproxy import IProxy
+ # return IProxy.call(signature, interp, s_frame, argcount, s_method)
raise PrimitiveFailedError
@expose_primitive(COMPILED_METHOD_FLUSH_CACHE, unwrap_spec=[object])
diff --git a/spyvm/shadow.py b/spyvm/shadow.py
--- a/spyvm/shadow.py
+++ b/spyvm/shadow.py
@@ -346,7 +346,7 @@
assert not isinstance(w_selector, str)
self.initialize_methoddict()
s_method = w_method.as_compiledmethod_get_shadow(self.space)
- self.s_methoddict().methoddict[w_selector] = s_method
+ self.s_methoddict().methoddict[w_selector.as_string()] = s_method
if isinstance(w_method, model.W_CompiledMethod):
s_method.w_compiledin = self.w_self()
@@ -460,18 +460,19 @@
__metaclass__ = extendabletype
_attrs_ = ['_s_sender', '_pc', '_temps_and_stack',
- '_stack_ptr', 'instances_w']
-
+ '_stack_ptr', 'instances_w', '_stores_instances']
_virtualizable_ = [
"_s_sender", "_pc",
"_temps_and_stack[*]", "_stack_ptr",
- "_w_self", "_w_self_size"
+ "_w_self", "_w_self_size",
+ "_stores_instances"
]
def __init__(self, space, w_self):
self._s_sender = None
AbstractRedirectingShadow.__init__(self, space, w_self)
self.instances_w = {}
+ self._stores_instances = False
@staticmethod
def is_block_context(w_pointers, space):
@@ -728,13 +729,22 @@
self._w_self_size = w_self.size()
return w_self
+ def store_instance(self, w_class, w_obj):
+ if not jit.promote(self._stores_instances):
+ return
+ else:
+ instances_w = self.instances_w.get(w_class, None)
+ if instances_w is not None:
+ instances_w.append(w_obj)
+
def store_instances_array(self, w_class, match_w):
# used for primitives 77 & 78
+ self._stores_instances = True
self.instances_w[w_class] = match_w
- @jit.elidable
def instances_array(self, w_class):
- return self.instances_w.get(w_class, None)
+ if jit.promote(self._stores_instances):
+ return self.instances_w.get(w_class, None)
# ______________________________________________________________________
# Debugging printout
diff --git a/spyvm/squeakimage.py b/spyvm/squeakimage.py
--- a/spyvm/squeakimage.py
+++ b/spyvm/squeakimage.py
@@ -361,8 +361,12 @@
# ____________________________________________________________
class SqueakImage(object):
+ _immutable_fields_ = ["special_objects", "w_asSymbol",
+ "w_simulateCopyBits", "version", "is_modern",
+ "startup_time"]
def from_reader(self, space, reader):
+ import time
from spyvm import constants
self.special_objects = [g_object.w_object for g_object in
reader.chunks[reader.specialobjectspointer]
@@ -376,6 +380,7 @@
self.lastWindowSize = reader.lastWindowSize
self.version = reader.version
self.is_modern = reader.version.magic > 6502
+ self.startup_time = int(time.time() * 1000)
self.run_spy_hacks(space)
def run_spy_hacks(self, space):
diff --git a/spyvm/test/jittest/base.py b/spyvm/test/jittest/base.py
--- a/spyvm/test/jittest/base.py
+++ b/spyvm/test/jittest/base.py
@@ -55,10 +55,12 @@
return self.run_simulated(tmpdir, code)
def run_binary(self, spy, tmpdir, code):
+ print code
proc = subprocess.Popen(
[str(spy), "-r", code, BenchmarkImage],
cwd=str(tmpdir),
- env={"PYPYLOG": "jit-log-opt:%s" % tmpdir.join("x.pypylog")}
+ env={"PYPYLOG": "jit-log-opt:%s" % tmpdir.join("x.pypylog"),
+ "SDL_VIDEODRIVER": "dummy"}
)
proc.wait()
data = logparser.parse_log_file(str(tmpdir.join("x.pypylog")),
verbose=False)
diff --git a/spyvm/test/jittest/test_basic.py b/spyvm/test/jittest/test_basic.py
--- a/spyvm/test/jittest/test_basic.py
+++ b/spyvm/test/jittest/test_basic.py
@@ -9,43 +9,36 @@
0 to: 10000000 do: [:t|nil].
""")
self.assert_matches(traces[0].loop, """
- guard_not_invalidated(descr=<Guard0xa15ec7c>)
- i60 = int_le(i49, 10000)
- guard_true(i60, descr=<Guard0xa15ec40>)
- i61 = int_add(i49, 1)
- i62 = int_sub(i61, -1073741824)
- i63 = uint_lt(i62, -2147483648)
- guard_true(i63, descr=<Guard0xa15ec04>)
- i64 = int_sub(i57, 1)
- setfield_gc(ConstPtr(ptr54), i64, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 16>)
- i65 = int_le(i64, 0)
- guard_false(i65, descr=<Guard0xa15ebc8>)
- jump(p0, p3, i61, p12, p14, p16, p18, p20, p22, p24, p26, p28, p30,
p32, p34, p36, p38, i64, descr=TargetToken(169145008))
+ guard_not_invalidated(descr=<Guard0x1ba06b0>),
+ i57 = int_le(i50, 10000000),
+ guard_true(i57, descr=<Guard0x1ba0640>),
+ i58 = int_add(i50, 1),
+ i59 = int_sub(i54, 1),
+ setfield_gc(ConstPtr(ptr51), i59, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ i60 = int_le(i59, 0),
+ guard_false(i60, descr=<Guard0x1ba05d0>),
+ jump(p0, i3, p4, i58, p13, p15, p17, p19, p21, p23, p25, p27, p29,
p31, p33, p35, p37, p39, i59, descr=TargetToken(27868504))
""")
self.assert_matches(traces[0].bridges[0], """
- f18 = call(ConstClass(ll_time.ll_time_time), descr=<Callf 8 EF=4>)
- setfield_gc(ConstPtr(ptr19), 10000, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>)
- guard_no_exception(descr=<Guard0x9732d30>)
- f22 = float_sub(f18, 1387380038.806162)
- f24 = float_mul(f22, 1000.000000)
- i25 = cast_float_to_int(f24)
- i27 = int_and(i25, 2147483647)
- i28 = getfield_gc(ConstPtr(ptr19), descr=<FieldS
spyvm.interpreter.Interpreter.inst_next_wakeup_tick 36>)
- i29 = int_is_zero(i28)
- guard_true(i29, descr=<Guard0x9761ad8>)
- label(p0, p1, i16, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
p14, p15, descr=TargetToken(158475216))
- guard_class(p0, ConstClass(MethodContextShadow),
descr=<Guard0x9761a9c>)
- p31 = getfield_gc(p0, descr=<FieldP
spyvm.shadow.MethodContextShadow.inst__w_method 44>)
- guard_value(p31, ConstPtr(ptr32), descr=<Guard0x9761a60>)
- guard_not_invalidated(descr=<Guard0x9761a24>)
- i34 = int_le(i16, 1000000000)
- guard_true(i34, descr=<Guard0x97619e8>)
- i36 = int_add(i16, 1)
- i38 = int_sub(i36, -1073741824)
- i40 = uint_lt(i38, -2147483648)
- guard_true(i40, descr=<Guard0x97619ac>)
- setfield_gc(ConstPtr(ptr19), 9999, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>)
- jump(p0, p1, i36, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
p14, p15, 9999, descr=TargetToken(158474976))
+ f19 = call(ConstClass(ll_time.ll_time_time), descr=<Callf 8 EF=4>),
+ setfield_gc(ConstPtr(ptr20), 10000, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ guard_no_exception(descr=<Guard0x3596800>),
+ f23 = float_mul(f19, 1000.000000),
+ i24 = cast_float_to_int(f23),
+ i26 = int_sub(i24, 1389627640615),
+ i27 = getfield_gc(ConstPtr(ptr20), descr=<FieldS
spyvm.interpreter.Interpreter.inst_next_wakeup_tick 48>),
+ i28 = int_is_zero(i27),
+ guard_true(i28, descr=<Guard0x35a8330>),
+ label(p0, i1, p2, i17, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
p14, p15, p16, descr=TargetToken(55082592)),
+ guard_class(p0, ConstClass(MethodContextShadow),
descr=<Guard0x35a82c0>),
+ p30 = getfield_gc(p0, descr=<FieldP
spyvm.shadow.MethodContextShadow.inst__w_method 88>),
+ guard_value(p30, ConstPtr(ptr31), descr=<Guard0x35a8250>),
+ guard_not_invalidated(descr=<Guard0x35a81e0>),
+ i33 = int_le(i17, 10000000),
+ guard_true(i33, descr=<Guard0x35a8170>),
+ i35 = int_add(i17, 1),
+ setfield_gc(ConstPtr(ptr20), 9999, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ jump(p0, i1, p2, i35, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
p14, p15, p16, 9999, descr=TargetToken(55082328))
""")
def test_constant_string(self, spy, tmpdir):
@@ -56,18 +49,15 @@
^ i
""")
self.assert_matches(traces[0].loop, """
- guard_not_invalidated(descr=<Guard0x92520c4>)
- i68 = int_le(i58, 10000)
- guard_true(i68, descr=<Guard0x9252088>)
- i69 = int_add(i58, 1)
- i70 = int_sub(i69, -1073741824)
- i71 = uint_lt(i70, -2147483648)
- guard_true(i71, descr=<Guard0x925204c>)
- i72 = int_sub(i65, 1)
- setfield_gc(ConstPtr(ptr55), i72, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 16>)
- i73 = int_le(i72, 0)
- guard_false(i73, descr=<Guard0x9252010>)
- jump(p0, p3, i69, p12, p14, p16, p18, p20, p22, p24, p26, p28, p30,
p32, p34, p36, p38, i72, descr=TargetToken(153187472))
+ guard_not_invalidated(descr=<Guard0x2f3b750>),
+ i65 = int_le(i59, 10000),
+ guard_true(i65, descr=<Guard0x2f3b6e0>),
+ i66 = int_add(i59, 1),
+ i67 = int_sub(i62, 1),
+ setfield_gc(ConstPtr(ptr56), i67, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ i68 = int_le(i67, 0),
+ guard_false(i68, descr=<Guard0x2f3b670>),
+ jump(p0, i3, p4, i66, p13, p15, p17, p19, p21, p23, p25, p27, p29,
p31, p33, p35, p37, p39, i67, descr=TargetToken(48782592))
""")
def test_constant_string_equal2(self, spy, tmpdir):
@@ -83,21 +73,18 @@
^ i
""")
self.assert_matches(traces[0].loop, """
- guard_not_invalidated(descr=<Guard0x9c66a60>),
- i76 = int_le(i65, 100000),
- guard_true(i76, descr=<Guard0x9c66628>),
- i77 = int_add(i65, 1),
- i78 = int_sub(i77, -1073741824),
- i79 = uint_lt(i78, -2147483648),
- guard_true(i79, descr=<Guard0x9c622a4>),
- i80 = int_sub(i73, 2),
- setfield_gc(ConstPtr(ptr70), i80, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
- i81 = int_le(i80, 0),
- guard_false(i81, descr=<Guard0x9bbbe5c>),
- i83 = arraylen_gc(p49, descr=<ArrayU 1>),
- i84 = arraylen_gc(p53, descr=<ArrayU 1>),
- i85 = arraylen_gc(p57, descr=<ArrayU 1>),
- jump(p0, p3, i77, p12, p14, p16, p18, p20, p22, p24, p26, p28, p30,
p32, p34, p36, p38, i80, p49, p53, p57, descr=TargetToken(163738864))
+ guard_not_invalidated(descr=<Guard0x27c6560>),
+ i73 = int_le(i66, 100000),
+ guard_true(i73, descr=<Guard0x27c64f0>),
+ i74 = int_add(i66, 1),
+ i75 = int_sub(i70, 2),
+ setfield_gc(ConstPtr(ptr67), i75, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ i76 = int_le(i75, 0),
+ guard_false(i76, descr=<Guard0x27c6480>),
+ i78 = arraylen_gc(p50, descr=<ArrayU 1>),
+ i79 = arraylen_gc(p54, descr=<ArrayU 1>),
+ i80 = arraylen_gc(p58, descr=<ArrayU 1>),
+ jump(p0, i3, p4, i74, p13, p15, p17, p19, p21, p23, p25, p27, p29,
p31, p33, p35, p37, p39, i75, p50, p54, p58, descr=TargetToken(40565840))
""")
def test_constant_string_var_equal(self, spy, tmpdir):
@@ -117,18 +104,15 @@
^ i
""")
self.assert_matches(traces[0].loop, """
- guard_not_invalidated(descr=<Guard0x967e7cc>),
- i73 = int_le(i62, 100000),
- guard_true(i73, descr=<Guard0x967e790>),
- i74 = int_add(i62, 1),
- i75 = int_sub(i74, -1073741824),
- i76 = uint_lt(i75, -2147483648),
- guard_true(i76, descr=<Guard0x967e754>),
- i77 = int_sub(i70, 1),
- setfield_gc(ConstPtr(ptr67), i77, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
- i78 = int_le(i77, 0),
- guard_false(i78, descr=<Guard0x967e718>),
- jump(p0, p3, i74, p8, p10, p12, p14, p20, p22, p24, p26, p28, p30,
p32, p34, p36, p38, p40, p42, p44, p46, i77, descr=TargetToken(157713840))
+ guard_not_invalidated(descr=<Guard0x33981e0>),
+ i70 = int_le(i63, 100000),
+ guard_true(i70, descr=<Guard0x3398170>),
+ i71 = int_add(i63, 1),
+ i72 = int_sub(i67, 1),
+ setfield_gc(ConstPtr(ptr64), i72, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ i73 = int_le(i72, 0),
+ guard_false(i73, descr=<Guard0x3398100>),
+ jump(p0, i3, p4, i71, p9, p11, p13, p15, p21, p23, p25, p27, p29, p31,
p33, p35, p37, p39, p41, p43, p45, p47, i72, descr=TargetToken(52952232))
""")
def test_bitInvert32(self, spy, tmpdir):
@@ -140,26 +124,20 @@
].
""")
self.assert_matches(traces[0].loop, """
- guard_not_invalidated(descr=<Guard0x2b48f70>),
- i90 = int_le(i79, 1000000),
- guard_true(i90, descr=<Guard0x2b49590>),
- setfield_gc(ConstPtr(ptr60), i67, descr=<FieldS
spyvm.interpreter.Interpreter.inst_remaining_stack_depth 56>),
- i91 = int_ge(i73, 0),
- guard_true(i91, descr=<Guard0x2b49520>),
- i92 = int_xor(i73, i72),
- i93 = int_sub(i92, -4611686018427387904),
- i94 = uint_lt(i93, -9223372036854775808),
- guard_true(i94, descr=<Guard0x2b494b0>),
- i95 = int_add(i79, 1),
- i96 = int_sub(i95, -4611686018427387904),
- setfield_gc(ConstPtr(ptr60), i63, descr=<FieldS
spyvm.interpreter.Interpreter.inst_remaining_stack_depth 56>),
- i97 = uint_lt(i96, -9223372036854775808),
- guard_true(i97, descr=<Guard0x2b49440>),
- i98 = int_sub(i87, 3),
- setfield_gc(ConstPtr(ptr60), i98, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
- i99 = int_le(i98, 0),
- guard_false(i99, descr=<Guard0x2b493d0>),
- jump(p0, p3, i92, p8, i95, p16, p18, p20, p22, p24, p26, p28, p30,
p32, p34, p36, p38, p40, p42, i67, i52, i72, i63, i98,
descr=TargetToken(44203440))
+ guard_not_invalidated(descr=<Guard0x2a59750>),
+ i83 = int_le(i76, 1000000),
+ guard_true(i83, descr=<Guard0x2a596e0>),
+ setfield_gc(ConstPtr(ptr61), i68, descr=<FieldS
spyvm.interpreter.Interpreter.inst_remaining_stack_depth 56>),
+ i84 = int_ge(i74, 0),
+ guard_true(i84, descr=<Guard0x2a59670>),
+ i85 = int_xor(i74, i73),
+ i86 = int_add(i76, 1),
+ i87 = int_sub(i79, 3),
+ setfield_gc(ConstPtr(ptr61), i64, descr=<FieldS
spyvm.interpreter.Interpreter.inst_remaining_stack_depth 56>),
+ setfield_gc(ConstPtr(ptr61), i87, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ i88 = int_le(i87, 0),
+ guard_false(i88, descr=<Guard0x2a59600>),
+ jump(p0, i3, p4, i85, p9, i86, p17, p19, p21, p23, p25, p27, p29, p31,
p33, p35, p37, p39, p41, p43, i68, i53, i73, i87, i64,
descr=TargetToken(43310512))
""")
def test_bitXor(self, spy, tmpdir):
@@ -172,20 +150,41 @@
].
""")
self.assert_matches(traces[0].loop, """
- guard_not_invalidated(descr=<Guard0x28565d0>),
- i82 = int_le(i72, 1000000),
- guard_true(i82, descr=<Guard0x2856560>),
- i83 = int_xor(i66, i63),
- i84 = int_sub(i83, -4611686018427387904),
- i85 = uint_lt(i84, -9223372036854775808),
- guard_true(i85, descr=<Guard0x28564f0>),
- i86 = int_add(i72, 1),
- i87 = int_sub(i86, -4611686018427387904),
- i88 = uint_lt(i87, -9223372036854775808),
- guard_true(i88, descr=<Guard0x2856480>),
- i90 = int_sub(i79, 1),
- setfield_gc(ConstPtr(ptr57), i90, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
- i91 = int_le(i90, 0),
- guard_false(i91, descr=<Guard0x2856410>),
- jump(p0, p3, i83, p8, i86, p16, p18, p20, p22, p24, p26, p28, p30,
p32, p34, p36, p38, p40, p42, i63, i90, descr=TargetToken(41172136))
+ guard_not_invalidated(descr=<Guard0x2dc3d70>),
+ i75 = int_le(i69, 1000000),
+ guard_true(i75, descr=<Guard0x2dc3d00>),
+ i76 = int_xor(i67, i64),
+ i77 = int_add(i69, 1),
+ i78 = int_sub(i72, 1),
+ setfield_gc(ConstPtr(ptr58), i78, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ i79 = int_le(i78, 0),
+ guard_false(i79, descr=<Guard0x2dc3c90>),
+ jump(p0, i3, p4, i76, p9, i77, p17, p19, p21, p23, p25, p27, p29, p31,
p33, p35, p37, p39, p41, p43, i64, i78, descr=TargetToken(46857208))
""")
+
+ def test_DisplayFlash(self, spy, tmpdir):
+ traces = self.run(spy, tmpdir, """
+ | path |
+ Display
+ setExtent: 200@200;
+ beDisplay;
+ fillWhite.
+ path := OrderedCollection new: 16.
+ #(40 115 190 265) do: [:y |
+ #(60 160 260 360) do: [:x |
+ path add: x@y]].
+ 1 to: 16 do: [:index |
+ BitBlt exampleAt: (path at: index) rule: index - 1 fillColor: nil].
+ """)
+ self.assert_matches(traces[0].loop, """
+ guard_not_invalidated(descr=<Guard0x1898410>),
+ i74 = int_le(i68, 1000000),
+ guard_true(i74, descr=<Guard0x18983a0>),
+ i75 = int_xor(i66, i63),
+ i76 = int_add(i68, 1),
+ i77 = int_sub(i71, 1),
+ setfield_gc(ConstPtr(ptr57), i77, descr=<FieldS
spyvm.interpreter.Interpreter.inst_interrupt_check_counter 24>),
+ i78 = int_le(i77, 0),
+ guard_false(i78, descr=<Guard0x1898330>),
+ jump(p0, p3, i75, p8, i76, p16, p18, p20, p22, p24, p26, p28, p30,
p32, p34, p36, p38, p40, p42, i63, i77, descr=TargetToken(24673448))
+ """)
diff --git a/spyvm/test/test_interpreter.py b/spyvm/test/test_interpreter.py
--- a/spyvm/test/test_interpreter.py
+++ b/spyvm/test/test_interpreter.py
@@ -431,7 +431,7 @@
assert s_active_context.w_sender() == w_frame
assert s_active_context.stack() == []
assert
w_active_context.as_methodcontext_get_shadow(space).w_receiver().is_same_object(w_object)
- assert
w_active_context.as_methodcontext_get_shadow(space).w_method().is_same_object(shadow.s_methoddict().methoddict[w_foo].w_self())
+ assert
w_active_context.as_methodcontext_get_shadow(space).w_method().is_same_object(shadow.s_methoddict().methoddict[w_foo.as_string()].w_self())
assert s_frame.stack() == []
step_in_interp(s_active_context)
w_active_context = step_in_interp(s_active_context)
@@ -602,7 +602,7 @@
s_frame.push(space.w_one)
w_active_context = step_in_interp(s_frame)
s_active_context = w_active_context.as_context_get_shadow(space)
- assert w_active_context.as_methodcontext_get_shadow(space).s_method() ==
shadow.s_methoddict().methoddict[w_symbol]
+ assert w_active_context.as_methodcontext_get_shadow(space).s_method() ==
shadow.s_methoddict().methoddict[w_symbol.as_string()]
assert s_active_context.w_receiver() is w_object
assert
w_active_context.as_methodcontext_get_shadow(space).gettemp(0).is_same_object(space.w_one)
assert s_active_context.stack() == []
@@ -662,7 +662,7 @@
assert s_active_context.w_sender() == w_caller_context
assert s_active_context.stack() == []
assert
w_active_context.as_methodcontext_get_shadow(space).w_receiver() == w_object
- meth =
w_specificclass.as_class_get_shadow(space).s_methoddict().methoddict[foo]
+ meth =
w_specificclass.as_class_get_shadow(space).s_methoddict().methoddict[foo.as_string()]
assert s_active_context.w_method() == meth.w_self()
assert s_caller_context.stack() == []
diff --git a/spyvm/test/test_miniimage.py b/spyvm/test/test_miniimage.py
--- a/spyvm/test/test_miniimage.py
+++ b/spyvm/test/test_miniimage.py
@@ -343,21 +343,28 @@
def test_large_positive_integer_operations():
w_result = perform(interp.space.w_SmallInteger, "maxVal")
- w_result = perform(w_result, "+", space.wrap_int(42))
+ w_result = perform(w_result, "+", space.wrap_int(2 *
interp.space.unwrap_int(w_result)))
assert w_result is not None
- assert isinstance(w_result, model.W_LargePositiveInteger1Word)
+ if constants.LONG_BIT == 32:
+ assert isinstance(w_result, model.W_LargePositiveInteger1Word)
+ else:
+ assert isinstance(w_result, model.W_SmallInteger)
w_result = perform(interp.space.w_SmallInteger, "maxVal")
w_result = perform(w_result, "*", w_result)
assert w_result is not None
- assert isinstance(w_result, model.W_BytesObject)
+ if constants.LONG_BIT == 32:
+ assert isinstance(w_result, model.W_BytesObject)
+ else:
+ assert isinstance(w_result, model.W_SmallInteger)
def test_compiling_large_positive_integer():
- sourcecode = """aLargeInteger
+ if constants.LONG_BIT == 32:
+ sourcecode = """aLargeInteger
^ 16rFFFFFFFF"""
- perform(w(10).getclass(space), "compile:classified:notifying:",
w(sourcecode), w('pypy'), w(None))
- w_result = perform(w(10), "aLargeInteger")
- assert isinstance(w_result, model.W_LargePositiveInteger1Word)
+ perform(w(10).getclass(space), "compile:classified:notifying:",
w(sourcecode), w('pypy'), w(None))
+ w_result = perform(w(10), "aLargeInteger")
+ assert isinstance(w_result, model.W_LargePositiveInteger1Word)
def test_doesNotUnderstand():
w_dnu = interp.space.objtable["w_doesNotUnderstand"]
@@ -410,7 +417,7 @@
selectors_w = w_methoddict._shadow.methoddict.keys()
w_sel = None
for sel in selectors_w:
- if sel.as_string() == 'size':
+ if sel == 'size':
w_sel = sel
size = prim(primitives.PERFORM_WITH_ARGS, [w_o, w_sel, []])
assert size.value == 3
diff --git a/spyvm/test/test_model.py b/spyvm/test/test_model.py
--- a/spyvm/test/test_model.py
+++ b/spyvm/test/test_model.py
@@ -3,8 +3,8 @@
import socket
from spyvm import model, shadow
from spyvm.shadow import MethodNotFound
-from spyvm import objspace, error, display
-from rpython.rlib.rarithmetic import intmask, r_uint32 as r_uint
+from spyvm import objspace, error, display, constants
+from rpython.rlib.rarithmetic import intmask, r_uint32
mockclass = objspace.bootstrap_class
@@ -50,6 +50,7 @@
assert w_bytes.getchar(0) == "\x00"
py.test.raises(IndexError, lambda: w_bytes.getchar(20))
[email protected]("constants.LONG_BIT == 64")
def test_c_bytes_object():
w_class = mockclass(space, 0, format=shadow.BYTES)
w_bytes = w_class.as_class_get_shadow(space).new(20)
@@ -75,6 +76,7 @@
assert w_bytes.getword(0) == 0
py.test.raises(AssertionError, lambda: w_bytes.getword(20))
[email protected]("constants.LONG_BIT == 64")
def test_c_word_object():
w_class = mockclass(space, 0, format=shadow.WORDS)
w_bytes = w_class.as_class_get_shadow(space).new(20)
@@ -266,18 +268,25 @@
b.setword(0, 3221225472)
r = b.at0(space, 0)
- assert isinstance(r, (model.W_BytesObject,
model.W_LargePositiveInteger1Word))
- assert r.size() == 4
+ if constants.LONG_BIT == 32:
+ assert isinstance(r, (model.W_BytesObject,
model.W_LargePositiveInteger1Word))
+ assert r.size() == 4
+ else:
+ assert isinstance(r, (model.W_SmallInteger))
def test_float_at():
b = model.W_Float(64.0)
r = b.fetch(space, 0)
- assert isinstance(r, model.W_LargePositiveInteger1Word)
- assert r.size() == 4
- assert space.unwrap_int(r.at0(space, 0)) == 0
- assert space.unwrap_int(r.at0(space, 1)) == 0
- assert space.unwrap_int(r.at0(space, 2)) == 80
- assert space.unwrap_int(r.at0(space, 3)) == 64
+ assert isinstance(r, model.W_LargePositiveInteger1Word) or (isinstance(r,
model.W_SmallInteger) and r.value > 0)
+ if not isinstance(r, model.W_SmallInteger):
+ assert False
+ assert r.size() == 4
+ assert space.unwrap_int(r.at0(space, 0)) == 0
+ assert space.unwrap_int(r.at0(space, 1)) == 0
+ assert space.unwrap_int(r.at0(space, 2)) == 80
+ assert space.unwrap_int(r.at0(space, 3)) == 64
+ else:
+ assert r.value == ((64 << 24) + (80 << 16))
r = b.fetch(space, 1)
assert isinstance(r, model.W_SmallInteger)
assert r.value == 0
@@ -313,7 +322,7 @@
for i in range(4):
target.atput0(space, i, source.at0(space, i))
assert target.at0(space, i) == source.at0(space, i)
- assert hex(r_uint(target.value)) == hex(r_uint(source.value))
+ assert hex(r_uint32(target.value)) == hex(r_uint32(source.value))
def test_BytesObject_short_at():
target = model.W_BytesObject(space, None, 4)
@@ -335,8 +344,8 @@
def test_WordsObject_short_at():
target = model.W_WordsObject(space, None, 2)
- target.setword(0, r_uint(0x00018000))
- target.setword(1, r_uint(0x80010111))
+ target.setword(0, r_uint32(0x00018000))
+ target.setword(1, r_uint32(0x80010111))
assert target.short_at0(space, 0).value == intmask(0xffff8000)
assert target.short_at0(space, 1).value == intmask(0x0001)
assert target.short_at0(space, 2).value == intmask(0x0111)
@@ -345,7 +354,7 @@
def test_WordsObject_short_atput():
target = model.W_WordsObject(space, None, 2)
target.short_atput0(space, 0, space.wrap_int(0x0100))
- target.short_atput0(space, 1, space.wrap_int(-1))
+ target.short_atput0(space, 1, space.wrap_int(intmask(0xffffffff)))
target.short_atput0(space, 2, space.wrap_int(intmask(0xffff8000)))
target.short_atput0(space, 3, space.wrap_int(0x7fff))
assert target.getword(0) == 0xffff0100
@@ -356,26 +365,21 @@
# double-free bug
def get_pixelbuffer(self):
from rpython.rtyper.lltypesystem import lltype, rffi
- return lltype.malloc(rffi.ULONGP.TO, self.width * self.height * 32,
flavor='raw')
+ return lltype.malloc(rffi.UINTP.TO, self.width * self.height * 32,
flavor='raw')
display.SDLDisplay.get_pixelbuffer = get_pixelbuffer
d = display.SDLDisplay("test")
d.set_video_mode(32, 10, 1)
target = model.W_DisplayBitmap.create(space, space.w_Array, 10, 1, d)
- target.setword(0, r_uint(0xFF00))
+ target.setword(0, r_uint32(0xFF00))
assert bin(target.getword(0)) == bin(0xFF00)
- target.setword(0, r_uint(0x00FF00FF))
+ target.setword(0, r_uint32(0x00FF00FF))
assert bin(target.getword(0)) == bin(0x00FF00FF)
- target.setword(0, r_uint(0xFF00FF00))
+ target.setword(0, r_uint32(0xFF00FF00))
assert bin(target.getword(0)) == bin(0xFF00FF00)
+ # Mapping 1-bit to 8-bit depth
for i in xrange(8):
- assert target.pixelbuffer[i] == 0xff000000
- for i in xrange(8, 16):
- assert target.pixelbuffer[i] == 0xffffffff
- for i in xrange(16, 24):
- assert target.pixelbuffer[i] == 0xff000000
- for i in xrange(24, 32):
- assert target.pixelbuffer[i] == 0xffffffff
+ assert target.pixelbuffer[i] == 0x01010101
@py.test.mark.skipif("socket.gethostname() == 'precise32'")
diff --git a/spyvm/test/test_objectspace.py b/spyvm/test/test_objectspace.py
--- a/spyvm/test/test_objectspace.py
+++ b/spyvm/test/test_objectspace.py
@@ -40,16 +40,17 @@
=> 27670116110564327424
"""
- from rpython.rlib.rarithmetic import r_uint32 as r_uint
+ from rpython.rlib.rarithmetic import r_uint
for num in [0, 1, 41, 100, 2**31, sys.maxint + 1, -1]:
num = r_uint(num)
assert space.unwrap_uint(space.wrap_uint(num)) == num
for num in [-1, -100, -sys.maxint]:
with py.test.raises(objspace.WrappingError):
space.wrap_uint(num)
- for obj in [space.wrap_char('a'), space.wrap_int(-1)]:
+ for obj in [space.wrap_char('a')]:
with py.test.raises(objspace.UnwrappingError):
space.unwrap_uint(obj)
+ assert space.unwrap_uint(space.wrap_int(-1)) == r_uint(-1)
# byteobj = space.wrap_uint(0x100000000)
# assert isinstance(byteobj, model.W_BytesObject)
# byteobj.bytes.append('\x01')
@@ -65,7 +66,8 @@
with py.test.raises(AssertionError):
space.wrap_int(num)
- from rpython.rlib.rarithmetic import intmask
- for num in [0x7fffffff, intmask(0x80000000)]:
- with py.test.raises(objspace.WrappingError):
- space.wrap_int(num)
+ # XXX: We ignore tagging now -- not sure if this is ok
+ # from rpython.rlib.rarithmetic import intmask
+ # for num in [0x7fffffff, intmask(0x80000000)]:
+ # with py.test.raises(objspace.WrappingError):
+ # space.wrap_int(num)
diff --git a/spyvm/test/test_primitives.py b/spyvm/test/test_primitives.py
--- a/spyvm/test/test_primitives.py
+++ b/spyvm/test/test_primitives.py
@@ -68,7 +68,7 @@
assert prim(primitives.ADD, [3,4]).value == 7
def test_small_int_add_fail():
- w_result = prim_fails(primitives.ADD, [constants.TAGGED_MAXINT, 2])
+ w_result = prim_fails(primitives.ADD, [constants.MAXINT, 2])
# assert isinstance(w_result, model.W_LargePositiveInteger1Word)
# assert w_result.value == constants.TAGGED_MAXINT + 2
# prim_fails(primitives.ADD, [constants.TAGGED_MAXINT,
constants.TAGGED_MAXINT * 2])
@@ -77,21 +77,21 @@
assert prim(primitives.SUBTRACT, [5,9]).value == -4
def test_small_int_minus_fail():
- prim_fails(primitives.SUBTRACT, [constants.TAGGED_MININT,1])
+ prim_fails(primitives.SUBTRACT, [constants.MININT,1])
prim_fails(primitives.SUBTRACT,
- [constants.TAGGED_MININT, constants.TAGGED_MAXINT])
+ [constants.MININT, constants.MAXINT])
def test_small_int_multiply():
assert prim(primitives.MULTIPLY, [6,3]).value == 18
def test_small_int_multiply_overflow():
- w_result = prim_fails(primitives.MULTIPLY, [constants.TAGGED_MAXINT, 2])
+ w_result = prim_fails(primitives.MULTIPLY, [constants.MAXINT, 2])
#assert isinstance(w_result, model.W_LargePositiveInteger1Word)
#assert w_result.value == constants.TAGGED_MAXINT * 2
- prim_fails(primitives.MULTIPLY, [constants.TAGGED_MAXINT,
constants.TAGGED_MAXINT])
- prim_fails(primitives.MULTIPLY, [constants.TAGGED_MAXINT, -4])
- prim_fails(primitives.MULTIPLY, [constants.TAGGED_MININT,
constants.TAGGED_MAXINT])
- prim_fails(primitives.MULTIPLY, [constants.TAGGED_MININT, 2])
+ prim_fails(primitives.MULTIPLY, [constants.MAXINT, constants.MAXINT])
+ prim_fails(primitives.MULTIPLY, [constants.MAXINT, -4])
+ prim_fails(primitives.MULTIPLY, [constants.MININT, constants.MAXINT])
+ prim_fails(primitives.MULTIPLY, [constants.MININT, 2])
def test_small_int_divide():
assert prim(primitives.DIVIDE, [6,3]).value == 2
@@ -176,14 +176,22 @@
def test_small_int_bit_shift_fail():
from rpython.rlib.rarithmetic import intmask
- prim_fails(primitives.BIT_SHIFT, [4, 32])
- prim_fails(primitives.BIT_SHIFT, [4, 31])
- prim_fails(primitives.BIT_SHIFT, [4, 30])
+ if constants.LONG_BIT == 32:
+ prim_fails(primitives.BIT_SHIFT, [4, 32])
+ prim_fails(primitives.BIT_SHIFT, [4, 31])
+ prim_fails(primitives.BIT_SHIFT, [4, 30])
+ else:
+ prim_fails(primitives.BIT_SHIFT, [4, 64])
+ prim_fails(primitives.BIT_SHIFT, [4, 63])
+ prim_fails(primitives.BIT_SHIFT, [4, 62])
w_result = prim(primitives.BIT_SHIFT, [4, 29])
- assert isinstance(w_result, model.W_LargePositiveInteger1Word)
+ if constants.LONG_BIT == 32:
+ assert isinstance(w_result, model.W_LargePositiveInteger1Word)
+ else:
+ assert isinstance(w_result, model.W_SmallInteger)
assert w_result.value == intmask(4 << 29)
w_result = prim(primitives.BIT_SHIFT, [4, 28])
- assert isinstance(w_result, model.W_LargePositiveInteger1Word)
+ assert isinstance(w_result, model.W_SmallInteger)
assert w_result.value == 4 << 28
def test_smallint_as_float():
@@ -430,16 +438,51 @@
def test_primitive_milliseconds_clock():
import time
- start = prim(primitives.MILLISECOND_CLOCK, [0]).value
+ class Image(object):
+ def __init__(self):
+ self.startup_time = int(time.time() * 1000)
+ image = Image()
+
+ interp, w_frame, argument_count = mock([0], None)
+ interp.image = image
+ prim_table[primitives.MILLISECOND_CLOCK](interp,
w_frame.as_context_get_shadow(space), argument_count-1)
+ start = w_frame.as_context_get_shadow(space).pop().value
+ s_frame = w_frame.as_context_get_shadow(space)
+ assert not s_frame.stackdepth() - s_frame.tempsize() # check args are
consumed
+
time.sleep(0.3)
- stop = prim(primitives.MILLISECOND_CLOCK, [0]).value
+ interp, w_frame, argument_count = mock([0], None)
+ interp.image = image
+ prim_table[primitives.MILLISECOND_CLOCK](interp,
w_frame.as_context_get_shadow(space), argument_count-1)
+ stop = w_frame.as_context_get_shadow(space).pop().value
+ s_frame = w_frame.as_context_get_shadow(space)
+ assert not s_frame.stackdepth() - s_frame.tempsize() # check args are
consumed
+
assert start + 250 <= stop
def test_signal_at_milliseconds():
import time
- future = prim(primitives.MILLISECOND_CLOCK, [0]).value + 400
+ class Image(object):
+ def __init__(self):
+ self.startup_time = int(time.time() * 1000)
+ image = Image()
+
+ interp, w_frame, argument_count = mock([0], None)
+ interp.image = image
+ prim_table[primitives.MILLISECOND_CLOCK](interp,
w_frame.as_context_get_shadow(space), argument_count-1)
+ future = w_frame.as_context_get_shadow(space).pop().value + 400
+ s_frame = w_frame.as_context_get_shadow(space)
+ assert not s_frame.stackdepth() - s_frame.tempsize() # check args are
consumed
+
sema = space.w_Semaphore.as_class_get_shadow(space).new()
- prim(primitives.SIGNAL_AT_MILLISECONDS, [space.w_nil, sema, future])
+
+ interp, w_frame, argument_count = mock([space.w_nil, sema, future], None)
+ interp.image = image
+ prim_table[primitives.SIGNAL_AT_MILLISECONDS](interp,
w_frame.as_context_get_shadow(space), argument_count-1)
+ res = w_frame.as_context_get_shadow(space).pop()
+ s_frame = w_frame.as_context_get_shadow(space)
+ assert not s_frame.stackdepth() - s_frame.tempsize() # check args are
consumed
+
assert space.objtable["w_timerSemaphore"] is sema
def test_inc_gc():
@@ -722,7 +765,7 @@
# double-free bug
def get_pixelbuffer(self):
from rpython.rtyper.lltypesystem import lltype, rffi
- return lltype.malloc(rffi.ULONGP.TO, self.width * self.height * 32,
flavor='raw')
+ return lltype.malloc(rffi.UINTP.TO, self.width * self.height * 32,
flavor='raw')
display.SDLDisplay.get_pixelbuffer = get_pixelbuffer
assert space.objtable["w_display"] is None
@@ -762,7 +805,7 @@
# double-free bug
def get_pixelbuffer(self):
from rpython.rtyper.lltypesystem import lltype, rffi
- return lltype.malloc(rffi.ULONGP.TO, self.width * self.height * 32,
flavor='raw')
+ return lltype.malloc(rffi.UINTP.TO, self.width * self.height * 32,
flavor='raw')
display.SDLDisplay.get_pixelbuffer = get_pixelbuffer
mock_display = model.W_PointersObject(space, space.w_Point, 4)
@@ -776,7 +819,7 @@
class DisplayFlush(Exception):
pass
- def flush_to_screen_mock(self):
+ def flush_to_screen_mock(self, force=False):
raise DisplayFlush
try:
@@ -787,6 +830,8 @@
monkeypatch.undo()
def test_bitblt_copy_bits(monkeypatch):
+ from spyvm.plugins import bitblt
+
class CallCopyBitsSimulation(Exception):
pass
class Image():
@@ -810,7 +855,7 @@
try:
monkeypatch.setattr(w_frame._shadow, "_sendSelfSelector", perform_mock)
- monkeypatch.setattr(shadow.BitBltShadow, "sync_cache", sync_cache_mock)
+ monkeypatch.setattr(bitblt.BitBltShadow, "sync_cache", sync_cache_mock)
with py.test.raises(CallCopyBitsSimulation):
prim_table[primitives.BITBLT_COPY_BITS](interp,
w_frame.as_context_get_shadow(space), argument_count-1)
finally:
diff --git a/spyvm/test/test_shadow.py b/spyvm/test/test_shadow.py
--- a/spyvm/test/test_shadow.py
+++ b/spyvm/test/test_shadow.py
@@ -72,8 +72,8 @@
classshadow = w_class.as_class_get_shadow(space)
methoddict = classshadow.s_methoddict().methoddict
assert len(methods) == len(methoddict)
- for w_key, value in methoddict.items():
- assert methods[w_key.as_string()].as_compiledmethod_get_shadow(space)
is value
+ for key, value in methoddict.items():
+ assert methods[key].as_compiledmethod_get_shadow(space) is value
def method(tempsize=3,argsize=2, bytes="abcde"):
w_m = model.W_CompiledMethod()
@@ -264,15 +264,15 @@
version = s_class.version
w_method = model.W_CompiledMethod(0)
- key = space.wrap_string('foo')
+ w_key = space.wrap_string('foo')
s_md = w_parent.as_class_get_shadow(space).s_methoddict()
s_md.sync_cache()
w_ary = s_md._w_self._fetch(constants.METHODDICT_VALUES_INDEX)
- s_md._w_self.atput0(space, 0, key)
+ s_md._w_self.atput0(space, 0, w_key)
w_ary.atput0(space, 0, w_method)
- assert s_class.lookup(key) is w_method.as_compiledmethod_get_shadow(space)
+ assert s_class.lookup(w_key) is
w_method.as_compiledmethod_get_shadow(space)
assert s_class.version is not version
assert s_class.version is w_parent.as_class_get_shadow(space).version
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
