Philip Jenvey avatar Philip Jenvey committed c0958cb Merge

merge default

Comments (0)

Files changed (30)

lib_pypy/_ctypes/structure.py

             return
         if '_fields_' not in self.__dict__:
             self._fields_ = []
-            self._names = []
             _set_shape(self, [], self._is_union)
 
     __setattr__ = struct_setattr

lib_pypy/ctypes_config_cache/dumpcache.py

-import os
+import sys, os
 from ctypes_configure import dumpcache
-from rpython.jit.backend import detect_cpu
 
 def dumpcache2(basename, config):
-    model = detect_cpu.autodetect_main_model_and_size()
-    filename = '_%s_%s_.py' % (basename, model)
+    size = 32 if sys.maxint <= 2**32 else 64
+    filename = '_%s_%s_.py' % (basename, size)
     dumpcache.dumpcache(__file__, filename, config)
     #
     filename = os.path.join(os.path.dirname(__file__),
                             '_%s_cache.py' % (basename,))
     g = open(filename, 'w')
     print >> g, '''\
-try:
-    from __pypy__ import cpumodel
-except ImportError:
-    from rpython.jit.backend import detect_cpu
-    cpumodel = detect_cpu.autodetect_main_model_and_size()
+import sys
+_size = 32 if sys.maxint <= 2**32 else 64
 # XXX relative import, should be removed together with
 # XXX the relative imports done e.g. by lib_pypy/pypy_test/test_hashlib
-mod = __import__("_%s_%%s_" %% (cpumodel,),
-                 globals(), locals(), ["*"], level=1)
-globals().update(mod.__dict__)\
+_mod = __import__("_%s_%%s_" %% (_size,),
+                  globals(), locals(), ["*"], level=1)
+globals().update(_mod.__dict__)\
 ''' % (basename,)
     g.close()

lib_pypy/ctypes_config_cache/rebuild.py

         sys.path[:] = path
 
 def try_rebuild():
-    from rpython.jit.backend import detect_cpu
-    model = detect_cpu.autodetect_main_model_and_size()
-    # remove the files '_*_model_.py'
+    size = 32 if sys.maxint <= 2**32 else 64
+    # remove the files '_*_size_.py'
     left = {}
     for p in os.listdir(_dirpath):
-        if p.startswith('_') and (p.endswith('_%s_.py' % model) or
-                                  p.endswith('_%s_.pyc' % model)):
+        if p.startswith('_') and (p.endswith('_%s_.py' % size) or
+                                  p.endswith('_%s_.pyc' % size)):
             os.unlink(os.path.join(_dirpath, p))
         elif p.startswith('_') and (p.endswith('_.py') or
                                     p.endswith('_.pyc')):

pypy/config/pypyoption.py

     '_multiprocessing': [('objspace.usemodules.rctime', True),
                          ('objspace.usemodules.thread', True)],
     'cpyext': [('objspace.usemodules.array', True)],
