Beispiel #1
0
 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 info lives on assembler stack, so we need to enable
             # writing
             enter_assembler_writing()
             frame.jf_frame_info.update_frame_depth(base_ofs, size)
             leave_assembler_writing()
         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)
Beispiel #2
0
 def f():
     s = lltype.malloc(S)
     s.x = 42
     llop.bare_setfield(lltype.Void, s0, void('next'), s)
     llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(s0))
     rgc.collect(0)
     return s0.next.x
Beispiel #3
0
 def attach_handle_on_suspstack(self, handle):
     s = self.suspstack
     self.suspstack = NULL_SUSPSTACK
     ll_assert(bool(s.anchor), "s.anchor should not be null")
     s.handle = handle
     llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(s))
     return s
Beispiel #4
0
def ll_writebarrier(gc_obj):
    """Use together with custom tracers.  When you update some object pointer
    stored in raw memory, you must call this function on 'gc_obj', which must
    be the object of type TP with the custom tracer (*not* the value stored!).
    This makes sure that the custom hook will be called again."""
    from rpython.rtyper.lltypesystem.lloperation import llop
    llop.gc_writebarrier(lltype.Void, gc_obj)
Beispiel #5
0
 def attach_handle_on_suspstack(self, handle):
     s = self.suspstack
     self.suspstack = NULL_SUSPSTACK
     ll_assert(bool(s.anchor), "s.anchor should not be null")
     s.handle = handle
     llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(s))
     return s
 def f():
     s = lltype.malloc(S)
     s.x = 42
     llop.bare_setfield(lltype.Void, s0, void('next'), s)
     llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(s0))
     rgc.collect(0)
     return s0.next.x
Beispiel #7
0
def ll_writebarrier(gc_obj):
    """Use together with custom tracers.  When you update some object pointer
    stored in raw memory, you must call this function on 'gc_obj', which must
    be the object of type TP with the custom tracer (*not* the value stored!).
    This makes sure that the custom hook will be called again."""
    from rpython.rtyper.lltypesystem.lloperation import llop
    llop.gc_writebarrier(lltype.Void, gc_obj)
def attach_handle_on_stacklet(stacklet, h):
    if not h:
        raise MemoryError
    elif _c.is_empty_handle(h):
        ll_assert(gcrootfinder.sscopy == llmemory.NULL, "empty_handle but sscopy != NULL")
        return NULL_STACKLET
    else:
        # This is a return that gave us a real handle.  Store it.
        stacklet.s_handle = h
        stacklet.s_sscopy = gcrootfinder.sscopy
        ll_assert(gcrootfinder.sscopy != llmemory.NULL, "!empty_handle but sscopy == NULL")
        gcrootfinder.sscopy = llmemory.NULL
        llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(stacklet))
        return stacklet
Beispiel #9
0
def ll_dict_remove_deleted_items(d):
    if d.num_live_items < len(d.entries) // 4:
        # At least 75% of the allocated entries are dead, so shrink the memory
        # allocated as well as doing a compaction.
        new_allocated = _overallocate_entries_len(d.num_live_items)
        newitems = lltype.malloc(lltype.typeOf(d).TO.entries.TO, new_allocated)
    else:
        newitems = d.entries
        # The loop below does a lot of writes into 'newitems'.  It's a better
        # idea to do a single gc_writebarrier rather than activating the
        # card-by-card logic (worth 11% in microbenchmarks).
        from rpython.rtyper.lltypesystem.lloperation import llop

        llop.gc_writebarrier(lltype.Void, newitems)
    #
    ENTRIES = lltype.typeOf(d).TO.entries.TO
    ENTRY = ENTRIES.OF
    isrc = 0
    idst = 0
    isrclimit = d.num_ever_used_items
    while isrc < isrclimit:
        if d.entries.valid(isrc):
            src = d.entries[isrc]
            dst = newitems[idst]
            dst.key = src.key
            dst.value = src.value
            if hasattr(ENTRY, "f_hash"):
                dst.f_hash = src.f_hash
            if hasattr(ENTRY, "f_valid"):
                assert src.f_valid
                dst.f_valid = True
            idst += 1
        isrc += 1
    assert d.num_live_items == idst
    d.num_ever_used_items = idst
    if (ENTRIES.must_clear_key or ENTRIES.must_clear_value) and d.entries == newitems:
        # must clear the extra entries: they may contain valid pointers
        # which would create a temporary memory leak
        while idst < isrclimit:
            entry = newitems[idst]
            if ENTRIES.must_clear_key:
                entry.key = lltype.nullptr(ENTRY.key.TO)
            if ENTRIES.must_clear_value:
                entry.value = lltype.nullptr(ENTRY.value.TO)
            idst += 1
    else:
        d.entries = newitems

    ll_dict_reindex(d, _ll_len_of_d_indexes(d))
