コード例 #1
0
def ll_shrink_array(p, smallerlength):
    from rpython.rtyper.lltypesystem.lloperation import llop
    from rpython.rlib.objectmodel import keepalive_until_here

    if llop.shrink_array(lltype.Bool, p, smallerlength):
        return p  # done by the GC
    # XXX we assume for now that the type of p is GcStruct containing a
    # variable array, with no further pointers anywhere, and exactly one
    # field in the fixed part -- like STR and UNICODE.

    TP = lltype.typeOf(p).TO
    newp = lltype.malloc(TP, smallerlength)

    assert len(TP._names) == 2
    field = getattr(p, TP._names[0])
    setattr(newp, TP._names[0], field)

    ARRAY = getattr(TP, TP._arrayfld)
    offset = llmemory.offsetof(TP, TP._arrayfld) + llmemory.itemoffsetof(ARRAY, 0)
    source_addr = llmemory.cast_ptr_to_adr(p) + offset
    dest_addr = llmemory.cast_ptr_to_adr(newp) + offset
    llmemory.raw_memcopy(source_addr, dest_addr, llmemory.sizeof(ARRAY.OF) * smallerlength)

    keepalive_until_here(p)
    keepalive_until_here(newp)
    return newp
コード例 #2
0
ファイル: gctypelayout.py プロジェクト: Darriall/pypy
    def consider_constant(self, TYPE, value, gc):
        if value is not lltype.top_container(value):
            return
        if value in self.iseen_roots:
            return
        self.iseen_roots[value] = True

        if isinstance(TYPE, lltype.GcOpaqueType):
            self.consider_constant(lltype.typeOf(value.container),
                                   value.container, gc)
            return

        if isinstance(TYPE, (lltype.GcStruct, lltype.GcArray)):
            typeid = self.get_type_id(TYPE)
            hdr = gc.gcheaderbuilder.new_header(value)
            adr = llmemory.cast_ptr_to_adr(hdr)
            gc.init_gc_object_immortal(adr, typeid)
            self.all_prebuilt_gc.append(value)

        # The following collects the addresses of all the fields that have
        # a GC Pointer type, inside the current prebuilt object.  All such
        # fields are potential roots: unless the structure is immutable,
        # they could be changed later to point to GC heap objects.
        adr = llmemory.cast_ptr_to_adr(value._as_ptr())
        if TYPE._gckind == "gc":
            if gc.prebuilt_gc_objects_are_static_roots or gc.DEBUG:
                appendto = self.addresses_of_static_ptrs
            else:
                return
        else:
            appendto = self.addresses_of_static_ptrs_in_nongc
        for a in gc_pointers_inside(value, adr, mutable_only=True):
            appendto.append(a)
コード例 #3
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
 def pin_referenced_from_old(self, collect_func):
     # scenario: an old object points to a pinned one. Check if the pinned
     # object is correctly kept in the nursery and not moved.
     #
     # create old object
     old_ptr = self.malloc(S)
     old_ptr.someInt = 900
     self.stackroots.append(old_ptr)
     assert self.stackroots[0] == old_ptr # validate our assumption
     collect_func() # make it old: move it out of the nursery
     old_ptr = self.stackroots[0]
     assert not self.gc.is_in_nursery(llmemory.cast_ptr_to_adr(old_ptr))
     #
     # create young pinned one and let the old one reference the young one
     pinned_ptr = self.malloc(T)
     pinned_ptr.someInt = 100
     self.write(old_ptr, 'next', pinned_ptr)
     pinned_adr = llmemory.cast_ptr_to_adr(pinned_ptr)
     assert self.gc.pin(pinned_adr)
     assert self.gc.is_in_nursery(pinned_adr)
     assert old_ptr.next.someInt == 100
     assert self.gc.pinned_objects_in_nursery == 1
     #
     # do a collection run and make sure the pinned one didn't move
     collect_func()
     assert old_ptr.next.someInt == pinned_ptr.someInt == 100
     assert llmemory.cast_ptr_to_adr(old_ptr.next) == pinned_adr
     assert self.gc.is_in_nursery(pinned_adr)
コード例 #4
0
ファイル: test_gctypelayout.py プロジェクト: charred/pypy
def test_gc_pointers_inside():
    from rpython.rtyper import rclass
    PT = lltype.Ptr(lltype.GcStruct('T'))
    S1 = lltype.GcStruct('S', ('x', PT), ('y', PT))
    S2 = lltype.GcStruct('S', ('x', PT), ('y', PT),
                         hints={'immutable': True})
    accessor = rclass.FieldListAccessor()
    S3 = lltype.GcStruct('S', ('x', PT), ('y', PT),
                         hints={'immutable_fields': accessor})
    accessor.initialize(S3, {'x': IR_IMMUTABLE, 'y': IR_QUASIIMMUTABLE})
    #
    s1 = lltype.malloc(S1)
    adr = llmemory.cast_ptr_to_adr(s1)
    lst = list(gc_pointers_inside(s1._obj, adr, mutable_only=True))
    expected = [adr + llmemory.offsetof(S1, 'x'),
                adr + llmemory.offsetof(S1, 'y')]
    assert lst == expected or lst == expected[::-1]
    #
    s2 = lltype.malloc(S2)
    adr = llmemory.cast_ptr_to_adr(s2)
    lst = list(gc_pointers_inside(s2._obj, adr, mutable_only=True))
    assert lst == []
    #
    s3 = lltype.malloc(S3)
    adr = llmemory.cast_ptr_to_adr(s3)
    lst = list(gc_pointers_inside(s3._obj, adr, mutable_only=True))
    assert lst == [adr + llmemory.offsetof(S3, 'y')]
コード例 #5
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
    def test_old_objects_pointing_to_pinned_not_exploading(self):
        # scenario: two old object, each pointing twice to a pinned object.
        # The internal 'old_objects_pointing_to_pinned' should contain
        # always two objects.
        # In previous implementation the list exploded (grew with every minor
        # collection), hence this test.
        old1_ptr = self.malloc(S)
        old1_ptr.someInt = 900
        self.stackroots.append(old1_ptr)
        
        old2_ptr = self.malloc(S)
        old2_ptr.someInt = 800
        self.stackroots.append(old2_ptr)
        
        pinned_ptr = self.malloc(T)
        pinned_ptr.someInt = 100
        assert self.gc.pin(llmemory.cast_ptr_to_adr(pinned_ptr))
        
        self.write(old1_ptr, 'next', pinned_ptr)
        self.write(old1_ptr, 'data', pinned_ptr)
        self.write(old2_ptr, 'next', pinned_ptr)
        self.write(old2_ptr, 'data', pinned_ptr)

        self.gc.collect()
        old1_ptr = self.stackroots[0]
        old2_ptr = self.stackroots[1]
        assert not self.gc.is_in_nursery(llmemory.cast_ptr_to_adr(old1_ptr))
        assert not self.gc.is_in_nursery(llmemory.cast_ptr_to_adr(old2_ptr))

        # do multiple rounds to make sure
        for _ in range(10):
            assert self.gc.old_objects_pointing_to_pinned.length() == 2
            self.gc.debug_gc_step()
コード例 #6
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
 def pin_referenced_from_prebuilt(self, collect_func):
     # scenario: a prebuilt object points to a pinned object. Check if the
     # pinned object doesn't move and is still accessible.
     #
     prebuilt_ptr = lltype.malloc(S, immortal=True)
     prebuilt_ptr.someInt = 900
     self.consider_constant(prebuilt_ptr)
     prebuilt_adr = llmemory.cast_ptr_to_adr(prebuilt_ptr)
     collect_func()
     #        
     pinned_ptr = self.malloc(T)
     pinned_ptr.someInt = 100
     self.write(prebuilt_ptr, 'next', pinned_ptr)
     pinned_adr = llmemory.cast_ptr_to_adr(pinned_ptr)
     assert self.gc.pin(pinned_adr)
     #
     # check if everything is as expected
     assert not self.gc.is_in_nursery(prebuilt_adr)
     assert self.gc.is_in_nursery(pinned_adr)
     assert pinned_ptr == prebuilt_ptr.next
     assert pinned_ptr.someInt == 100
     #
     # do a collection and check again
     collect_func()
     assert self.gc.is_in_nursery(pinned_adr)
     assert pinned_ptr == prebuilt_ptr.next
     assert pinned_ptr.someInt == 100