+    'cppyy': [('objspace.usemodules.cpyext', True)],
     }
 module_suggests = {
     # the reason you want _rawffi is for ctypes, which

pypy/doc/release-2.0.0.rst

+============================
+PyPy 2.0 - Einstein Sandwich
+============================
+
+We're pleased to announce PyPy 2.0. This is a stable release that brings
+a swath of bugfixes, small performance improvements and compatibility fixes.
+
+You can download the PyPy 2.0 release here:
+
+    http://pypy.org/download.html
+
+The two biggest changes since PyPy 1.9 are:
+
+* stackless is now supported including greenlets, which means eventlet
+  and gevent should work (but read below about gevent)
+
+* PyPy now contains release 0.6 of `cffi`_ as a builtin module, which
+  is preferred way of calling C from Python that works well on PyPy
+
+.. _`cffi`: http://cffi.readthedocs.org
+
+What is PyPy?
+=============
+
+PyPy is a very compliant Python interpreter, almost a drop-in replacement for
+CPython 2.7. It's fast (`pypy 2.0 and cpython 2.7.3`_ performance comparison)
+due to its integrated tracing JIT compiler.
+
+This release supports x86 machines running Linux 32/64, Mac OS X 64 or
+Windows 32.  Windows 64 work is still stalling, we would welcome a volunteer
+to handle that. ARM support is on the way and we're expecting to release
+an alpha ARM version shortly.
+
+.. _`pypy 2.0 and cpython 2.7.3`: http://speed.pypy.org
+
+Highlights
+==========
+
+* Stackless including greenlets should work. For gevent, you need to check
+  out `pypycore`_ and use the `pypy-hacks`_ branch of gevent.
+
+* cffi is now a module included with PyPy.  (`cffi`_ also exists for
+  CPython; the two versions should be fully compatible.)  It is the
+  preferred way of calling C from Python that works on PyPy.
+
+* Callbacks from C are now JITted, which means XML parsing is much faster.
+
+* A lot of speed improvements in various language corners, most of them small,
+  but speeding up some particular corners a lot.
+
+* The JIT was refactored to emit machine code which manipulates a "frame"
+  that lives on the heap rather than on the stack.  This is what makes
+  Stackless work, and it could bring another future speed-up (not done yet).
+
+* A lot of stability issues fixed.
+
+.. _`pypycore`: https://github.com/gevent-on-pypy/pypycore/
+.. _`pypy-hacks`: https://github.com/schmir/gevent/tree/pypy-hacks
+
+Cheers,
+fijal, arigo and the PyPy team

pypy/doc/whatsnew-head.rst

 .. this is a revision shortly after release-2.0
 .. startrev: a13c07067613
 
-

pypy/goal/getnightly.py

 
 if sys.platform.startswith('linux'):
     arch = 'linux'
+    cmd = 'wget "%s"'
+    tar = "tar -x -v --wildcards --strip-components=2 -f %s '*/bin/pypy'"
+if sys.platform.startswith('darwin'):
+    arch = 'osx'
+    cmd = 'curl -O "%s"'
+    tar = "tar -x -v --strip-components=2 -f %s '*/bin/pypy'"
 else:
-    print 'Cannot determine the platform, please update this scrip'
+    print 'Cannot determine the platform, please update this script'
     sys.exit(1)
 
 if sys.maxint == 2**63 - 1:
 tmp = py.path.local.mkdtemp()
 mydir = tmp.chdir()
 print 'Downloading pypy to', tmp
-if os.system('wget "%s"' % url) != 0:
+if os.system(cmd % url) != 0:
     sys.exit(1)
 
 print 'Extracting pypy binary'
 mydir.chdir()
-os.system("tar -x -v --wildcards --strip-components=2 -f %s '*/bin/pypy'" % tmp.join(filename))
-
+os.system(tar % tmp.join(filename))

pypy/module/__pypy__/__init__.py

         PYC_MAGIC = get_pyc_magic(self.space)
         self.extra_interpdef('PYC_MAGIC', 'space.wrap(%d)' % PYC_MAGIC)
         #
-        from rpython.jit.backend import detect_cpu
-        model = detect_cpu.autodetect_main_model_and_size()
-        self.extra_interpdef('cpumodel', 'space.wrap(%r)' % model)
+        try:
+            from rpython.jit.backend import detect_cpu
+            model = detect_cpu.autodetect()
+            self.extra_interpdef('cpumodel', 'space.wrap(%r)' % model)
+        except Exception:
+            if self.space.config.translation.jit:
+                raise
+            else:
+                pass   # ok fine to ignore in this case
+        #
+        if self.space.config.translation.jit:
+            features = detect_cpu.getcpufeatures(model)
+            self.extra_interpdef('jit_backend_features',
+                                    'space.wrap(%r)' % features)

pypy/module/__pypy__/test/test_special.py

         assert list_strategy(l) == "empty"
         o = 5
         raises(TypeError, list_strategy, 5)
+
+
+class AppTestJitFeatures(object):
+    spaceconfig = {"translation.jit": True}
+
+    def test_jit_backend_features(self):
+        from __pypy__ import jit_backend_features
+        supported_types = jit_backend_features
+        assert isinstance(supported_types, list)
+        for x in supported_types:
+            assert x in ['floats', 'singlefloats', 'longlong']

pypy/module/_cffi_backend/misc.py

             return rffi.cast(lltype.Unsigned, rffi.cast(TPP, target)[0])
     raise NotImplementedError("bad integer size")
 
+@specialize.arg(0)
+def _read_raw_float_data_tp(TPP, target):
+    # in its own function: FLOAT may make the whole function jit-opaque
+    return rffi.cast(lltype.Float, rffi.cast(TPP, target)[0])
+
 def read_raw_float_data(target, size):
     for TP, TPP in _prim_float_types:
         if size == rffi.sizeof(TP):
-            return rffi.cast(lltype.Float, rffi.cast(TPP, target)[0])
+            return _read_raw_float_data_tp(TPP, target)
     raise NotImplementedError("bad float size")
 
 def read_raw_longdouble_data(target):
     raise NotImplementedError("bad integer size")
 
 
+@specialize.arg(0, 1)
+def _write_raw_float_data_tp(TP, TPP, target, source):
+    # in its own function: FLOAT may make the whole function jit-opaque
+    rffi.cast(TPP, target)[0] = rffi.cast(TP, source)
+
 def write_raw_float_data(target, source, size):
     for TP, TPP in _prim_float_types:
         if size == rffi.sizeof(TP):
-            rffi.cast(TPP, target)[0] = rffi.cast(TP, source)
+            _write_raw_float_data_tp(TP, TPP, target, source)
             return
     raise NotImplementedError("bad float size")
 
 
 # ____________________________________________________________
 
+@specialize.arg(0)
+def _raw_memcopy_tp(TPP, source, dest):
+    # in its own function: LONGLONG may make the whole function jit-opaque
+    rffi.cast(TPP, dest)[0] = rffi.cast(TPP, source)[0]
+
 def _raw_memcopy(source, dest, size):
     if jit.isconstant(size):
         # for the JIT: first handle the case where 'size' is known to be
         # a constant equal to 1, 2, 4, 8
         for TP, TPP in _prim_unsigned_types:
             if size == rffi.sizeof(TP):
-                rffi.cast(TPP, dest)[0] = rffi.cast(TPP, source)[0]
+                _raw_memcopy_tp(TPP, source, dest)
                 return
     _raw_memcopy_opaque(source, dest, size)
 
         llmemory.cast_ptr_to_adr(dest) + zero,
         size * llmemory.sizeof(lltype.Char))
 
