[pypy-commit] pypy numpy-refactor: make call2 work

fijal noreply at buildbot.pypy.org
Thu Aug 30 14:01:13 CEST 2012


Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: numpy-refactor
Changeset: r56931:802976e5ad01
Date: 2012-08-30 14:00 +0200
http://bitbucket.org/pypy/pypy/changeset/802976e5ad01/

Log:	make call2 work

diff --git a/pypy/module/micronumpy/arrayimpl/concrete.py b/pypy/module/micronumpy/arrayimpl/concrete.py
--- a/pypy/module/micronumpy/arrayimpl/concrete.py
+++ b/pypy/module/micronumpy/arrayimpl/concrete.py
@@ -3,15 +3,18 @@
 from pypy.module.micronumpy import support
 
 class ConcreteArrayIterator(base.BaseArrayIterator):
-    def __init__(self, array, dtype):
+    def __init__(self, array):
         self.array = array
         self.offset = 0
-        self.dtype = dtype
-        self.element_size = dtype.get_size()
+        self.dtype = array.dtype
+        self.element_size = array.dtype.get_size()
         self.size = array.size
 
     def setitem(self, elem):
-        self.dtype.setitem(self.array.storage, self.offset, elem)
+        self.dtype.setitem(self.array, self.offset, elem)
+
+    def getitem(self):
+        return self.dtype.getitem(self.array, self.offset)
 
     def next(self):
         self.offset += self.element_size
@@ -42,9 +45,10 @@
         self.storage = dtype.itemtype.malloc(self.size)
         self.strides, self.backstrides = calc_strides(shape, dtype, order)
         self.order = order
+        self.dtype = dtype
 
     def get_shape(self):
         return self.shape
 
-    def create_iter(self, dtype):
-        return ConcreteArrayIterator(self, dtype)
+    def create_iter(self):
+        return ConcreteArrayIterator(self)
diff --git a/pypy/module/micronumpy/interp_dtype.py b/pypy/module/micronumpy/interp_dtype.py
--- a/pypy/module/micronumpy/interp_dtype.py
+++ b/pypy/module/micronumpy/interp_dtype.py
@@ -49,8 +49,8 @@
     def getitem_bool(self, arr, i):
         return self.itemtype.read_bool(arr, i, 0)
 
-    def setitem(self, storage, i, box):
-        self.itemtype.store(storage, i, 0, box)
+    def setitem(self, arr, i, box):
+        self.itemtype.store(arr, i, 0, box)
 
     def fill(self, storage, box, start, stop):
         self.itemtype.fill(storage, self.get_size(), box, start, stop, 0)
diff --git a/pypy/module/micronumpy/interp_numarray.py b/pypy/module/micronumpy/interp_numarray.py
--- a/pypy/module/micronumpy/interp_numarray.py
+++ b/pypy/module/micronumpy/interp_numarray.py
@@ -41,7 +41,7 @@
         return self.dtype
 
     def create_iter(self):
-        return self.implementation.create_iter(self.dtype)
+        return self.implementation.create_iter()
 
     def is_scalar(self):
         return self.implementation.is_scalar
diff --git a/pypy/module/micronumpy/loop.py b/pypy/module/micronumpy/loop.py
--- a/pypy/module/micronumpy/loop.py
+++ b/pypy/module/micronumpy/loop.py
@@ -8,86 +8,90 @@
     right_iter = w_rhs.create_iter()
     out_iter = out.create_iter()
     while not out_iter.done():
-        #left_iter.getitem()
+        w_left = left_iter.getitem().convert_to(calc_dtype)
+        w_right = right_iter.getitem().convert_to(calc_dtype)
+        out_iter.setitem(func(calc_dtype, w_left, w_right).convert_to(
+            res_dtype))
         left_iter.next()
         right_iter.next()
         out_iter.next()
+    return out
 
-from pypy.rlib.jit import JitDriver, hint, unroll_safe, promote
-from pypy.module.micronumpy.interp_iter import ConstantIterator
+# from pypy.rlib.jit import JitDriver, hint, unroll_safe, promote
+# from pypy.module.micronumpy.interp_iter import ConstantIterator
 
-class NumpyEvalFrame(object):
-    _virtualizable2_ = ['iterators[*]', 'final_iter', 'arraylist[*]',
-                        'value', 'identity', 'cur_value']
+# class NumpyEvalFrame(object):
+#     _virtualizable2_ = ['iterators[*]', 'final_iter', 'arraylist[*]',
+#                         'value', 'identity', 'cur_value']
 
-    @unroll_safe
-    def __init__(self, iterators, arrays):
-        self = hint(self, access_directly=True, fresh_virtualizable=True)
-        self.iterators = iterators[:]
-        self.arrays = arrays[:]
-        for i in range(len(self.iterators)):
-            iter = self.iterators[i]
-            if not isinstance(iter, ConstantIterator):
-                self.final_iter = i
-                break
-        else:
-            self.final_iter = -1
-        self.cur_value = None
-        self.identity = None
+#     @unroll_safe
+#     def __init__(self, iterators, arrays):
+#         self = hint(self, access_directly=True, fresh_virtualizable=True)
+#         self.iterators = iterators[:]
+#         self.arrays = arrays[:]
+#         for i in range(len(self.iterators)):
+#             iter = self.iterators[i]
+#             if not isinstance(iter, ConstantIterator):
+#                 self.final_iter = i
+#                 break
+#         else:
+#             self.final_iter = -1
+#         self.cur_value = None
+#         self.identity = None
 