Beispiel #10
0
def ll_dict_remove_deleted_items(d):
    if d.num_live_items < len(d.entries) // 4:
        # At least 75% of the allocated entries are dead, so shrink the memory
        # allocated as well as doing a compaction.
        new_allocated = _overallocate_entries_len(d.num_live_items)
        newitems = lltype.malloc(lltype.typeOf(d).TO.entries.TO, new_allocated)
    else:
        newitems = d.entries
        # The loop below does a lot of writes into 'newitems'.  It's a better
        # idea to do a single gc_writebarrier rather than activating the
        # card-by-card logic (worth 11% in microbenchmarks).
        from rpython.rtyper.lltypesystem.lloperation import llop
        llop.gc_writebarrier(lltype.Void, newitems)
    #
    ENTRIES = lltype.typeOf(d).TO.entries.TO
    ENTRY = ENTRIES.OF
    isrc = 0
    idst = 0
    isrclimit = d.num_ever_used_items
    while isrc < isrclimit:
        if d.entries.valid(isrc):
            src = d.entries[isrc]
            dst = newitems[idst]
            dst.key = src.key
            dst.value = src.value
            if hasattr(ENTRY, 'f_hash'):
                dst.f_hash = src.f_hash
            if hasattr(ENTRY, 'f_valid'):
                assert src.f_valid
                dst.f_valid = True
            idst += 1
        isrc += 1
    assert d.num_live_items == idst
    d.num_ever_used_items = idst
    if ((ENTRIES.must_clear_key or ENTRIES.must_clear_value)
            and d.entries == newitems):
        # must clear the extra entries: they may contain valid pointers
        # which would create a temporary memory leak
        while idst < isrclimit:
            entry = newitems[idst]
            if ENTRIES.must_clear_key:
                entry.key = lltype.nullptr(ENTRY.key.TO)
            if ENTRIES.must_clear_value:
                entry.value = lltype.nullptr(ENTRY.value.TO)
            idst += 1
    else:
        d.entries = newitems

    ll_dict_reindex(d, _ll_len_of_d_indexes(d))
Beispiel #11
0
def make_framework_tracer(array_base_addr, gcrefs):
    # careful about the order here: the allocation of the GCREFTRACER
    # can trigger a GC.  So we must write the gcrefs into the raw
    # array only afterwards...
    rgc.register_custom_trace_hook(GCREFTRACER, lambda_gcrefs_trace)
    length = len(gcrefs)
    tr = lltype.malloc(GCREFTRACER)
    # --no GC from here--
    tr.array_base_addr = array_base_addr
    tr.array_length = length
    i = 0
    while i < length:
        p = rffi.cast(rffi.SIGNEDP, array_base_addr + i * WORD)
        p[0] = rffi.cast(lltype.Signed, gcrefs[i])
        i += 1
    llop.gc_writebarrier(lltype.Void, tr)
    # --no GC until here--
    return tr
Beispiel #12
0
def make_framework_tracer(array_base_addr, gcrefs):
    # careful about the order here: the allocation of the GCREFTRACER
    # can trigger a GC.  So we must write the gcrefs into the raw
    # array only afterwards...
    rgc.register_custom_trace_hook(GCREFTRACER, lambda_gcrefs_trace)
    length = len(gcrefs)
    tr = lltype.malloc(GCREFTRACER)
    # --no GC from here--
    tr.array_base_addr = array_base_addr
    tr.array_length = length
    i = 0
    while i < length:
        p = rffi.cast(rffi.SIGNEDP, array_base_addr + i * WORD)
        p[0] = rffi.cast(lltype.Signed, gcrefs[i])
        i += 1
    llop.gc_writebarrier(lltype.Void, tr)
    # --no GC until here--
    return tr