コード例 #7
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
    def test_random(self):
        # scenario: create bunch of objects. randomly pin, unpin, add to
        # stackroots and remove from stackroots.
        import random

        for i in xrange(10**3):
            obj = self.malloc(T)
            obj.someInt = 100
            #
            if random.random() < 0.5:
                self.stackroots.append(obj)
                print("+stack")
            if random.random() < 0.5:
                self.gc.pin(llmemory.cast_ptr_to_adr(obj))
                print("+pin")
            self.gc.debug_gc_step(random.randint(1, 4))
            for o in self.stackroots[:]:
                assert o.someInt == 100
                o_adr = llmemory.cast_ptr_to_adr(o)
                if random.random() < 0.1 and self.gc._is_pinned(o_adr):
                    print("-pin")
                    self.gc.unpin(o_adr)
                if random.random() < 0.1:
                    print("-stack")
                    self.stackroots.remove(o)
コード例 #8
0
ファイル: test_minimarkpage.py プロジェクト: Darriall/pypy
def test_allocate_new_page():
    pagesize = hdrsize + 16
    arenasize = pagesize * 4 - 1
    #
    def checknewpage(page, size_class):
        size = WORD * size_class
        assert (ac._nuninitialized(page, size_class) ==
                    (pagesize - hdrsize) // size)
        assert page.nfree == 0
        page1 = page.freeblock - hdrsize
        assert llmemory.cast_ptr_to_adr(page) == page1
        assert page.nextpage == PAGE_NULL
    #
    ac = ArenaCollection(arenasize, pagesize, 99)
    assert ac.num_uninitialized_pages == 0
    assert ac.total_memory_used == 0
    #
    page = ac.allocate_new_page(5)
    checknewpage(page, 5)
    assert ac.num_uninitialized_pages == 2
    assert ac.current_arena.freepages - pagesize == cast_ptr_to_adr(page)
    assert ac.page_for_size[5] == page
    #
    page = ac.allocate_new_page(3)
    checknewpage(page, 3)
    assert ac.num_uninitialized_pages == 1
    assert ac.current_arena.freepages - pagesize == cast_ptr_to_adr(page)
    assert ac.page_for_size[3] == page
    #
    page = ac.allocate_new_page(4)
    checknewpage(page, 4)
    assert ac.num_uninitialized_pages == 0
    assert ac.page_for_size[4] == page
コード例 #9
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
    def test_pin_nursery_top_scenario1(self):
        ptr1 = self.malloc(T)
        adr1 = llmemory.cast_ptr_to_adr(ptr1)
        ptr1.someInt = 101
        self.stackroots.append(ptr1)
        assert self.gc.pin(adr1)
        
        ptr2 = self.malloc(T)
        adr2 = llmemory.cast_ptr_to_adr(ptr2)
        ptr2.someInt = 102
        self.stackroots.append(ptr2)
        assert self.gc.pin(adr2)

        ptr3 = self.malloc(T)
        adr3 = llmemory.cast_ptr_to_adr(ptr3)
        ptr3.someInt = 103
        self.stackroots.append(ptr3)
        assert self.gc.pin(adr3)

        # scenario: no minor collection happened, only three mallocs
        # and pins
        #
        # +- nursery
        # |
        # v
        # +--------+--------+--------+---------------------...---+
        # | pinned | pinned | pinned | empty                     |
        # +--------+--------+--------+---------------------...---+
        #                            ^                           ^
        #                            |                           |
        #              nursery_free -+                           |
        #                                           nursery_top -+
        #
        assert adr3 < self.gc.nursery_free
        assert self.gc.nursery_free < self.gc.nursery_top
コード例 #10
0
ファイル: test_direct.py プロジェクト: mozillazg/pypy
    def test_write_barrier_marking_simple(self):
        for i in range(2):
            curobj = self.malloc(S)
            curobj.x = i
            self.stackroots.append(curobj)


        oldobj = self.stackroots[-1]
        oldhdr = self.gc.header(llmemory.cast_ptr_to_adr(oldobj))

        assert oldhdr.tid & incminimark.GCFLAG_VISITED == 0
        self.gc.debug_gc_step_until(incminimark.STATE_MARKING)
        oldobj = self.stackroots[-1]
        # object shifted by minor collect
        oldhdr = self.gc.header(llmemory.cast_ptr_to_adr(oldobj))
        assert oldhdr.tid & incminimark.GCFLAG_VISITED == 0

        self.gc._minor_collection()
        self.gc.visit_all_objects_step(1)

        assert oldhdr.tid & incminimark.GCFLAG_VISITED

        #at this point the first object should have been processed
        newobj = self.malloc(S)
        self.write(oldobj,'next',newobj)

        assert self.gc.header(self.gc.old_objects_pointing_to_young.tolist()[0]) == oldhdr

        self.gc._minor_collection()
        self.gc.debug_check_consistency()
コード例 #11
0
ファイル: test_direct.py プロジェクト: mozillazg/pypy
 def walk_roots(self, collect_stack_root,
                collect_static_in_prebuilt_nongc,
                collect_static_in_prebuilt_gc,
                is_minor=False):
     gc = self.tester.gc
     layoutbuilder = self.tester.layoutbuilder
     if collect_static_in_prebuilt_gc:
         for addrofaddr in layoutbuilder.addresses_of_static_ptrs:
             if addrofaddr.address[0]:
                 collect_static_in_prebuilt_gc(gc, addrofaddr)
     if collect_static_in_prebuilt_nongc:
         for addrofaddr in layoutbuilder.addresses_of_static_ptrs_in_nongc:
             if addrofaddr.address[0]:
                 collect_static_in_prebuilt_nongc(gc, addrofaddr)
     if collect_stack_root:
         stackroots = self.tester.stackroots
         a = lltype.malloc(ADDR_ARRAY, len(stackroots), flavor='raw')
         for i in range(len(a)):
             a[i] = llmemory.cast_ptr_to_adr(stackroots[i])
         a_base = lltype.direct_arrayitems(a)
         for i in range(len(a)):
             ai = lltype.direct_ptradd(a_base, i)
             collect_stack_root(gc, llmemory.cast_ptr_to_adr(ai))
         for i in range(len(a)):
             PTRTYPE = lltype.typeOf(stackroots[i])
             stackroots[i] = llmemory.cast_adr_to_ptr(a[i], PTRTYPE)
         lltype.free(a, flavor='raw')
コード例 #12
0
ファイル: test_rdict.py プロジェクト: charred/pypy
    def test_prebuilt_list_of_addresses(self):
        from rpython.rtyper.lltypesystem import llmemory

        TP = lltype.Struct('x', ('y', lltype.Signed))
        a = lltype.malloc(TP, flavor='raw', immortal=True)
        b = lltype.malloc(TP, flavor='raw', immortal=True)
        c = lltype.malloc(TP, flavor='raw', immortal=True)
        a_a = llmemory.cast_ptr_to_adr(a)
        a0 = llmemory.cast_ptr_to_adr(a)
        assert a_a is not a0
        assert a_a == a0
        a_b = llmemory.cast_ptr_to_adr(b)
        a_c = llmemory.cast_ptr_to_adr(c)

        d = {a_a: 3, a_b: 4, a_c: 5}
        d[a0] = 8

        def func(i):
            if i == 0:
                ptr = a
            else:
                ptr = b
            return d[llmemory.cast_ptr_to_adr(ptr)]

        py.test.raises(TypeError, self.interpret, func, [0])
コード例 #13
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
    def pin_unpin_moved_stackroot(self, collect_func):
        # scenario: test if the pinned object is moved after being unpinned.
        # the second part of the scenario is the tested one. The first part
        # is already tests by other tests.
        ptr = self.malloc(T)
        ptr.someInt = 100
        self.stackroots.append(ptr)
        assert self.stackroots[0] == ptr # validate our assumption

        adr = llmemory.cast_ptr_to_adr(ptr)
        assert self.gc.pin(adr)

        collect_func()
        #
        # from here on the test really starts. previouse logic is already tested
        #
        self.gc.unpin(adr)
        assert not self.gc._is_pinned(adr)
        assert self.gc.is_in_nursery(adr)
        #
        # now we do another collection and the object should be moved out of
        # the nursery.
        collect_func()
        new_adr = llmemory.cast_ptr_to_adr(self.stackroots[0])
        assert not self.gc.is_in_nursery(new_adr)
        assert self.stackroots[0].someInt == 100
        with py.test.raises(RuntimeError) as exinfo:
            ptr.someInt = 200
        assert "freed" in str(exinfo.value)
コード例 #14
0
ファイル: misc.py プロジェクト: kipras/pypy
def _raw_memcopy_opaque(source, dest, size):
    # push push push at the llmemory interface (with hacks that are all
    # removed after translation)
    zero = llmemory.itemoffsetof(rffi.CCHARP.TO, 0)
    llmemory.raw_memcopy(
        llmemory.cast_ptr_to_adr(source) + zero,
        llmemory.cast_ptr_to_adr(dest) + zero,
        size * llmemory.sizeof(lltype.Char))
コード例 #15
0
ファイル: gc_test_base.py プロジェクト: charred/pypy
 def setup():
     s1 = lltype.malloc(S)
     tx = lltype.malloc(T)
     tx.z = 42
     ty = lltype.malloc(T)
     s1.x = llmemory.cast_ptr_to_adr(tx)
     s1.y = llmemory.cast_ptr_to_adr(ty)
     return s1
コード例 #16
0
ファイル: test_direct.py プロジェクト: charred/pypy
 def writearray(self, p, index, newvalue):
     if self.gc.needs_write_barrier:
         newaddr = llmemory.cast_ptr_to_adr(newvalue)
         addr_struct = llmemory.cast_ptr_to_adr(p)
         if hasattr(self.gc, 'write_barrier_from_array'):
             self.gc.write_barrier_from_array(newaddr, addr_struct, index)
         else:
             self.gc.write_barrier(newaddr, addr_struct)
     p[index] = newvalue
コード例 #17
0
ファイル: llmodel.py プロジェクト: mozillazg/pypy
    def _setup_frame_realloc(self, translate_support_code):
        FUNC_TP = lltype.Ptr(lltype.FuncType([llmemory.GCREF, lltype.Signed],
                                             llmemory.GCREF))
        base_ofs = self.get_baseofs_of_frame_field()

        def realloc_frame(frame, size):
            try:
                if not we_are_translated():
                    assert not self._exception_emulator[0]
                frame = lltype.cast_opaque_ptr(jitframe.JITFRAMEPTR, frame)
                if size > frame.jf_frame_info.jfi_frame_depth:
                    # update the frame_info size, which is for whatever reason
                    # not up to date
                    frame.jf_frame_info.update_frame_depth(base_ofs, size)
                new_frame = jitframe.JITFRAME.allocate(frame.jf_frame_info)
                frame.jf_forward = new_frame
                i = 0
                while i < len(frame.jf_frame):
                    new_frame.jf_frame[i] = frame.jf_frame[i]
                    frame.jf_frame[i] = 0
                    i += 1
                new_frame.jf_savedata = frame.jf_savedata
                new_frame.jf_guard_exc = frame.jf_guard_exc
                # all other fields are empty
                llop.gc_writebarrier(lltype.Void, new_frame)
                return lltype.cast_opaque_ptr(llmemory.GCREF, new_frame)
            except Exception as e:
                print "Unhandled exception", e, "in realloc_frame"
                return lltype.nullptr(llmemory.GCREF.TO)

        def realloc_frame_crash(frame, size):
            print "frame", frame, "size", size
            return lltype.nullptr(llmemory.GCREF.TO)

        if not translate_support_code:
            fptr = llhelper(FUNC_TP, realloc_frame)
        else:
            FUNC = FUNC_TP.TO
            args_s = [lltype_to_annotation(ARG) for ARG in FUNC.ARGS]
            s_result = lltype_to_annotation(FUNC.RESULT)
            mixlevelann = MixLevelHelperAnnotator(self.rtyper)
            graph = mixlevelann.getgraph(realloc_frame, args_s, s_result)
            fptr = mixlevelann.graph2delayed(graph, FUNC)
            mixlevelann.finish()
        self.realloc_frame = heaptracker.adr2int(llmemory.cast_ptr_to_adr(fptr))

        if not translate_support_code:
            fptr = llhelper(FUNC_TP, realloc_frame_crash)
        else:
            FUNC = FUNC_TP.TO
            args_s = [lltype_to_annotation(ARG) for ARG in FUNC.ARGS]
            s_result = lltype_to_annotation(FUNC.RESULT)
            mixlevelann = MixLevelHelperAnnotator(self.rtyper)
            graph = mixlevelann.getgraph(realloc_frame_crash, args_s, s_result)
            fptr = mixlevelann.graph2delayed(graph, FUNC)
            mixlevelann.finish()
        self.realloc_frame_crash = heaptracker.adr2int(llmemory.cast_ptr_to_adr(fptr))
コード例 #18
0
ファイル: gc_test_base.py プロジェクト: abhinavthomas/pypy
 def setup():
     rgc.register_custom_trace_hook(S, lambda_customtrace)
     s1 = lltype.malloc(S)
     tx = lltype.malloc(T)
     tx.z = 42
     ty = lltype.malloc(T)
     s1.x = llmemory.cast_ptr_to_adr(tx)
     s1.y = llmemory.cast_ptr_to_adr(ty)
     return s1
コード例 #19
0
ファイル: test_rdict.py プロジェクト: charred/pypy
 def func(i):
     d = {}
     d[llmemory.cast_ptr_to_adr(a)] = 123
     d[llmemory.cast_ptr_to_adr(b)] = 456
     if i > 5:
         key = llmemory.cast_ptr_to_adr(a)
     else:
         key = llmemory.cast_ptr_to_adr(b)
     return d[key]
コード例 #20
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
    def test_pin_nursery_top_scenario5(self):
        ptr1 = self.malloc(T)
        adr1 = llmemory.cast_ptr_to_adr(ptr1)
        ptr1.someInt = 101
        self.stackroots.append(ptr1)
        assert self.gc.pin(adr1)
        
        ptr2 = self.malloc(T)
        adr2 = llmemory.cast_ptr_to_adr(ptr2)
        ptr2.someInt = 102
        self.stackroots.append(ptr2)
        assert self.gc.pin(adr2)

        ptr3 = self.malloc(T)
        adr3 = llmemory.cast_ptr_to_adr(ptr3)
        ptr3.someInt = 103
        self.stackroots.append(ptr3)
        assert self.gc.pin(adr3)

        # scenario: no minor collection happened, only three mallocs
        # and pins
        #
        # +- nursery
        # |
        # v
        # +--------+--------+--------+---------------------...---+
        # | pinned | pinned | pinned | empty                     |
        # +--------+--------+--------+---------------------...---+
        #                            ^                           ^
        #                            |                           |
        #              nursery_free -+                           |
        #                                           nursery_top -+
        #
        assert adr3 < self.gc.nursery_free
        assert self.gc.nursery_free < self.gc.nursery_top

        # scenario: unpin everything and minor collection
        #
        # +- nursery
        # |
        # v
        # +----------------------------------+-------------...---+
        # | reset arena                      | empty (not reset) |
        # +----------------------------------+-------------...---+
        # ^                                  ^
        # |                                  |
        # +- nursery_free                    |
        #                       nursery_top -+
        #
        self.gc.unpin(adr1)
        self.gc.unpin(adr2)
        self.gc.unpin(adr3)
        self.gc.collect()

        assert self.gc.nursery_free == self.gc.nursery
        assert self.gc.nursery_top > self.gc.nursery_free
コード例 #21
0
ファイル: test_symbolic.py プロジェクト: Darriall/pypy
 def f():
     a = lltype.malloc(ARR, 5, flavor='raw')
     a2 = lltype.malloc(ARR2, 6, flavor='raw')
     a2[0] = 1
     a[0] = 3
     adr = llmemory.cast_ptr_to_adr(a)
     adr2 = llmemory.cast_ptr_to_adr(a2)
     return ((adr + offsetx).signed[0] * 1000 +
             (adr + offsety).signed[0] * 100 +
             (adr2 + offsetx2).signed[0] * 10 + (adr2 + offsety2).signed[0])
コード例 #22
0
 def writebarrier_before_copy(self, source, dest,
                              source_start, dest_start, length):
     if self.gc.needs_write_barrier:
         source_addr = llmemory.cast_ptr_to_adr(source)
         dest_addr   = llmemory.cast_ptr_to_adr(dest)
         return self.gc.writebarrier_before_copy(source_addr, dest_addr,
                                                 source_start, dest_start,
                                                 length)
     else:
         return True
コード例 #23
0
ファイル: gc.py プロジェクト: charred/pypy
 def do_write_barrier(self, gcref_struct, gcref_newptr):
     hdr_addr = llmemory.cast_ptr_to_adr(gcref_struct)
     hdr_addr -= self.gcheaderbuilder.size_gc_header
     hdr = llmemory.cast_adr_to_ptr(hdr_addr, self.HDRPTR)
     if hdr.tid & self.GCClass.JIT_WB_IF_FLAG:
         # get a pointer to the 'remember_young_pointer' function from
         # the GC, and call it immediately
         llop1 = self.llop1
         funcptr = llop1.get_write_barrier_failing_case(self.WB_FUNCPTR)
         funcptr(llmemory.cast_ptr_to_adr(gcref_struct))
コード例 #24
0
ファイル: targetlbench.py プロジェクト: cimarieta/usp
def longername(a, b, size):
    if 1:
        baseofs = itemoffsetof(TP, 0)
        onesize = sizeof(TP.OF)
        size = baseofs + onesize * (size - 1)
        raw_memcopy(cast_ptr_to_adr(b) + baseofs, cast_ptr_to_adr(a) + baseofs, size)
    else:
        a = []
        for i in range(x):
            a.append(i)
    return 0
コード例 #25
0
ファイル: test_pointer.py プロジェクト: mswart/topaz
 def test_it_saves_a_pointer_to_whatever_address_was_given(self, space):
     int8_ptr = lltype.malloc(rffi.CArray(rffi.CHAR), 1, flavor='raw')
     adr = llmemory.cast_ptr_to_adr(int8_ptr)
     aint = llmemory.cast_adr_to_int(adr, mode='forced')
     w_ptr_obj = space.execute("""
     ptr = FFI::Pointer.new(%s)
     """ % aint)
     adr = llmemory.cast_ptr_to_adr(w_ptr_obj.ptr)
     assert llmemory.cast_adr_to_int(adr, mode='forced') == aint
     lltype.free(int8_ptr, flavor='raw')
     assert not aint in ALLOCATED
コード例 #26
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
 def test_malloc_different_types(self):
     # scenario: malloc two objects of different type and pin them. Do a
     # minor and major collection in between. This test showed a bug that was
     # present in a previous implementation of pinning.
     obj1 = self.malloc(T)
     self.stackroots.append(obj1)
     assert self.gc.pin(llmemory.cast_ptr_to_adr(obj1))
     #
     self.gc.collect()
     #
     obj2 = self.malloc(T)
     self.stackroots.append(obj2)
     assert self.gc.pin(llmemory.cast_ptr_to_adr(obj2))
コード例 #27
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
    def test_pin_bug2(self):
        #
        # * we have an old object A that points to a pinned object B
        #
        # * we unpin B
        #
        # * the next minor_collection() is done in STATE_MARKING==1
        #   when the object A is already black
        #
        # * _minor_collection() => _visit_old_objects_pointing_to_pinned()
        #   which will move the now-unpinned B out of the nursery, to B'
        #
        # At that point we need to take care of colors, otherwise we
        # get a black object (A) pointing to a white object (B'),
        # which must never occur.
        #
        ptrA = self.malloc(T)
        ptrA.someInt = 42
        adrA = llmemory.cast_ptr_to_adr(ptrA)
        res = self.gc.pin(adrA)
        assert res

        ptrC = self.malloc(S)
        self.stackroots.append(ptrC)

        ptrB = self.malloc(S)
        ptrB.data = ptrA
        self.stackroots.append(ptrB)

        self.gc.collect()
        ptrB = self.stackroots[-1]    # now old and outside the nursery
        ptrC = self.stackroots[-2]    # another random old object, traced later
        adrB = llmemory.cast_ptr_to_adr(ptrB)

        self.gc.minor_collection()
        assert self.gc.gc_state == self.STATE_SCANNING
        self.gc.major_collection_step()
        assert self.gc.gc_state == self.STATE_MARKING
        assert not (self.gc.header(adrB).tid & GCFLAG_VISITED)  # not black yet

        self.gc.TEST_VISIT_SINGLE_STEP = True
        self.gc.major_collection_step()
        assert self.gc.gc_state == self.STATE_MARKING
        assert self.gc.header(adrB).tid & GCFLAG_VISITED    # now black
        # but ptrC is not traced yet, which is why we're still in STATE_MARKING
        assert self.gc.old_objects_pointing_to_pinned.tolist() == [adrB]

        self.gc.unpin(adrA)

        self.gc.DEBUG = 2
        self.gc.minor_collection()
コード例 #28
0
ファイル: test_ll_random.py プロジェクト: Darriall/pypy
 def produce_into(self, builder, r):
     fail_subset = builder.subset_of_intvars(r)
     subset, f, exc = self.raising_func_code(builder, r)
     TP = lltype.FuncType([lltype.Signed] * len(subset), lltype.Void)
     ptr = llhelper(lltype.Ptr(TP), f)
     c_addr = ConstAddr(llmemory.cast_ptr_to_adr(ptr), builder.cpu)
     args = [c_addr] + subset
     descr = self.getcalldescr(builder, TP)
     self.put(builder, args, descr)
     exc_box = ConstAddr(llmemory.cast_ptr_to_adr(exc), builder.cpu)
     op = ResOperation(rop.GUARD_EXCEPTION, [exc_box], BoxPtr(),
                       descr=builder.getfaildescr())
     op.setfailargs(fail_subset)
     builder.loop.operations.append(op)
コード例 #29
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
 def pin_shadow_2(self, collect_func):
     ptr = self.malloc(T)
     adr = llmemory.cast_ptr_to_adr(ptr)
     self.stackroots.append(ptr)
     ptr.someInt = 100
     assert self.gc.pin(adr)
     self.gc.identityhash(ptr) # allocate shadow
     collect_func()
     assert self.gc.is_in_nursery(adr)
     assert ptr.someInt == 100
     self.gc.unpin(adr)
     collect_func() # move to shadow
     adr = llmemory.cast_ptr_to_adr(self.stackroots[0])
     assert not self.gc.is_in_nursery(adr)
コード例 #30
0
ファイル: test_object_pinning.py プロジェクト: mozillazg/pypy
 def test_pinning_limit(self):
     assert self.gc.max_number_of_pinned_objects == 5
     for instance_nr in xrange(self.gc.max_number_of_pinned_objects):
         ptr = self.malloc(T)
         adr = llmemory.cast_ptr_to_adr(ptr)
         ptr.someInt = 100 + instance_nr
         self.stackroots.append(ptr)
         assert self.gc.pin(adr)
     #
     # now we reached the maximum amount of pinned objects
     ptr = self.malloc(T)
     adr = llmemory.cast_ptr_to_adr(ptr)
     self.stackroots.append(ptr)
     assert not self.gc.pin(adr)
コード例 #31
0
 def cast_fnptr_to_root(self, fnptr):
     return llmemory.cast_ptr_to_adr(fnptr)
コード例 #32
0
 def g(p):
     return bool(llmemory.cast_ptr_to_adr(p))
コード例 #33
0
ファイル: runner.py プロジェクト: weijiwei/pypy
 def cast_ptr_to_int(x):
     adr = llmemory.cast_ptr_to_adr(x)
     return CPU_ARM.cast_adr_to_int(adr)
コード例 #34
0
ファイル: test_object_pinning.py プロジェクト: zielmicha/pypy
 def test_try_pin_gcref_containing_type(self):
     # scenario: incminimark's object pinning can't pin objects that may
     # contain GC pointers
     obj = self.malloc(S)
     assert not self.gc.pin(llmemory.cast_ptr_to_adr(obj))
コード例 #35
0
 def setfield(self, obj, fieldname, fieldvalue):
     STRUCT = lltype.typeOf(obj).TO
     addr = llmemory.cast_ptr_to_adr(obj)
     addr += llmemory.offsetof(STRUCT, fieldname)
     self.setinterior(obj, addr, getattr(STRUCT, fieldname), fieldvalue)
コード例 #36
0
ファイル: gcwrapper.py プロジェクト: Mu-L/pypy
 def writebarrier_before_move(self, array):
     if self.gc.needs_write_barrier:
         array_addr = llmemory.cast_ptr_to_adr(array)
         return self.gc.writebarrier_before_move(array_addr)
コード例 #37
0
 def get_malloc_fn_addr(self, funcname):
     ll_func = self.get_malloc_fn(funcname)
     return heaptracker.adr2int(llmemory.cast_ptr_to_adr(ll_func))
コード例 #38
0
 def get_write_barrier_fn(self, cpu):
     llop1 = self.llop1
     funcptr = llop1.get_write_barrier_failing_case(self.WB_FUNCPTR)
     funcaddr = llmemory.cast_ptr_to_adr(funcptr)
     return cpu.cast_adr_to_int(funcaddr)
コード例 #39
0
ファイル: llmodel.py プロジェクト: fhalde/pypy
 def bh_classof(self, struct):
     struct = lltype.cast_opaque_ptr(rclass.OBJECTPTR, struct)
     result_adr = llmemory.cast_ptr_to_adr(struct.typeptr)
     return heaptracker.adr2int(result_adr)
コード例 #40
0
ファイル: inspector.py プロジェクト: praveenmunagapati/pypy
def get_rpy_memory_usage(gc, gcref):
    return gc.get_size_incl_hash(llmemory.cast_ptr_to_adr(gcref))
コード例 #41
0
ファイル: inspector.py プロジェクト: praveenmunagapati/pypy
def _do_append_rpy_referents(gc, gcref, lst):
    gc._count_rpy = 0
    gc._list_rpy = lst
    gc.trace(llmemory.cast_ptr_to_adr(gcref), _append_rpy_referent, gc)
    gc._list_rpy = None
    return gc._count_rpy
コード例 #42
0
ファイル: inspector.py プロジェクト: praveenmunagapati/pypy
def get_rpy_type_index(gc, gcref):
    typeid = gc.get_type_id(llmemory.cast_ptr_to_adr(gcref))
    return gc.get_member_index(typeid)
コード例 #43
0
ファイル: inspector.py プロジェクト: praveenmunagapati/pypy
def is_rpy_instance(gc, gcref):
    typeid = gc.get_type_id(llmemory.cast_ptr_to_adr(gcref))
    return gc.is_rpython_class(typeid)
コード例 #44
0
 def setarrayitem(self, array, index, newitem):
     ARRAY = lltype.typeOf(array).TO
     addr = llmemory.cast_ptr_to_adr(array)
     addr += llmemory.itemoffsetof(ARRAY, index)
     self.setinterior(array, addr, ARRAY.OF, newitem, (index,))
コード例 #45
0
 def cast_vtable_to_hashable(self, cpu, ptr):
     adr = llmemory.cast_ptr_to_adr(ptr)
     return heaptracker.adr2int(adr)
コード例 #46
0
 def _wrapkey(self, obj):
     return llmemory.cast_ptr_to_adr(obj._as_ptr())
コード例 #47
0
 def func(i):
     if i == 0:
         ptr = a
     else:
         ptr = b
     return d[llmemory.cast_ptr_to_adr(ptr)]
コード例 #48
0
 def shrink_array(self, p, smallersize):
     if hasattr(self.gc, 'shrink_array'):
         addr = llmemory.cast_ptr_to_adr(p)
         return self.gc.shrink_array(addr, smallersize)
     return False
コード例 #49
0
ファイル: test_zrpy_gc_direct.py プロジェクト: sota/pypy-old
def run_guards_translated(gcremovetypeptr):
    class A(object):
        pass

    class B(A):
        pass

    class C(B):
        pass

    def main(argv):
        A()
        B().foo = len(argv)
        C()
        return 0

    t = TranslationContext()
    t.config.translation.gc = "minimark"
    t.config.translation.gcremovetypeptr = gcremovetypeptr
    ann = t.buildannotator()
    ann.build_types(main, [s_list_of_strings], main_entry_point=True)
    rtyper = t.buildrtyper()
    rtyper.specialize()

    classdef = ann.bookkeeper.getuniqueclassdef(B)
    rclass = getclassrepr(rtyper, classdef)
    rinstance = getinstancerepr(rtyper, classdef)
    LLB = rinstance.lowleveltype.TO
    ptr_vtable_B = rclass.getvtable()
    adr_vtable_B = llmemory.cast_ptr_to_adr(ptr_vtable_B)
    vtable_B = llmemory.cast_adr_to_int(adr_vtable_B, mode="symbolic")

    CPU = getcpuclass()
    cpu = CPU(rtyper,
              NoStats(),
              translate_support_code=True,
              gcdescr=get_description(t.config))
    execute_token = cpu.make_execute_token(llmemory.GCREF)
    finaldescr = BasicFinalDescr()
    faildescr = BasicFailDescr()

    descr_B = cpu.sizeof(LLB, ptr_vtable_B)
    typeid_B = descr_B.get_type_id()
    fielddescr_B = cpu.fielddescrof(LLB, 'inst_foo')

    LLD = lltype.GcStruct('D', ('dd', lltype.Signed))
    descr_D = cpu.sizeof(LLD)
    fielddescr_D = cpu.fielddescrof(LLD, 'dd')

    ARRAY = lltype.GcArray(lltype.Signed)
    arraydescr = cpu.arraydescrof(ARRAY)

    loop1 = parse("""
    [p0]
    guard_class(p0, ConstInt(vtable_B), descr=faildescr) []
    finish(descr=finaldescr)
    """,
                  namespace={
                      'finaldescr': finaldescr,
                      'faildescr': faildescr,
                      'vtable_B': vtable_B
                  })

    loop2 = parse("""
    [p0]
    guard_gc_type(p0, ConstInt(typeid_B), descr=faildescr) []
    finish(descr=finaldescr)
    """,
                  namespace={
                      'finaldescr': finaldescr,
                      'faildescr': faildescr,
                      'typeid_B': typeid_B
                  })

    loop3 = parse("""
    [p0]
    guard_is_object(p0, descr=faildescr) []
    finish(descr=finaldescr)
    """,
                  namespace={
                      'finaldescr': finaldescr,
                      'faildescr': faildescr
                  })

    loop4 = parse("""
    [p0]
    guard_subclass(p0, ConstInt(vtable_B), descr=faildescr) []
    finish(descr=finaldescr)
    """,
                  namespace={
                      'finaldescr': finaldescr,
                      'faildescr': faildescr,
                      'vtable_B': vtable_B
                  })

    def g():
        cpu.setup_once()
        token1 = JitCellToken()
        token2 = JitCellToken()
        token3 = JitCellToken()
        token4 = JitCellToken()
        cpu.compile_loop(loop1.inputargs, loop1.operations, token1)
        cpu.compile_loop(loop2.inputargs, loop2.operations, token2)
        cpu.compile_loop(loop3.inputargs, loop3.operations, token3)
        cpu.compile_loop(loop4.inputargs, loop4.operations, token4)

        for token, p0 in [
            (token1, rffi.cast(llmemory.GCREF, A())),
            (token1, rffi.cast(llmemory.GCREF, B())),
            (token1, rffi.cast(llmemory.GCREF, C())),
            (token2, rffi.cast(llmemory.GCREF, A())),
            (token2, rffi.cast(llmemory.GCREF, B())),
            (token2, rffi.cast(llmemory.GCREF, C())),
            (token2, rffi.cast(llmemory.GCREF, [42, 43])),
            (token3, rffi.cast(llmemory.GCREF, A())),
            (token3, rffi.cast(llmemory.GCREF, B())),
            (token3, rffi.cast(llmemory.GCREF, [44, 45])),
            (token4, rffi.cast(llmemory.GCREF, A())),
            (token4, rffi.cast(llmemory.GCREF, B())),
            (token4, rffi.cast(llmemory.GCREF, C())),
        ]:
            frame = execute_token(token, p0)
            descr = cpu.get_latest_descr(frame)
            if descr is finaldescr:
                print 'match'
            elif descr is faildescr:
                print 'fail'
            else:
                print '???'
            #
            if token is token2:  # guard_gc_type
                print int(cpu.get_actual_typeid(p0) == typeid_B)
            if token is token3:  # guard_is_object
                print int(cpu.check_is_object(p0))

        for p0 in [
                lltype.nullptr(llmemory.GCREF.TO),
                rffi.cast(llmemory.GCREF, A()),
                rffi.cast(llmemory.GCREF, B()),
                rffi.cast(llmemory.GCREF, C()),
                rffi.cast(llmemory.GCREF, lltype.malloc(LLD)),
                rffi.cast(llmemory.GCREF, lltype.malloc(ARRAY, 5)),
                rffi.cast(llmemory.GCREF, "foobar"),
                rffi.cast(llmemory.GCREF, u"foobaz")
        ]:
            results = ['B', 'D', 'A', 'S', 'U']
            try:
                cpu.protect_speculative_field(p0, fielddescr_B)
            except SpeculativeError:
                results[0] = '-'
            try:
                cpu.protect_speculative_field(p0, fielddescr_D)
            except SpeculativeError:
                results[1] = '-'
            try:
                cpu.protect_speculative_array(p0, arraydescr)
            except SpeculativeError:
                results[2] = '-'
            try:
                cpu.protect_speculative_string(p0)
            except SpeculativeError:
                results[3] = '-'
            try:
                cpu.protect_speculative_unicode(p0)
            except SpeculativeError:
                results[4] = '-'
            print ''.join(results)

    call_initial_function(t, g)

    cbuilder = genc.CStandaloneBuilder(t, main, t.config)
    cbuilder.generate_source(defines=cbuilder.DEBUG_DEFINES)
    cbuilder.compile()

    data = cbuilder.cmdexec('')
    assert data == (
        'fail\n'
        'match\n'
        'fail\n'
        'fail\n'
        '0\n'
        'match\n'
        '1\n'
        'fail\n'
        '0\n'
        'fail\n'
        '0\n'
        'match\n'
        '1\n'
        'match\n'
        '1\n'
        'fail\n'
        '0\n'
        'fail\n'
        'match\n'
        'match\n'
        '-----\n'  # null
        '-----\n'  # instance of A
        'B----\n'  # instance of B
        'B----\n'  # instance of C
        '-D---\n'
        '--A--\n'
        '---S-\n'
        '----U\n')
コード例 #50
0
ファイル: test_object_pinning.py プロジェクト: zielmicha/pypy
 def test_prebuilt_not_pinnable(self):
     ptr = lltype.malloc(T, immortal=True)
     self.consider_constant(ptr)
     assert not self.gc.pin(llmemory.cast_ptr_to_adr(ptr))
     self.gc.collect()
     assert not self.gc.pin(llmemory.cast_ptr_to_adr(ptr))
コード例 #51
0
class LLtypeMixin(object):
    def get_class_of_box(self, box):
        base = box.getref_base()
        return lltype.cast_opaque_ptr(rclass.OBJECTPTR, base).typeptr

    node_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    node_vtable.name = rclass.alloc_array_name('node')
    node_vtable_adr = llmemory.cast_ptr_to_adr(node_vtable)
    node_vtable2 = lltype.malloc(OBJECT_VTABLE, immortal=True)
    node_vtable2.name = rclass.alloc_array_name('node2')
    node_vtable_adr2 = llmemory.cast_ptr_to_adr(node_vtable2)
    node_vtable3 = lltype.malloc(OBJECT_VTABLE, immortal=True)
    node_vtable3.name = rclass.alloc_array_name('node3')
    node_vtable_adr3 = llmemory.cast_ptr_to_adr(node_vtable3)
    cpu = runner.LLGraphCPU(None)

    NODE = lltype.GcForwardReference()
    S = lltype.GcForwardReference()
    NODE.become(lltype.GcStruct('NODE', ('parent', OBJECT),
                                        ('value', lltype.Signed),
                                        ('floatval', lltype.Float),
                                        ('charval', lltype.Char),
                                        ('nexttuple', lltype.Ptr(S)),
                                        ('next', lltype.Ptr(NODE))))
    S.become(lltype.GcStruct('TUPLE', ('a', lltype.Signed), ('abis', lltype.Signed),
                        ('b', lltype.Ptr(NODE))))
    NODE2 = lltype.GcStruct('NODE2', ('parent', NODE),
                                     ('other', lltype.Ptr(NODE)))

    NODE3 = lltype.GcForwardReference()
    NODE3.become(lltype.GcStruct('NODE3', ('parent', OBJECT),
                            ('value', lltype.Signed),
                            ('next', lltype.Ptr(NODE3)),
                            hints={'immutable': True}))

    big_fields = [('big' + i, lltype.Signed) for i in string.ascii_lowercase]
    BIG = lltype.GcForwardReference()
    BIG.become(lltype.GcStruct('BIG', *big_fields, hints={'immutable': True}))

    for field, _ in big_fields:
        locals()[field + 'descr'] = cpu.fielddescrof(BIG, field)

    node = lltype.malloc(NODE)
    node.value = 5
    node.next = node
    node.parent.typeptr = node_vtable
    nodeaddr = lltype.cast_opaque_ptr(llmemory.GCREF, node)
    #nodebox = InputArgRef(lltype.cast_opaque_ptr(llmemory.GCREF, node))
    node2 = lltype.malloc(NODE2)
    node2.parent.parent.typeptr = node_vtable2
    node2addr = lltype.cast_opaque_ptr(llmemory.GCREF, node2)
    myptr = lltype.cast_opaque_ptr(llmemory.GCREF, node)
    mynodeb = lltype.malloc(NODE)
    myarray = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(lltype.GcArray(lltype.Signed), 13, zero=True))
    mynodeb.parent.typeptr = node_vtable
    myptrb = lltype.cast_opaque_ptr(llmemory.GCREF, mynodeb)
    myptr2 = lltype.malloc(NODE2)
    myptr2.parent.parent.typeptr = node_vtable2
    myptr2 = lltype.cast_opaque_ptr(llmemory.GCREF, myptr2)
    nullptr = lltype.nullptr(llmemory.GCREF.TO)

    mynode3 = lltype.malloc(NODE3)
    mynode3.parent.typeptr = node_vtable3
    mynode3.value = 7
    mynode3.next = mynode3
    myptr3 = lltype.cast_opaque_ptr(llmemory.GCREF, mynode3)   # a NODE2
    mynode4 = lltype.malloc(NODE3)
    mynode4.parent.typeptr = node_vtable3
    myptr4 = lltype.cast_opaque_ptr(llmemory.GCREF, mynode4)   # a NODE3


    nullptr = lltype.nullptr(llmemory.GCREF.TO)
    #nodebox2 = InputArgRef(lltype.cast_opaque_ptr(llmemory.GCREF, node2))
    nodesize = cpu.sizeof(NODE, node_vtable)
    node_tid = nodesize.get_type_id()
    nodesize2 = cpu.sizeof(NODE2, node_vtable2)
    nodesize3 = cpu.sizeof(NODE3, node_vtable3)
    valuedescr = cpu.fielddescrof(NODE, 'value')
    floatdescr = cpu.fielddescrof(NODE, 'floatval')
    chardescr = cpu.fielddescrof(NODE, 'charval')
    nextdescr = cpu.fielddescrof(NODE, 'next')
    nexttupledescr = cpu.fielddescrof(NODE, 'nexttuple')
    otherdescr = cpu.fielddescrof(NODE2, 'other')
    valuedescr3 = cpu.fielddescrof(NODE3, 'value')
    nextdescr3 = cpu.fielddescrof(NODE3, 'next')
    assert valuedescr3.is_always_pure()
    assert nextdescr3.is_always_pure()

    accessor = FieldListAccessor()
    accessor.initialize(None, {'inst_field': IR_QUASIIMMUTABLE})
    QUASI = lltype.GcStruct('QUASIIMMUT', ('inst_field', lltype.Signed),
                            ('mutate_field', rclass.OBJECTPTR),
                            hints={'immutable_fields': accessor})
    quasisize = cpu.sizeof(QUASI, None)
    quasi = lltype.malloc(QUASI, immortal=True)
    quasi.inst_field = -4247
    quasifielddescr = cpu.fielddescrof(QUASI, 'inst_field')
    quasiptr = lltype.cast_opaque_ptr(llmemory.GCREF, quasi)
    quasiimmutdescr = QuasiImmutDescr(cpu, quasiptr, quasifielddescr,
                                      cpu.fielddescrof(QUASI, 'mutate_field'))

    NODEOBJ = lltype.GcStruct('NODEOBJ', ('parent', OBJECT),
                                         ('ref', lltype.Ptr(OBJECT)))
    nodeobj = lltype.malloc(NODEOBJ)
    nodeobjvalue = lltype.cast_opaque_ptr(llmemory.GCREF, nodeobj)
    refdescr = cpu.fielddescrof(NODEOBJ, 'ref')

    INTOBJ_NOIMMUT = lltype.GcStruct('INTOBJ_NOIMMUT', ('parent', OBJECT),
                                                ('intval', lltype.Signed))
    INTOBJ_IMMUT = lltype.GcStruct('INTOBJ_IMMUT', ('parent', OBJECT),
                                            ('intval', lltype.Signed),
                                            hints={'immutable': True})
    intobj_noimmut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    intobj_immut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    noimmut_intval = cpu.fielddescrof(INTOBJ_NOIMMUT, 'intval')
    immut_intval = cpu.fielddescrof(INTOBJ_IMMUT, 'intval')
    immut = lltype.malloc(INTOBJ_IMMUT, zero=True)
    immutaddr = lltype.cast_opaque_ptr(llmemory.GCREF, immut)
    noimmut_descr = cpu.sizeof(INTOBJ_NOIMMUT, intobj_noimmut_vtable)
    immut_descr = cpu.sizeof(INTOBJ_IMMUT, intobj_immut_vtable)

    PTROBJ_IMMUT = lltype.GcStruct('PTROBJ_IMMUT', ('parent', OBJECT),
                                            ('ptrval', lltype.Ptr(OBJECT)),
                                            hints={'immutable': True})
    ptrobj_immut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    ptrobj_immut_descr = cpu.sizeof(PTROBJ_IMMUT, ptrobj_immut_vtable)
    immut_ptrval = cpu.fielddescrof(PTROBJ_IMMUT, 'ptrval')

    arraydescr = cpu.arraydescrof(lltype.GcArray(lltype.Signed))
    int32arraydescr = cpu.arraydescrof(lltype.GcArray(rffi.INT))
    int16arraydescr = cpu.arraydescrof(lltype.GcArray(rffi.SHORT))
    float32arraydescr = cpu.arraydescrof(lltype.GcArray(lltype.SingleFloat))
    arraydescr_tid = arraydescr.get_type_id()
    array = lltype.malloc(lltype.GcArray(lltype.Signed), 15, zero=True)
    arrayref = lltype.cast_opaque_ptr(llmemory.GCREF, array)
    array2 = lltype.malloc(lltype.GcArray(lltype.Ptr(S)), 15, zero=True)
    array2ref = lltype.cast_opaque_ptr(llmemory.GCREF, array2)
    gcarraydescr = cpu.arraydescrof(lltype.GcArray(llmemory.GCREF))
    gcarraydescr_tid = gcarraydescr.get_type_id()
    floatarraydescr = cpu.arraydescrof(lltype.GcArray(lltype.Float))

    arrayimmutdescr = cpu.arraydescrof(lltype.GcArray(lltype.Signed, hints={"immutable": True}))
    immutarray = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(arrayimmutdescr.A, 13, zero=True))
    gcarrayimmutdescr = cpu.arraydescrof(lltype.GcArray(llmemory.GCREF, hints={"immutable": True}))
    floatarrayimmutdescr = cpu.arraydescrof(lltype.GcArray(lltype.Float, hints={"immutable": True}))

    # a GcStruct not inheriting from OBJECT
    tpl = lltype.malloc(S, zero=True)
    tupleaddr = lltype.cast_opaque_ptr(llmemory.GCREF, tpl)
    nodefull2 = lltype.malloc(NODE, zero=True)
    nodefull2addr = lltype.cast_opaque_ptr(llmemory.GCREF, nodefull2)
    ssize = cpu.sizeof(S, None)
    adescr = cpu.fielddescrof(S, 'a')
    abisdescr = cpu.fielddescrof(S, 'abis')
    bdescr = cpu.fielddescrof(S, 'b')
    #sbox = BoxPtr(lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S)))
    arraydescr2 = cpu.arraydescrof(lltype.GcArray(lltype.Ptr(S)))

    T = lltype.GcStruct('TUPLE',
                        ('c', lltype.Signed),
                        ('d', lltype.Ptr(lltype.GcArray(lltype.Ptr(NODE)))))

    W_ROOT = lltype.GcStruct('W_ROOT', ('parent', OBJECT),
        ('inst_w_seq', llmemory.GCREF), ('inst_index', lltype.Signed),
        ('inst_w_list', llmemory.GCREF), ('inst_length', lltype.Signed),
        ('inst_start', lltype.Signed), ('inst_step', lltype.Signed))
    inst_w_seq = cpu.fielddescrof(W_ROOT, 'inst_w_seq')
    inst_index = cpu.fielddescrof(W_ROOT, 'inst_index')
    inst_length = cpu.fielddescrof(W_ROOT, 'inst_length')
    inst_start = cpu.fielddescrof(W_ROOT, 'inst_start')
    inst_step = cpu.fielddescrof(W_ROOT, 'inst_step')
    inst_w_list = cpu.fielddescrof(W_ROOT, 'inst_w_list')
    w_root_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    
    tsize = cpu.sizeof(T, None)
    cdescr = cpu.fielddescrof(T, 'c')
    ddescr = cpu.fielddescrof(T, 'd')
    arraydescr3 = cpu.arraydescrof(lltype.GcArray(lltype.Ptr(NODE3)))

    U = lltype.GcStruct('U',
                        ('parent', OBJECT),
                        ('one', lltype.Ptr(lltype.GcArray(lltype.Ptr(NODE)))))
    u_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    u_vtable_adr = llmemory.cast_ptr_to_adr(u_vtable)
    SIMPLE = lltype.GcStruct('simple',
        ('parent', OBJECT),
        ('value', lltype.Signed))
    simplevalue = cpu.fielddescrof(SIMPLE, 'value')
    simple_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    simpledescr = cpu.sizeof(SIMPLE, simple_vtable)
    simple = lltype.malloc(SIMPLE, zero=True)
    simpleaddr = lltype.cast_opaque_ptr(llmemory.GCREF, simple)
    #usize = cpu.sizeof(U, ...)
    onedescr = cpu.fielddescrof(U, 'one')

    FUNC = lltype.FuncType([lltype.Signed], lltype.Signed)
    plaincalldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                     EffectInfo.MOST_GENERAL)
    elidablecalldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                    EffectInfo([valuedescr], [], [],
                                               [valuedescr], [], [],
                                         EffectInfo.EF_ELIDABLE_CANNOT_RAISE))
    elidable2calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                    EffectInfo([valuedescr], [], [],
                                               [valuedescr], [], [],
                                         EffectInfo.EF_ELIDABLE_OR_MEMORYERROR))
    elidable3calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                    EffectInfo([valuedescr], [], [],
                                               [valuedescr], [], [],
                                         EffectInfo.EF_ELIDABLE_CAN_RAISE))
    nonwritedescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                    EffectInfo([], [], [], [], [], []))
    writeadescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                  EffectInfo([], [], [], [adescr], [], []))
    writearraydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                  EffectInfo([], [], [], [adescr], [arraydescr],
                                             []))
    writevalue3descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                       EffectInfo([], [], [], [valuedescr3], [], []))
    readadescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                                 EffectInfo([adescr], [], [], [], [], []))
    mayforcevirtdescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                 EffectInfo([nextdescr], [], [], [], [], [],
                            EffectInfo.EF_FORCES_VIRTUAL_OR_VIRTUALIZABLE,
                            can_invalidate=True))
    arraycopydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
             EffectInfo([], [arraydescr], [], [], [arraydescr], [],
                        EffectInfo.EF_CANNOT_RAISE,
                        oopspecindex=EffectInfo.OS_ARRAYCOPY))

    raw_malloc_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
             EffectInfo([], [], [], [], [], [],
                        EffectInfo.EF_CAN_RAISE,
                        oopspecindex=EffectInfo.OS_RAW_MALLOC_VARSIZE_CHAR))
    raw_free_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
             EffectInfo([], [], [], [], [], [],
                        EffectInfo.EF_CANNOT_RAISE,
                        oopspecindex=EffectInfo.OS_RAW_FREE))

    chararray = lltype.GcArray(lltype.Char)
    chararraydescr = cpu.arraydescrof(chararray)
    u2array = lltype.GcArray(rffi.USHORT)
    u2arraydescr = cpu.arraydescrof(u2array)

    nodefull = lltype.malloc(NODE2, zero=True)
    nodefull.parent.next = lltype.cast_pointer(lltype.Ptr(NODE), nodefull)
    nodefull.parent.nexttuple = tpl
    nodefulladdr = lltype.cast_opaque_ptr(llmemory.GCREF, nodefull)

    # array of structs (complex data)
    complexarray = lltype.GcArray(
        lltype.Struct("complex",
            ("real", lltype.Float),
            ("imag", lltype.Float),
        )
    )
    complexarraydescr = cpu.arraydescrof(complexarray)
    complexrealdescr = cpu.interiorfielddescrof(complexarray, "real")
    compleximagdescr = cpu.interiorfielddescrof(complexarray, "imag")
    complexarraycopydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
            EffectInfo([], [complexarraydescr], [], [], [complexarraydescr], [],
                       EffectInfo.EF_CANNOT_RAISE,
                       oopspecindex=EffectInfo.OS_ARRAYCOPY))

    rawarraydescr = cpu.arraydescrof(lltype.Array(lltype.Signed,
                                                  hints={'nolength': True}))
    rawarraydescr_char = cpu.arraydescrof(lltype.Array(lltype.Char,
                                                       hints={'nolength': True}))
    rawarraydescr_float = cpu.arraydescrof(lltype.Array(lltype.Float,
                                                        hints={'nolength': True}))

    fc_array = lltype.GcArray(
        lltype.Struct(
            "floatchar", ("float", lltype.Float), ("char", lltype.Char)))
    fc_array_descr = cpu.arraydescrof(fc_array)
    fc_array_floatdescr = cpu.interiorfielddescrof(fc_array, "float")
    fc_array_chardescr = cpu.interiorfielddescrof(fc_array, "char")

    for _name, _os in [
        ('strconcatdescr',               'OS_STR_CONCAT'),
        ('strslicedescr',                'OS_STR_SLICE'),
        ('strequaldescr',                'OS_STR_EQUAL'),
        ('streq_slice_checknull_descr',  'OS_STREQ_SLICE_CHECKNULL'),
        ('streq_slice_nonnull_descr',    'OS_STREQ_SLICE_NONNULL'),
        ('streq_slice_char_descr',       'OS_STREQ_SLICE_CHAR'),
        ('streq_nonnull_descr',          'OS_STREQ_NONNULL'),
        ('streq_nonnull_char_descr',     'OS_STREQ_NONNULL_CHAR'),
        ('streq_checknull_char_descr',   'OS_STREQ_CHECKNULL_CHAR'),
        ('streq_lengthok_descr',         'OS_STREQ_LENGTHOK'),
        ]:
        if _name in ('strconcatdescr', 'strslicedescr'):
            _extra = EffectInfo.EF_ELIDABLE_OR_MEMORYERROR
        else:
            _extra = EffectInfo.EF_ELIDABLE_CANNOT_RAISE
        _oopspecindex = getattr(EffectInfo, _os)
        locals()[_name] = \
            cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                EffectInfo([], [], [], [], [], [], _extra,
                           oopspecindex=_oopspecindex))
        #
        _oopspecindex = getattr(EffectInfo, _os.replace('STR', 'UNI'))
        locals()[_name.replace('str', 'unicode')] = \
            cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
                EffectInfo([], [], [], [], [], [], _extra,
                           oopspecindex=_oopspecindex))

    s2u_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
            EffectInfo([], [], [], [], [], [], EffectInfo.EF_ELIDABLE_CAN_RAISE,
                       oopspecindex=EffectInfo.OS_STR2UNICODE))
    #

    class LoopToken(AbstractDescr):
        pass
    asmdescr = LoopToken() # it can be whatever, it's not a descr though

    from rpython.jit.metainterp.virtualref import VirtualRefInfo

    class FakeWarmRunnerDesc:
        pass
    FakeWarmRunnerDesc.cpu = cpu
    vrefinfo = VirtualRefInfo(FakeWarmRunnerDesc)
    virtualtokendescr = vrefinfo.descr_virtual_token
    virtualforceddescr = vrefinfo.descr_forced
    FUNC = lltype.FuncType([], lltype.Void)
    ei = EffectInfo([], [], [], [], [], [], EffectInfo.EF_CANNOT_RAISE,
                    can_invalidate=False,
                    oopspecindex=EffectInfo.OS_JIT_FORCE_VIRTUALIZABLE)
    clear_vable = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, ei)

    jit_virtual_ref_vtable = vrefinfo.jit_virtual_ref_vtable
    jvr_vtable_adr = llmemory.cast_ptr_to_adr(jit_virtual_ref_vtable)
    vref_descr = cpu.sizeof(vrefinfo.JIT_VIRTUAL_REF, jit_virtual_ref_vtable)

    namespace = locals()