+@specialize.arg(0, 1)
+def _raw_memclear_tp(TP, TPP, dest):
+    # in its own function: LONGLONG may make the whole function jit-opaque
+    rffi.cast(TPP, dest)[0] = rffi.cast(TP, 0)
+
 def _raw_memclear(dest, size):
     # for now, only supports the cases of size = 1, 2, 4, 8
     for TP, TPP in _prim_unsigned_types:
         if size == rffi.sizeof(TP):
-            rffi.cast(TPP, dest)[0] = rffi.cast(TP, 0)
+            _raw_memclear_tp(TP, TPP, dest)
             return
     raise NotImplementedError("bad clear size")

pypy/module/_io/__init__.py

 
     def shutdown(self, space):
         # at shutdown, flush all open streams.  Ignore I/O errors.
-        from pypy.module._io.interp_iobase import get_autoflushher
-        get_autoflushher(space).flush_all(space)
+        from pypy.module._io.interp_iobase import get_autoflusher
+        get_autoflusher(space).flush_all(space)

pypy/module/_io/interp_iobase.py

         self.w_dict = space.newdict()
         self.__IOBase_closed = False
         self.streamholder = None # needed by AutoFlusher
-        get_autoflushher(space).add(self)
+        get_autoflusher(space).add(self)
 
     def getdict(self, space):
         return self.w_dict
             space.call_method(self, "flush")
         finally:
             self.__IOBase_closed = True
-            get_autoflushher(space).remove(self)
+            get_autoflusher(space).remove(self)
 
     def _dealloc_warn_w(self, space, w_source):
         """Called when the io is implicitly closed via the deconstructor"""
                 else:
                     streamholder.autoflush(space)
 
-def get_autoflushher(space):
+def get_autoflusher(space):
     return space.fromcache(AutoFlusher)

pypy/module/_random/interp_random.py

             if space.isinstance_w(w_n, space.w_int):
                 w_n = space.abs(w_n)
             else:
-                # XXX not perfectly like CPython
-                w_n = space.abs(space.hash(w_n))
+                n = space.hash_w(w_n)
+                w_n = space.wrap(r_uint(n))
         key = []
         w_one = space.newint(1)
         w_two = space.newint(2)