Beispiel #13
0
def attach_handle_on_stacklet(stacklet, h):
    ll_assert(stacklet.s_handle == _c.null_handle,
              "attach stacklet 1: garbage")
    ll_assert(stacklet.s_sscopy == llmemory.NULL, "attach stacklet 2: garbage")
    if not h:
        raise MemoryError
    elif _c.is_empty_handle(h):
        ll_assert(gcrootfinder.sscopy == llmemory.NULL,
                  "empty_handle but sscopy != NULL")
        return NULL_STACKLET
    else:
        # This is a return that gave us a real handle.  Store it.
        stacklet.s_handle = h
        stacklet.s_sscopy = gcrootfinder.sscopy
        ll_assert(gcrootfinder.sscopy != llmemory.NULL,
                  "!empty_handle but sscopy == NULL")
        gcrootfinder.sscopy = llmemory.NULL
        llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(stacklet))
        return stacklet
Beispiel #14
0
 def execute_token(executable_token, *args):
     clt = executable_token.compiled_loop_token
     assert isinstance(clt, CompiledLoopTokenASMJS)
     funcid = clt.func.compiled_funcid
     loopid = clt.compiled_loopid
     frame_info = clt.func.frame_info
     frame = self.gc_ll_descr.malloc_jitframe(frame_info)
     ll_frame = lltype.cast_opaque_ptr(llmemory.GCREF, frame)
     locs = clt._ll_initial_locs
     if SANITYCHECK:
         assert len(locs) == len(args)
     if not self.translate_support_code:
         prev_interpreter = LLInterpreter.current_interpreter
         LLInterpreter.current_interpreter = self.debug_ll_interpreter
     try:
         # Store each argument into the frame.
         for i, kind in kinds:
             arg = args[i]
             num = locs[i]
             if kind == history.INT:
                 self.set_int_value(ll_frame, num, arg)
             elif kind == history.FLOAT:
                 self.set_float_value(ll_frame, num, arg)
             else:
                 assert kind == history.REF
                 self.set_ref_value(ll_frame, num, arg)
         llop.gc_writebarrier(lltype.Void, ll_frame)
         # Send the threadlocaladdr.
         if self.translate_support_code:
             ll_tlref = llop.threadlocalref_addr(llmemory.Address)
         else:
             ll_tlref = rffi.cast(llmemory.Address,
                                  self._debug_errno_container)
         # Invoke it via the helper.
         ll_frameadr = self.cast_ptr_to_int(ll_frame)
         ll_tladdr = self.cast_adr_to_int(ll_tlref)
         ll_frameadr = support.jitInvoke(funcid, ll_frameadr, ll_tladdr,
                                         loopid)
         ll_frame = self.cast_int_to_ptr(ll_frameadr, llmemory.GCREF)
     finally:
         if not self.translate_support_code:
             LLInterpreter.current_interpreter = prev_interpreter
     return ll_frame
Beispiel #15
0
 def execute_token(executable_token, *args):
     clt = executable_token.compiled_loop_token
     assert isinstance(clt, CompiledLoopTokenASMJS)
     funcid = clt.func.compiled_funcid
     loopid = clt.compiled_loopid
     frame_info = clt.func.frame_info
     frame = self.gc_ll_descr.malloc_jitframe(frame_info)
     ll_frame = lltype.cast_opaque_ptr(llmemory.GCREF, frame)
     locs = clt._ll_initial_locs
     if SANITYCHECK:
         assert len(locs) == len(args)
     if not self.translate_support_code:
         prev_interpreter = LLInterpreter.current_interpreter
         LLInterpreter.current_interpreter = self.debug_ll_interpreter
     try:
         # Store each argument into the frame.
         for i, kind in kinds:
             arg = args[i]
             num = locs[i]
             if kind == history.INT:
                 self.set_int_value(ll_frame, num, arg)
             elif kind == history.FLOAT:
                 self.set_float_value(ll_frame, num, arg)
             else:
                 assert kind == history.REF
                 self.set_ref_value(ll_frame, num, arg)
         llop.gc_writebarrier(lltype.Void, ll_frame)
         # Send the threadlocaladdr.
         if self.translate_support_code:
             ll_tlref = llop.threadlocalref_addr(
                 llmemory.Address)
         else:
             ll_tlref = rffi.cast(llmemory.Address,
                 self._debug_errno_container)
         # Invoke it via the helper.
         ll_frameadr = self.cast_ptr_to_int(ll_frame)
         ll_tladdr = self.cast_adr_to_int(ll_tlref)
         ll_frameadr = support.jitInvoke(funcid, ll_frameadr, ll_tladdr, loopid)
         ll_frame = self.cast_int_to_ptr(ll_frameadr, llmemory.GCREF)
     finally:
         if not self.translate_support_code:
             LLInterpreter.current_interpreter = prev_interpreter
     return ll_frame