コード例 #52
0
ファイル: test_object_pinning.py プロジェクト: zielmicha/pypy
 def test_pin_twice(self):
     ptr = self.malloc(T)
     adr = llmemory.cast_ptr_to_adr(ptr)
     assert self.gc.pin(adr)
     assert not self.gc.pin(adr)
コード例 #53
0
 def _walk_prebuilt_gc(self, collect):  # debugging only!  not RPython
     for obj in self.gcheap._all_prebuilt_gc:
         collect(llmemory.cast_ptr_to_adr(obj._as_ptr()))
コード例 #54
0
ファイル: inspector.py プロジェクト: zielmicha/pypy
def _do_count_rpy_referents(gc, gcref):
    gc._count_rpy = 0
    gc.trace(llmemory.cast_ptr_to_adr(gcref), _count_rpy_referent, gc)
    return gc._count_rpy
コード例 #55
0
ファイル: test_object_pinning.py プロジェクト: zielmicha/pypy
 def test_unpin_not_pinned(self):
     # this test checks a requirement of the unpin() interface
     ptr = self.malloc(S)
     py.test.raises(Exception, self.gc.unpin, llmemory.cast_ptr_to_adr(ptr))
コード例 #56
0
ファイル: test_direct.py プロジェクト: soIu/rpython
 def write(self, p, fieldname, newvalue):
     if self.gc.needs_write_barrier:
         addr_struct = llmemory.cast_ptr_to_adr(p)
         self.gc.write_barrier(addr_struct)
     setattr(p, fieldname, newvalue)