-    def done(self):
-        final_iter = promote(self.final_iter)
-        if final_iter < 0:
-            assert False
-        return self.iterators[final_iter].done()
+#     def done(self):
+#         final_iter = promote(self.final_iter)
+#         if final_iter < 0:
+#             assert False
+#         return self.iterators[final_iter].done()
 
-    @unroll_safe
-    def next(self, shapelen):
-        for i in range(len(self.iterators)):
-            self.iterators[i] = self.iterators[i].next(shapelen)
+#     @unroll_safe
+#     def next(self, shapelen):
+#         for i in range(len(self.iterators)):
+#             self.iterators[i] = self.iterators[i].next(shapelen)
 
-    @unroll_safe
-    def next_from_second(self, shapelen):
-        """ Don't increase the first iterator
-        """
-        for i in range(1, len(self.iterators)):
-            self.iterators[i] = self.iterators[i].next(shapelen)
+#     @unroll_safe
+#     def next_from_second(self, shapelen):
+#         """ Don't increase the first iterator
+#         """
+#         for i in range(1, len(self.iterators)):
+#             self.iterators[i] = self.iterators[i].next(shapelen)
 
-    def next_first(self, shapelen):
-        self.iterators[0] = self.iterators[0].next(shapelen)
+#     def next_first(self, shapelen):
+#         self.iterators[0] = self.iterators[0].next(shapelen)
 
-    def get_final_iter(self):
-        final_iter = promote(self.final_iter)
-        if final_iter < 0:
-            assert False
-        return self.iterators[final_iter]
+#     def get_final_iter(self):
+#         final_iter = promote(self.final_iter)
+#         if final_iter < 0:
+#             assert False
+#         return self.iterators[final_iter]
 
-def get_printable_location(shapelen, sig):
-    return 'numpy ' + sig.debug_repr() + ' [%d dims]' % (shapelen,)
+# def get_printable_location(shapelen, sig):
+#     return 'numpy ' + sig.debug_repr() + ' [%d dims]' % (shapelen,)
 
-numpy_driver = JitDriver(
-    greens=['shapelen', 'sig'],
-    virtualizables=['frame'],
-    reds=['frame', 'arr'],
-    get_printable_location=get_printable_location,
-    name='numpy',
-)
+# numpy_driver = JitDriver(
+#     greens=['shapelen', 'sig'],
+#     virtualizables=['frame'],
+#     reds=['frame', 'arr'],
+#     get_printable_location=get_printable_location,
+#     name='numpy',
+# )
 
-class ComputationDone(Exception):
-    def __init__(self, value):
-        self.value = value
+# class ComputationDone(Exception):
+#     def __init__(self, value):
+#         self.value = value
 
-def compute(arr):
-    sig = arr.find_sig()
-    shapelen = len(arr.shape)
-    frame = sig.create_frame(arr)
-    try:
-        while not frame.done():
-            numpy_driver.jit_merge_point(sig=sig,
-                                         shapelen=shapelen,
-                                         frame=frame, arr=arr)
-            sig.eval(frame, arr)
-            frame.next(shapelen)
-        return frame.cur_value
-    except ComputationDone, e:
-        return e.value
+# def compute(arr):
+#     sig = arr.find_sig()
+#     shapelen = len(arr.shape)
+#     frame = sig.create_frame(arr)
+#     try:
+#         while not frame.done():
+#             numpy_driver.jit_merge_point(sig=sig,
+#                                          shapelen=shapelen,
+#                                          frame=frame, arr=arr)
+#             sig.eval(frame, arr)
+#             frame.next(shapelen)
+#         return frame.cur_value
+#     except ComputationDone, e:
+#         return e.value
diff --git a/pypy/module/micronumpy/types.py b/pypy/module/micronumpy/types.py
--- a/pypy/module/micronumpy/types.py
+++ b/pypy/module/micronumpy/types.py
@@ -125,8 +125,8 @@
     def _write(self, storage, i, offset, value):
         raw_storage_setitem(storage, i + offset, value)
 
-    def store(self, storage, i, offset, box):
-        self._write(storage, i, offset, self.unbox(box))
+    def store(self, arr, i, offset, box):
+        self._write(arr.storage, i, offset, self.unbox(box))
 
     def fill(self, storage, width, box, start, stop, offset):
         value = self.unbox(box)
@@ -956,10 +956,10 @@
         return interp_boxes.W_VoidBox(arr, 0, arr.dtype)
 
     @jit.unroll_safe
-    def store(self, storage, i, ofs, box):
+    def store(self, arr, i, ofs, box):
         assert isinstance(box, interp_boxes.W_VoidBox)
         for k in range(self.get_element_size()):
-            storage[k + i] = box.arr.storage[k + box.ofs]
+            arr.storage[k + i] = box.arr.storage[k + box.ofs]
 
     @jit.unroll_safe
     def str_format(self, box):


More information about the pypy-commit mailing list