pypy/module/_random/test/test_random.py

         rnd1.setstate((-1, ) * 624 + (0, ))
 
     def test_seed(self):
-        import _random
+        import _random, sys
         rnd = _random.Random()
         rnd.seed()
         different_nums = []
+        mask = sys.maxint * 2 + 1
         for obj in ["spam and eggs", 3.14, 1+2j, 'a', tuple('abc')]:
             nums = []
-            for o in [obj, hash(obj), -hash(obj)]:
+            for o in [obj, hash(obj) & mask, -(hash(obj) & mask)]:
                 rnd.seed(o)
                 nums.append([rnd.random() for i in range(100)])
             n1 = nums[0]

pypy/module/pypyjit/test_pypy_c/test_array.py

         """)
 
     def test_array_of_floats(self):
+        try:
+            from __pypy__ import jit_backend_features
+            if 'singlefloats' not in jit_backend_features:
+                py.test.skip("test requres singlefloats support from the JIT backend")
+        except ImportError:
+            pass
         def main():
             from array import array
             img = array('f', [21.5]*1000)

pypy/module/test_lib_pypy/ctypes_tests/test_structures.py

         pt = POINT(y=2, x=1)
         assert (pt.x, pt.y) == (1, 2)
 
+    def test_subclass_initializer(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_int), ("y", c_int)]
+
+        class POSITION(POINT):
+            # A subclass without _fields_
+            pass
+        pos = POSITION(1, 2)
+        assert (pos.x, pos.y) == (1, 2)
+        
+
     def test_invalid_field_types(self):
         class POINT(Structure):
             pass
         raises(AttributeError, setattr, X, "_fields_", [])
         Y.__fields__ = []
 
+
 class TestPatologicalCases(BaseCTypesTestChecker):
     def test_structure_overloading_getattr(self):
         class X(Structure):

pypy/objspace/std/stringobject.py

 def str_title__String(space, w_self):
     input = w_self._value
     builder = StringBuilder(len(input))
-    prev_letter=' '
+    prev_letter = ' '
 
     for pos in range(len(input)):
         ch = input[pos]
             space.wrap("rjust() argument 2 must be a single character"))
 
     d = u_arg - len(u_self)
-    if d>0:
+    if d > 0:
         fillchar = fillchar[0]    # annotator hint: it's a single character
         u_self = d * fillchar + u_self
 
             space.wrap("ljust() argument 2 must be a single character"))
 
     d = u_arg - len(u_self)
-    if d>0:
+    if d > 0:
         fillchar = fillchar[0]    # annotator hint: it's a single character
         u_self += d * fillchar
 
 
 
 def str_index__String_String_ANY_ANY(space, w_self, w_sub, w_start, w_end):
-    (self, start, end) =  _convert_idx_params(space, w_self, w_start, w_end)
+    (self, start, end) = _convert_idx_params(space, w_self, w_start, w_end)
     res = self.find(w_sub._value, start, end)
     if res < 0:
         raise OperationError(space.w_ValueError,
 
 
 def str_rindex__String_String_ANY_ANY(space, w_self, w_sub, w_start, w_end):
-    (self, start, end) =  _convert_idx_params(space, w_self, w_start, w_end)
+    (self, start, end) = _convert_idx_params(space, w_self, w_start, w_end)
     res = self.rfind(w_sub._value, start, end)
     if res < 0:
         raise OperationError(space.w_ValueError,
         while 1:
             #no sophisticated linebreak support now, '\r' just for passing adapted CPython test
             if u_token[offset-1] == "\n" or u_token[offset-1] == "\r":
-                break;
+                break
             distance += 1
             offset -= 1
             if offset == 0:
         #print '<offset:%d distance:%d tabsize:%d token:%s>' % (offset, distance, u_tabsize, u_token)
         distance = (u_tabsize-distance) % u_tabsize
         if distance == 0:
-            distance=u_tabsize
+            distance = u_tabsize
 
     return distance
 
 
         for token in split:
             #print  "%d#%d -%s-" % (_tabindent(oldtoken,u_tabsize), u_tabsize, token)
-            u_expanded += " " * _tabindent(oldtoken,u_tabsize) + token
+            u_expanded += " " * _tabindent(oldtoken, u_tabsize) + token
             oldtoken = token
 
     return wrapstr(space, u_expanded)
 
 
 def str_splitlines__String_ANY(space, w_self, w_keepends):
-    u_keepends  = space.int_w(w_keepends)  # truth value, but type checked
+    u_keepends = space.int_w(w_keepends)  # truth value, but type checked
     data = w_self._value
     selflen = len(data)
     strs_w = []
     return space.wrap(ord(str[ival]))
 
 def getitem__String_Slice(space, w_str, w_slice):
-    w = space.wrap
     s = w_str._value
     length = len(s)
     start, stop, step, sl = w_slice.indices4(space, length)

pypy/objspace/std/test/test_listobject.py

     def test_setitem_slice_performance(self):
         # because of a complexity bug, this used to take forever on a
         # translated pypy.  On CPython2.6 -A, it takes around 5 seconds.
+        import platform
+        if platform.machine().startswith('arm'):
+            skip("consumes too much memory for most ARM machines")
         if self.runappdirect:
             count = 16*1024*1024
         else:
             'interpreter/pyparser/test',
             'interpreter/test',
             'interpreter/test2',
+            'module/test_lib_pypy',
             'objspace/std/test',
     ],
 }

pypy/tool/jitlogparser/test/test_parser.py

                                            parse_log_counts)
 from pypy.tool.jitlogparser.storage import LoopStorage
 import py, sys
-from rpython.jit.backend.detect_cpu import autodetect_main_model
+from rpython.jit.backend.detect_cpu import autodetect
 
 def parse(input, **kwds):
     return SimpleParser.parse_from_input(input, **kwds)
     assert chunk.bytecode_name.startswith('StrLiteralSearch')
 
 def test_parsing_assembler():
-    if not autodetect_main_model() == 'x86':
+    if not autodetect().startswith('x86'):
         py.test.skip('x86 only test')
     backend_dump = "554889E5534154415541564157488DA500000000488B042590C5540148C7042590C554010000000048898570FFFFFF488B042598C5540148C7042598C554010000000048898568FFFFFF488B0425A0C5540148C70425A0C554010000000048898560FFFFFF488B0425A8C5540148C70425A8C554010000000048898558FFFFFF4C8B3C2550525B0149BB30E06C96FC7F00004D8B334983C60149BB30E06C96FC7F00004D89334981FF102700000F8D000000004983C7014C8B342580F76A024983EE014C89342580F76A024983FE000F8C00000000E9AEFFFFFF488B042588F76A024829E0483B042580EC3C01760D49BB05F30894FC7F000041FFD3554889E5534154415541564157488DA550FFFFFF4889BD70FFFFFF4889B568FFFFFF48899560FFFFFF48898D58FFFFFF4D89C7E954FFFFFF49BB00F00894FC7F000041FFD34440484C3D030300000049BB00F00894FC7F000041FFD34440484C3D070304000000"
     dump_start = 0x7f3b0b2e63d5
     assert 'jmp' in loop.operations[-1].asm
 
 def test_parsing_arm_assembler():
-    if not autodetect_main_model() == 'arm':
+    if not autodetect().startswith('arm'):
         py.test.skip('ARM only test')
     backend_dump = "F04F2DE9108B2DED2CD04DE20DB0A0E17CC302E3DFC040E300409CE5085084E2086000E3006084E504B084E500508CE508D04BE20000A0E10000A0E1B0A10DE30EA044E300A09AE501A08AE2B0910DE30E9044E300A089E5C0910DE30E9044E3009099E5019089E2C0A10DE30EA044E300908AE5010050E1700020E124A092E500C08AE00C90DCE5288000E3090058E10180A0030080A013297000E3090057E10170A0030070A013077088E1200059E30180A0030080A013099049E2050059E30190A0330090A023099088E1000059E30190A0130090A003099087E1000059E3700020E1010080E204200BE5D0210DE30E2044E3002092E5012082E2D0910DE30E9044E3002089E5010050E1700020E100C08AE00C90DCE5282000E3090052E10120A0030020A013297000E3090057E10170A0030070A013077082E1200059E30120A0030020A013099049E2050059E30190A0330090A023099082E1000059E30190A0130090A003099087E1000059E3700020E1010080E20D005BE10FF0A0A1700020E1D8FFFFEA68C100E301C04BE33CFF2FE105010803560000000000000068C100E301C04BE33CFF2FE105010803570000000000000068C100E301C04BE33CFF2FE105014003580000000000000068C100E301C04BE33CFF2FE1050140035900000000000000"
     dump_start = int(-0x4ffee930)
 
 
 def test_import_log():
-    if not autodetect_main_model() == 'x86':
+    if not autodetect().startswith('x86'):
         py.test.skip('x86 only test')
     _, loops = import_log(str(py.path.local(__file__).join('..',
                                                            'logtest.log')))
     assert 'jge' in loops[0].operations[3].asm
 
 def test_import_log_2():
-    if not autodetect_main_model() == 'x86':
+    if not autodetect().startswith('x86'):
         py.test.skip('x86 only test')
     _, loops = import_log(str(py.path.local(__file__).join('..',
                                                            'logtest2.log')))

rpython/jit/backend/arm/test/test_fficall.py

+import py
+from rpython.jit.metainterp.test import test_fficall
+from rpython.jit.backend.arm.test.support import JitARMMixin
+
+class TestFfiCall(JitARMMixin, test_fficall.FfiCallTests):
+    # for the individual tests see
+    # ====> ../../../metainterp/test/test_fficall.py
+
+    def _add_libffi_types_to_ll2types_maybe(self):
+        # this is needed by test_guard_not_forced_fails, because it produces a
+        # loop which reads the value of types.* in a variable, then a guard
+        # fail and we switch to blackhole: the problem is that at this point
+        # the blackhole interp has a real integer, but it needs to convert it
+        # back to a lltype pointer (which is handled by ll2ctypes, deeply in
+        # the logic). The workaround is to teach ll2ctypes in advance which
+        # are the addresses of the various types.* structures.
+        # Try to comment this code out and run the test to see how it fails :)
+        from rpython.rtyper.lltypesystem import rffi, lltype, ll2ctypes
+        from rpython.rlib.jit_libffi import types
+        for key, value in types.__dict__.iteritems():
+            if isinstance(value, lltype._ptr):
+                addr = rffi.cast(lltype.Signed, value)
+                ll2ctypes._int2obj[addr] = value

rpython/jit/backend/detect_cpu.py

     pass
 
 
-def detect_main_model_and_size_from_platform():
+MODEL_X86         = 'x86'
+MODEL_X86_NO_SSE2 = 'x86-without-sse2'
+MODEL_X86_64      = 'x86-64'
+MODEL_ARM         = 'arm'
+MODEL_PPC_64      = 'ppc-64'
+# don't use '_' in the model strings; they are replaced by '-'
+
+
+def detect_model_from_c_compiler():
     # based on http://sourceforge.net/p/predef/wiki/Architectures/
     mapping = {
-            ('x86', '64'): [
-                '__amd64__', '__amd64', '__x86_64__', '__x86_64',  # AMD64
-                ],
-            ('arm', '32'): ['__arm__', '__thumb__'],
-            ('x86', '32'): ['i386', '__i386', '__i386__', '__i686__',],
-            ('ppc', '64'): ['__powerpc64__'],
+        MODEL_X86_64: ['__amd64__', '__amd64', '__x86_64__', '__x86_64'],
+        MODEL_ARM:    ['__arm__', '__thumb__'],
+        MODEL_X86:    ['i386', '__i386', '__i386__', '__i686__'],
+        MODEL_PPC_64: ['__powerpc64__'],
     }
     for k, v in mapping.iteritems():
         for macro in v:
             if not getdefined(macro, ''):
                 continue
-            return '_'.join(k)
+            return k
     raise ProcessorAutodetectError, "Cannot detect processor using compiler macros"
 
 
-def detect_main_model_from_platform():
-    return detect_main_model_and_size_from_platform()[0]
-
-
-def autodetect_main_model():
-    if not is_host_build():
-        return detect_main_model_from_platform()
+def detect_model_from_host_platform():
     mach = None
     try:
         import platform
     if not mach:
         platform = sys.platform.lower()
         if platform.startswith('win'):   # assume an Intel Windows
-            return 'x86'
+            return MODEL_X86
         # assume we have 'uname'
         mach = os.popen('uname -m', 'r').read().strip()
         if not mach:
             raise ProcessorAutodetectError, "cannot run 'uname -m'"
-    try:
-        return {'i386': 'x86',
-                'i486': 'x86',
-                'i586': 'x86',
-                'i686': 'x86',
-                'i86pc': 'x86',    # Solaris/Intel
-                'x86':   'x86',    # Apple
-                'Power Macintosh': 'ppc',
-                'x86_64': 'x86',
-                'amd64': 'x86',    # freebsd
-                'AMD64': 'x86',    # win64
-                'armv7l': 'arm',
-                'armv6l': 'arm',
-                }[mach]
-    except KeyError:
-        return mach
+    #
+    result ={'i386': MODEL_X86,
+            'i486': MODEL_X86,
+            'i586': MODEL_X86,
+            'i686': MODEL_X86,
+            'i86pc': MODEL_X86,    # Solaris/Intel
+            'x86': MODEL_X86,      # Apple
+            'Power Macintosh': MODEL_PPC_64,
+            'x86_64': MODEL_X86,
+            'amd64': MODEL_X86,    # freebsd
+            'AMD64': MODEL_X86,    # win64
+            'armv7l': MODEL_ARM,
+            'armv6l': MODEL_ARM,
+            }[mach]
+    #
+    if result.startswith('x86'):
+        if sys.maxint == 2**63-1:
+            result = MODEL_X86_64
+        else:
+            assert sys.maxint == 2**31-1
+            from rpython.jit.backend.x86.detect_sse2 import detect_sse2
+            if detect_sse2():
+                result = MODEL_X86
+            else:
+                result = MODEL_X86_NO_SSE2
+    #
+    if result.startswith('arm'):
+        from rpython.jit.backend.arm.detect import detect_float
+        assert detect_float(), 'the JIT-compiler requires a vfp unit'
+    #
+    return result
 
-def autodetect_main_model_and_size():
-    if not is_host_build():
-        return detect_main_model_and_size_from_platform()
-    model = autodetect_main_model()
-    if sys.maxint == 2**31-1:
-        model += '_32'
-    elif sys.maxint == 2**63-1:
-        model += '_64'
-    else:
-        raise AssertionError, "bad value for sys.maxint"
-    return model
 
 def autodetect():
-    model = autodetect_main_model()
-    if sys.maxint == 2**63-1:
-        model += '_64'
+    if not is_host_build():
+        return detect_model_from_c_compiler()
     else:
-        assert sys.maxint == 2**31-1
-        if model == 'x86':
-            from rpython.jit.backend.x86.detect_sse2 import detect_sse2
-            if not detect_sse2():
-                model = 'x86-without-sse2'
-    if model.startswith('arm'):
-        from rpython.jit.backend.arm.detect import detect_hardfloat, detect_float
-        assert detect_float(), 'the JIT-compiler requires a vfp unit'
-    return model
+        return detect_model_from_host_platform()
+
 
 def getcpuclassname(backend_name="auto"):
     if backend_name == "auto":
         backend_name = autodetect()
-    if backend_name == 'x86':
+    backend_name = backend_name.replace('_', '-')
+    if backend_name == MODEL_X86:
         return "rpython.jit.backend.x86.runner", "CPU"
-    elif backend_name == 'x86-without-sse2':
+    elif backend_name == MODEL_X86_NO_SSE2:
         return "rpython.jit.backend.x86.runner", "CPU386_NO_SSE2"
-    elif backend_name == 'x86_64':
+    elif backend_name == MODEL_X86_64:
         return "rpython.jit.backend.x86.runner", "CPU_X86_64"
-    elif backend_name == 'cli':
-        return "rpython.jit.backend.cli.runner", "CliCPU"
-    elif backend_name.startswith('arm'):
+    #elif backend_name == 'cli':
+    #    return "rpython.jit.backend.cli.runner", "CliCPU"
+    elif backend_name == MODEL_ARM:
         return "rpython.jit.backend.arm.runner", "CPU_ARM"
     else:
         raise ProcessorAutodetectError, (
     mod = __import__(modname, {}, {}, clsname)
     return getattr(mod, clsname)
 
+
+def getcpufeatures(backend_name="auto"):
+    """NOT_RPYTHON"""
+    cpucls = getcpuclass(backend_name)
+    return [attr[len('supports_'):] for attr in dir(cpucls)
+                            if attr.startswith('supports_')
+                                and getattr(cpucls, attr)]
+
 if __name__ == '__main__':
-    print autodetect()
-    print getcpuclassname()
+    if len(sys.argv) > 1:
+        name = sys.argv[1]
+        x = name
+    else:
+        name = 'auto'
+        x = autodetect()
+    x = (x, getcpuclassname(name), getcpufeatures(name))
+    print 'autodetect:     ', x[0]
+    print 'getcpuclassname:', x[1]
+    print 'getcpufeatures: ', x[2]

rpython/jit/backend/test/runner_test.py

 from rpython.jit.codewriter import heaptracker, longlong
 from rpython.rlib import longlong2float
 from rpython.rlib.rarithmetic import intmask, is_valid_int
-from rpython.jit.backend.detect_cpu import autodetect_main_model_and_size
+from rpython.jit.backend.detect_cpu import autodetect
 from rpython.jit.backend.llsupport import jitframe
 
 
                                               looptoken)
         self.cpu.assembler.set_debug(True) # always on untranslated
         assert info.asmlen != 0
-        cpuname = autodetect_main_model_and_size()
+        cpuname = autodetect()
         # XXX we have to check the precise assembler, otherwise
         # we don't quite know if borders are correct
 

rpython/jit/backend/test/test_detect_cpu.py

         assert issubclass(cpu, AbstractCPU)
 
 
-def test_detect_main_model_and_size_from_platform():
-    info = autodetect_main_model_and_size()
-    assert detect_main_model_and_size_from_platform() == info
+def test_detect_model_from_c_compiler():
+    info1 = detect_model_from_host_platform()
+    info2 = detect_model_from_c_compiler()
+    assert info1 == info2
+
+def test_getcpufeatures():
+    features = getcpufeatures()
+    assert isinstance(features, list)
+    for x in features:
+        assert x in ['floats', 'singlefloats', 'longlong']

rpython/jit/backend/tool/viewcode.py

 def machine_code_dump(data, originaddr, backend_name, label_list=None):
     objdump_backend_option = {
         'x86': 'i386',
+        'x86-without-sse2': 'i386',
         'x86_32': 'i386',
         'x86_64': 'x86-64',
+        'x86-64': 'x86-64',
         'i386': 'i386',
+        'arm': 'arm',
         'arm_32': 'arm',
     }
     cmd = find_objdump()

rpython/jit/backend/x86/test/conftest.py

 
 cpu = detect_cpu.autodetect()
 def pytest_runtest_setup(item):
-    if cpu not in ('x86', 'x86_64'):
+    if not cpu.startswith('x86'):
         py.test.skip("x86/x86_64 tests skipped: cpu is %r" % (cpu,))
     if cpu == 'x86_64':
         if os.name == "nt":

rpython/memory/gctransform/transform.py

     def finish_helpers(self, backendopt=True):
         if self.translator is not None:
             self.mixlevelannotator.finish_annotate()
-        self.finished_helpers = True
         if self.translator is not None:
             self.mixlevelannotator.finish_rtype()
             if backendopt:
                 self.mixlevelannotator.backend_optimize()
+        self.finished_helpers = True
         # Make sure that the database also sees all finalizers now.
         # It is likely that the finalizers need special support there
         newgcdependencies = self.ll_finalizers_ptrs

rpython/translator/c/gcc/test/conftest.py

 from rpython.jit.backend import detect_cpu
 cpu = detect_cpu.autodetect()
 def pytest_runtest_setup(item):
-    if cpu not in ('x86', 'x86_64'):
+    if not cpu.startswith('x86'):
         py.test.skip("x86 directory skipped: cpu is %r" % (cpu,))

rpython/translator/goal/translate.py

     else:
         show_help(translateconfig, opt_parser, None, config)
 
+    # print the version of the host
+    # (if it's PyPy, it includes the hg checksum)
+    log.info(sys.version)
+
     # apply the platform settings
     set_platform(config)
 

testrunner/runner.py

                     self.collect_one_testdir(testdirs, reldir,
                                    [self.reltoroot(t) for t in entries
                                     if self.is_test_py_file(t)])
-                    return
+                    break
 
         for p1 in entries:
             if p1.check(dir=1, link=0):
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.