コード例 #57
0
 def f():
     llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(s))
     return True
コード例 #58
0
 def cls_of_box(self, box):
     obj = box.getref(lltype.Ptr(rclass.OBJECT))
     cls = llmemory.cast_ptr_to_adr(obj.typeptr)
     return history.ConstInt(heaptracker.adr2int(cls))
コード例 #59
0
 class FakeJitDriverSD:
     index_of_virtualizable = -1
     _assembler_helper_ptr = llhelper(FUNCPTR, assembler_helper)
     assembler_helper_adr = llmemory.cast_ptr_to_adr(
         _assembler_helper_ptr)
コード例 #60
0
 def walk_page(self, page, block_size, ok_to_free_func):
     """Walk over all objects in a page, and ask ok_to_free_func()."""
     #
     # 'freeblock' is the next free block
     freeblock = page.freeblock
     #
     # 'prevfreeblockat' is the address of where 'freeblock' was read from.
     prevfreeblockat = lltype.direct_fieldptr(page, 'freeblock')
     prevfreeblockat = llmemory.cast_ptr_to_adr(prevfreeblockat)
     #
     obj = llarena.getfakearenaaddress(llmemory.cast_ptr_to_adr(page))
     obj += self.hdrsize
     surviving = 0  # initially
     skip_free_blocks = page.nfree
     #
     while True:
         #
         if obj == freeblock:
             #
             if skip_free_blocks == 0:
                 #
                 # 'obj' points to the first uninitialized block,
                 # or to the end of the page if there are none.
                 break
             #
             # 'obj' points to a free block.  It means that
             # 'prevfreeblockat.address[0]' does not need to be updated.
             # Just read the next free block from 'obj.address[0]'.
             skip_free_blocks -= 1
             prevfreeblockat = obj
             freeblock = obj.address[0]
             #
         else:
             # 'obj' points to a valid object.
             ll_assert(freeblock > obj,
                       "freeblocks are linked out of order")
             #
             if ok_to_free_func(obj):
                 #
                 # The object should die.
                 llarena.arena_reset(obj, _dummy_size(block_size), 0)
                 llarena.arena_reserve(obj,
                                       llmemory.sizeof(llmemory.Address))
                 # Insert 'obj' in the linked list of free blocks.
                 prevfreeblockat.address[0] = obj
                 prevfreeblockat = obj
                 obj.address[0] = freeblock
                 #
                 # Update the number of free objects in the page.
                 page.nfree += 1
                 #
             else:
                 # The object survives.
                 surviving += 1
         #
         obj += block_size
     #
     # Update the global total size of objects.
     self.total_memory_used += r_uint(surviving * block_size)
     #
     # Return the number of surviving objects.
     return surviving