[pypy-commit] pypy default: Remove the smallintobject - it does not work with the JIT and it should
fijal
noreply at buildbot.pypy.org
Sat Mar 23 21:55:27 CET 2013
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch:
Changeset: r62708:4ceef442528f
Date: 2013-03-23 13:55 -0700
http://bitbucket.org/pypy/pypy/changeset/4ceef442528f/
Log: Remove the smallintobject - it does not work with the JIT and it
should be reworked for the upcoming multimethod removal anyway. It's
also not very useful in the presence of the JIT.
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -189,11 +189,6 @@
BoolOption("withtproxy", "support transparent proxies",
default=True),
- BoolOption("withsmallint", "use tagged integers",
- default=False,
- requires=[("objspace.std.withprebuiltint", False),
- ("translation.taggedpointers", True)]),
-
BoolOption("withprebuiltint", "prebuild commonly used int objects",
default=False),
@@ -204,9 +199,7 @@
default=100, cmdline="--prebuiltintto"),
BoolOption("withsmalllong", "use a version of 'long' in a C long long",
- default=False,
- requires=[("objspace.std.withsmallint", False)]),
- # ^^^ because of missing delegate_xx2yy
+ default=False),
BoolOption("withstrbuf", "use strings optimized for addition (ver 2)",
default=False),
diff --git a/pypy/objspace/std/frame.py b/pypy/objspace/std/frame.py
--- a/pypy/objspace/std/frame.py
+++ b/pypy/objspace/std/frame.py
@@ -6,7 +6,7 @@
from pypy.interpreter import pyopcode
from pypy.interpreter.pyframe import PyFrame
from pypy.interpreter.error import OperationError
-from pypy.objspace.std import intobject, smallintobject
+from pypy.objspace.std import intobject
from pypy.objspace.std.multimethod import FailedToImplement
from pypy.objspace.std.listobject import W_ListObject
@@ -23,20 +23,6 @@
raise AssertionError
-def small_int_BINARY_ADD(f, oparg, next_instr):
- w_2 = f.popvalue()
- w_1 = f.popvalue()
- if (type(w_1) is smallintobject.W_SmallIntObject and
- type(w_2) is smallintobject.W_SmallIntObject):
- try:
- w_result = smallintobject.add__SmallInt_SmallInt(f.space, w_1, w_2)
- except FailedToImplement:
- w_result = f.space.add(w_1, w_2)
- else:
- w_result = f.space.add(w_1, w_2)
- f.pushvalue(w_result)
-
-
def int_BINARY_ADD(f, oparg, next_instr):
w_2 = f.popvalue()
w_1 = f.popvalue()
@@ -102,10 +88,7 @@
class StdObjSpaceFrame(BaseFrame):
pass
if space.config.objspace.std.optimized_int_add:
- if space.config.objspace.std.withsmallint:
- StdObjSpaceFrame.BINARY_ADD = small_int_BINARY_ADD
- else:
- StdObjSpaceFrame.BINARY_ADD = int_BINARY_ADD
+ StdObjSpaceFrame.BINARY_ADD = int_BINARY_ADD
if space.config.objspace.std.optimized_list_getitem:
StdObjSpaceFrame.BINARY_SUBSCR = list_BINARY_SUBSCR
if space.config.objspace.opcodes.CALL_METHOD:
diff --git a/pypy/objspace/std/inttype.py b/pypy/objspace/std/inttype.py
--- a/pypy/objspace/std/inttype.py
+++ b/pypy/objspace/std/inttype.py
@@ -39,14 +39,7 @@
def wrapint(space, x):
- if space.config.objspace.std.withsmallint:
- from pypy.objspace.std.smallintobject import W_SmallIntObject
- try:
- return W_SmallIntObject(x)
- except OverflowError:
- from pypy.objspace.std.intobject import W_IntObject
- return W_IntObject(x)
- elif space.config.objspace.std.withprebuiltint:
+ if space.config.objspace.std.withprebuiltint:
from pypy.objspace.std.intobject import W_IntObject
lower = space.config.objspace.std.prebuiltintfrom
upper = space.config.objspace.std.prebuiltintto
diff --git a/pypy/objspace/std/model.py b/pypy/objspace/std/model.py
--- a/pypy/objspace/std/model.py
+++ b/pypy/objspace/std/model.py
@@ -17,7 +17,6 @@
option_to_typename = {
"withspecialisedtuple" : ["specialisedtupleobject.W_SpecialisedTupleObject"],
"withsmalltuple" : ["smalltupleobject.W_SmallTupleObject"],
- "withsmallint" : ["smallintobject.W_SmallIntObject"],
"withsmalllong" : ["smalllongobject.W_SmallLongObject"],
"withstrbuf" : ["strbufobject.W_StringBufferObject"],
}
@@ -158,18 +157,6 @@
# when trying to dispatch multimethods.
# XXX build these lists a bit more automatically later
- if config.objspace.std.withsmallint:
- from pypy.objspace.std import smallintobject
- self.typeorder[boolobject.W_BoolObject] += [
- (smallintobject.W_SmallIntObject, boolobject.delegate_Bool2SmallInt),
- ]
- self.typeorder[smallintobject.W_SmallIntObject] += [
- (intobject.W_IntObject, smallintobject.delegate_SmallInt2Int),
- (floatobject.W_FloatObject, smallintobject.delegate_SmallInt2Float),
- (longobject.W_LongObject, smallintobject.delegate_SmallInt2Long),
- (complexobject.W_ComplexObject, smallintobject.delegate_SmallInt2Complex),
- ]
-
if config.objspace.usemodules.micronumpy:
from pypy.module.micronumpy.stdobjspace import register_delegates
register_delegates(self.typeorder)
diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py
--- a/pypy/objspace/std/objspace.py
+++ b/pypy/objspace/std/objspace.py
@@ -26,7 +26,6 @@
from pypy.objspace.std.iterobject import W_SeqIterObject
from pypy.objspace.std.setobject import W_SetObject, W_FrozensetObject
from pypy.objspace.std.sliceobject import W_SliceObject
-from pypy.objspace.std.smallintobject import W_SmallIntObject
from pypy.objspace.std.stringobject import W_StringObject
from pypy.objspace.std.unicodeobject import W_UnicodeObject
from pypy.objspace.std.tupleobject import W_AbstractTupleObject
@@ -580,16 +579,8 @@
self.setitem(w_obj, self.wrap(key), w_value)
def getindex_w(self, w_obj, w_exception, objdescr=None):
- # Performance shortcut for the common case of w_obj being an int.
- # If withsmallint is disabled, we check for W_IntObject.
- # If withsmallint is enabled, we only check for W_SmallIntObject - it's
- # probably not useful to have a shortcut for W_IntObject at all then.
- if self.config.objspace.std.withsmallint:
- if type(w_obj) is W_SmallIntObject:
- return w_obj.intval
- else:
- if type(w_obj) is W_IntObject:
- return w_obj.intval
+ if type(w_obj) is W_IntObject:
+ return w_obj.intval
return ObjSpace.getindex_w(self, w_obj, w_exception, objdescr)
def call_method(self, w_obj, methname, *arg_w):
diff --git a/pypy/objspace/std/smallintobject.py b/pypy/objspace/std/smallintobject.py
deleted file mode 100644
--- a/pypy/objspace/std/smallintobject.py
+++ /dev/null
@@ -1,87 +0,0 @@
-"""
-Implementation of small ints, stored as odd-valued pointers in the
-translated PyPy. To enable them, see inttype.py.
-"""
-from pypy.objspace.std import intobject
-from pypy.objspace.std.model import registerimplementation, W_Object
-from pypy.objspace.std.register_all import register_all
-from pypy.objspace.std.noneobject import W_NoneObject
-from pypy.objspace.std.intobject import W_AbstractIntObject, W_IntObject
-from pypy.interpreter.error import OperationError
-from rpython.rlib.objectmodel import UnboxedValue
-from rpython.rlib.rbigint import rbigint
-from rpython.rlib.rarithmetic import r_uint
-from rpython.tool.sourcetools import func_with_new_name
-from pypy.objspace.std.inttype import wrapint
-
-class W_SmallIntObject(W_AbstractIntObject, UnboxedValue):
- __slots__ = 'intval'
- from pypy.objspace.std.inttype import int_typedef as typedef
-
- def unwrap(w_self, space):
- return int(w_self.intval)
- int_w = unwrap
-
- def uint_w(w_self, space):
- intval = w_self.intval
- if intval < 0:
- raise OperationError(space.w_ValueError,
- space.wrap("cannot convert negative integer to unsigned"))
- else:
- return r_uint(intval)
-
- def bigint_w(w_self, space):
- return rbigint.fromint(w_self.intval)
-
-
-registerimplementation(W_SmallIntObject)
-
-
-def delegate_SmallInt2Int(space, w_small):
- return W_IntObject(w_small.intval)
-
-def delegate_SmallInt2Long(space, w_small):
- return space.newlong(w_small.intval)
-
-def delegate_SmallInt2Float(space, w_small):
- return space.newfloat(float(w_small.intval))
-
-def delegate_SmallInt2Complex(space, w_small):
- return space.newcomplex(float(w_small.intval), 0.0)
-
-def add__SmallInt_SmallInt(space, w_a, w_b):
- return wrapint(space, w_a.intval + w_b.intval) # cannot overflow
-
-def sub__SmallInt_SmallInt(space, w_a, w_b):
- return wrapint(space, w_a.intval - w_b.intval) # cannot overflow
-
-def floordiv__SmallInt_SmallInt(space, w_a, w_b):
- return wrapint(space, w_a.intval // w_b.intval) # cannot overflow
-
-div__SmallInt_SmallInt = floordiv__SmallInt_SmallInt
-
-def mod__SmallInt_SmallInt(space, w_a, w_b):
- return wrapint(space, w_a.intval % w_b.intval) # cannot overflow
-
-def divmod__SmallInt_SmallInt(space, w_a, w_b):
- w = wrapint(space, w_a.intval // w_b.intval) # cannot overflow
- z = wrapint(space, w_a.intval % w_b.intval)
- return space.newtuple([w, z])
-
-def copy_multimethods(ns):
- """Copy integer multimethods for small int."""
- for name, func in intobject.__dict__.iteritems():
- if "__Int" in name:
- new_name = name.replace("Int", "SmallInt")
- if new_name not in ns:
- # Copy the function, so the annotator specializes it for
- # W_SmallIntObject.
- ns[new_name] = func = func_with_new_name(func, new_name, globals=ns)
- else:
- ns[name] = func
- ns["get_integer"] = ns["pos__SmallInt"] = ns["int__SmallInt"]
- ns["get_negint"] = ns["neg__SmallInt"]
-
-copy_multimethods(globals())
-
-register_all(vars())
diff --git a/pypy/objspace/std/test/test_smallintobject.py b/pypy/objspace/std/test/test_smallintobject.py
deleted file mode 100644
--- a/pypy/objspace/std/test/test_smallintobject.py
+++ /dev/null
@@ -1,229 +0,0 @@
-import sys, py
-
-#from pypy.objspace.std.model import WITHSMALLINT
-#if not WITHSMALLINT:
-# py.test.skip("WITHSMALLINT is not enabled")
-
-from pypy.objspace.std.inttype import wrapint
-from pypy.objspace.std.multimethod import FailedToImplement
-from rpython.rlib.rarithmetic import r_uint
-
-from pypy.objspace.std.test.test_intobject import AppTestInt
-
-class TestW_IntObject:
- spaceconfig = {"objspace.std.withsmallint": True}
-
- def test_int_w(self):
- assert self.space.int_w(self.space.wrap(42)) == 42
-
- def test_uint_w(self):
- space = self.space
- assert space.uint_w(space.wrap(42)) == 42
- assert isinstance(space.uint_w(space.wrap(42)), r_uint)
- space.raises_w(space.w_ValueError, space.uint_w, space.wrap(-1))
-
- def test_repr(self):
- x = 1
- f1 = wrapint(self.space, x)
- result = self.space.repr(f1)
- assert self.space.unwrap(result) == repr(x)
-
- def test_str(self):
- x = 12345
- f1 = wrapint(self.space, x)
- result = self.space.str(f1)
- assert self.space.unwrap(result) == str(x)
-
- def test_hash(self):
- x = 42
- f1 = wrapint(self.space, x)
- result = self.space.hash(f1)
- assert result.intval == hash(x)
-
- def test_compare(self):
- import operator
- optab = ['lt', 'le', 'eq', 'ne', 'gt', 'ge']
- for x in (-10, -1, 0, 1, 2, 1000, sys.maxint):
- for y in (-sys.maxint-1, -11, -9, -2, 0, 1, 3, 1111, sys.maxint):
- for op in optab:
- wx = wrapint(self.space, x)
- wy = wrapint(self.space, y)
- res = getattr(operator, op)(x, y)
- method = getattr(self.space, op)
- myres = method(wx, wy)
- assert self.space.unwrap(myres) == res
-
- def test_add(self):
- for x in [1, 100, sys.maxint // 2 - 50,
- sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
- for y in [1, 100, sys.maxint // 2 - 50,
- sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- result = self.space.unwrap(self.space.add(f1, f2))
- assert result == x+y
-
- def test_sub(self):
- for x in [1, 100, sys.maxint // 2 - 50,
- sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
- for y in [1, 100, sys.maxint // 2 - 50,
- sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- result = self.space.unwrap(self.space.sub(f1, f2))
- assert result == x-y
-
- def test_mul(self):
- for x in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - 1000]:
- for y in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - 1000]:
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- result = self.space.unwrap(self.space.mul(f1, f2))
- assert result == x*y
-
-
- def test_div(self):
- for i in range(10):
- res = i//3
- f1 = wrapint(self.space, i)
- f2 = wrapint(self.space, 3)
- result = self.space.div(f1, f2)
- assert result.intval == res
-
- def test_mod(self):
- x = 1
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- v = self.space.mod(f1, f2)
- assert v.intval == x % y
- # not that mod cannot overflow
-
- def test_divmod(self):
- x = 1
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- ret = self.space.divmod(f1, f2)
- v, w = self.space.unwrap(ret)
- assert (v, w) == divmod(x, y)
-
- def test_pow_iii(self):
- x = 10
- y = 2
- z = 13
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- f3 = wrapint(self.space, z)
- v = self.space.pow(f1, f2, f3)
- assert v.intval == pow(x, y, z)
- f1, f2, f3 = [wrapint(self.space, i) for i in (10, -1, 42)]
- self.space.raises_w(self.space.w_TypeError,
- self.space.pow,
- f1, f2, f3)
- f1, f2, f3 = [wrapint(self.space, i) for i in (10, 5, 0)]
- self.space.raises_w(self.space.w_ValueError,
- self.space.pow,
- f1, f2, f3)
-
- def test_pow_iin(self):
- x = 10
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- v = self.space.pow(f1, f2, self.space.w_None)
- assert v.intval == x ** y
-
- def test_neg(self):
- x = 42
- f1 = wrapint(self.space, x)
- v = self.space.neg(f1)
- assert v.intval == -x
-
- def test_pos(self):
- x = 42
- f1 = wrapint(self.space, x)
- v = self.space.pos(f1)
- assert v.intval == +x
- x = -42
- f1 = wrapint(self.space, x)
- v = self.space.pos(f1)
- assert v.intval == +x
-
- def test_abs(self):
- x = 42
- f1 = wrapint(self.space, x)
- v = self.space.abs(f1)
- assert v.intval == abs(x)
- x = -42
- f1 = wrapint(self.space, x)
- v = self.space.abs(f1)
- assert v.intval == abs(x)
-
- def test_invert(self):
- x = 42
- f1 = wrapint(self.space, x)
- v = self.space.invert(f1)
- assert v.intval == ~x
-
- def test_lshift(self):
- x = 12345678
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- v = self.space.lshift(f1, f2)
- assert v.intval == x << y
-
- def test_rshift(self):
- x = 12345678
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- v = self.space.rshift(f1, f2)
- assert v.intval == x >> y
-
- def test_and(self):
- x = 12345678
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- v = self.space.and_(f1, f2)
- assert v.intval == x & y
-
- def test_xor(self):
- x = 12345678
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- v = self.space.xor(f1, f2)
- assert v.intval == x ^ y
-
- def test_or(self):
- x = 12345678
- y = 2
- f1 = wrapint(self.space, x)
- f2 = wrapint(self.space, y)
- v = self.space.or_(f1, f2)
- assert v.intval == x | y
-
- def test_int(self):
- f1 = wrapint(self.space, 1)
- result = self.space.int(f1)
- assert result == f1
-
- def test_oct(self):
- x = 012345
- f1 = wrapint(self.space, x)
- result = self.space.oct(f1)
- assert self.space.unwrap(result) == oct(x)
-
- def test_hex(self):
- x = 0x12345
- f1 = wrapint(self.space, x)
- result = self.space.hex(f1)
- assert self.space.unwrap(result) == hex(x)
-
-
-class AppTestSmallInt(AppTestInt):
- spaceconfig = {"objspace.std.optimized_int_add" : True,
- "objspace.std.withsmallint" : True}
More information about the pypy-commit
mailing list