Beispiel #16
0
 def execute_token(executable_token, *args):
     clt = executable_token.compiled_loop_token
     assert len(args) == clt._debug_nbargs
     #
     addr = executable_token._ll_function_addr
     func = rffi.cast(FUNCPTR, addr)
     #llop.debug_print(lltype.Void, ">>>> Entering", addr)
     frame_info = clt.frame_info
     frame = self.gc_ll_descr.malloc_jitframe(frame_info)
     ll_frame = lltype.cast_opaque_ptr(llmemory.GCREF, frame)
     locs = executable_token.compiled_loop_token._ll_initial_locs
     prev_interpreter = None   # help flow space
     if not self.translate_support_code:
         prev_interpreter = LLInterpreter.current_interpreter
         LLInterpreter.current_interpreter = self.debug_ll_interpreter
     try:
         for i, kind in kinds:
             arg = args[i]
             num = locs[i]
             if kind == history.INT:
                 self.set_int_value(ll_frame, num, arg)
             elif kind == history.FLOAT:
                 self.set_float_value(ll_frame, num, arg)
             else:
                 assert kind == history.REF
                 self.set_ref_value(ll_frame, num, arg)
         if self.translate_support_code:
             ll_threadlocal_addr = llop.threadlocalref_addr(
                 llmemory.Address)
         else:
             ll_threadlocal_addr = rffi.cast(llmemory.Address,
                 self._debug_tls_errno_container)
         llop.gc_writebarrier(lltype.Void, ll_frame)
         ll_frame = func(ll_frame, ll_threadlocal_addr)
     finally:
         if not self.translate_support_code:
             LLInterpreter.current_interpreter = prev_interpreter
     #llop.debug_print(lltype.Void, "<<<< Back")
     return ll_frame
Beispiel #17
0
 def execute_token(executable_token, *args):
     clt = executable_token.compiled_loop_token
     assert len(args) == clt._debug_nbargs
     #
     addr = executable_token._ll_function_addr
     func = rffi.cast(FUNCPTR, addr)
     #llop.debug_print(lltype.Void, ">>>> Entering", addr)
     frame_info = clt.frame_info
     frame = self.gc_ll_descr.malloc_jitframe(frame_info)
     ll_frame = lltype.cast_opaque_ptr(llmemory.GCREF, frame)
     locs = executable_token.compiled_loop_token._ll_initial_locs
     prev_interpreter = None   # help flow space
     if not self.translate_support_code:
         prev_interpreter = LLInterpreter.current_interpreter
         LLInterpreter.current_interpreter = self.debug_ll_interpreter
     try:
         for i, kind in kinds:
             arg = args[i]
             num = locs[i]
             if kind == history.INT:
                 self.set_int_value(ll_frame, num, arg)
             elif kind == history.FLOAT:
                 self.set_float_value(ll_frame, num, arg)
             else:
                 assert kind == history.REF
                 self.set_ref_value(ll_frame, num, arg)
         if self.translate_support_code:
             ll_threadlocal_addr = llop.threadlocalref_addr(
                 llmemory.Address)
         else:
             ll_threadlocal_addr = rffi.cast(llmemory.Address,
                 self._debug_errno_container)
         llop.gc_writebarrier(lltype.Void, ll_frame)
         ll_frame = func(ll_frame, ll_threadlocal_addr)
     finally:
         if not self.translate_support_code:
             LLInterpreter.current_interpreter = prev_interpreter
     #llop.debug_print(lltype.Void, "<<<< Back")
     return ll_frame
Beispiel #18
0
 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)
Beispiel #19
0
 def f():
     llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(s))
     return True
Beispiel #20
0
 def f():
     llop.gc_writebarrier(lltype.Void, llmemory.cast_ptr_to_adr(s))
     return True