def _ll_malloc_varsize_no_length_zero(length, size, itemsize): tot_size = _ll_compute_size(length, size, itemsize) result = mh.allocate(tot_size) if not result: raise MemoryError() llmemory.raw_memclear(result, tot_size) return result
def malloc(self, typeid, length=0, zero=False): """NOT_RPYTHON For testing. The interface used by the gctransformer is the four malloc_[fixed,var]size[_clear]() functions. """ size = self.fixed_size(typeid) needs_finalizer = bool(self.getfinalizer(typeid)) finalizer_is_light = bool(self.getlightfinalizer(typeid)) contains_weakptr = self.weakpointer_offset(typeid) >= 0 assert not (needs_finalizer and contains_weakptr) if self.is_varsize(typeid): assert not contains_weakptr assert not needs_finalizer itemsize = self.varsize_item_sizes(typeid) offset_to_length = self.varsize_offset_to_length(typeid) if self.malloc_zero_filled: malloc_varsize = self.malloc_varsize_clear else: malloc_varsize = self.malloc_varsize ref = malloc_varsize(typeid, length, size, itemsize, offset_to_length) size += itemsize * length else: if self.malloc_zero_filled: malloc_fixedsize = self.malloc_fixedsize_clear else: malloc_fixedsize = self.malloc_fixedsize ref = malloc_fixedsize(typeid, size, needs_finalizer, finalizer_is_light, contains_weakptr) # lots of cast and reverse-cast around... ref = llmemory.cast_ptr_to_adr(ref) if zero and not self.malloc_zero_filled: llmemory.raw_memclear(ref, size) return ref
def llimpl_arena_reset(arena_addr, size, zero): if zero: if zero == 1: clear_large_memory_chunk(arena_addr, size) elif zero == 3: llop.raw_memset(lltype.Void, arena_addr, ord('#'), size) else: llmemory.raw_memclear(arena_addr, size)
def ll_arrayclear(p): # Equivalent to memset(array, 0). Only for GcArray(primitive-type) for now. from rpython.rlib.objectmodel import keepalive_until_here length = len(p) ARRAY = lltype.typeOf(p).TO offset = llmemory.itemoffsetof(ARRAY, 0) dest_addr = llmemory.cast_ptr_to_adr(p) + offset llmemory.raw_memclear(dest_addr, llmemory.sizeof(ARRAY.OF) * length) keepalive_until_here(p)
def ll_malloc_varsize_no_length(length, size, itemsize): try: fixsize = gc_header_offset + size varsize = ovfcheck(itemsize * length) tot_size = ovfcheck(fixsize + varsize) except OverflowError: raise MemoryError() result = mh._ll_malloc_fixedsize(tot_size) llmemory.raw_memclear(result, tot_size) result += gc_header_offset return result
def malloc_varsize_marknsweep(self, totalsize): # In order to free the large objects from time to time, we # arbitrarily force a full collect() if none occurs when we have # allocated self.space_size + rawmalloced bytes of large objects. self._check_rawsize_alloced(raw_malloc_usage(totalsize)) result = self.allocate_external_object(totalsize) if not result: raise MemoryError() # The parent classes guarantee zero-filled allocations, so we # need to follow suit. llmemory.raw_memclear(result, totalsize) size_gc_header = self.gcheaderbuilder.size_gc_header self.gen2_rawmalloced_objects.append(result + size_gc_header) return result
def clear_large_memory_chunk(baseaddr, size): from rpython.rlib import rmmap pagesize = posixpagesize.get() if size > 2 * pagesize: lowbits = rffi.cast(lltype.Signed, baseaddr) & (pagesize - 1) if lowbits: # clear the initial misaligned part, if any partpage = pagesize - lowbits llmemory.raw_memclear(baseaddr, partpage) baseaddr += partpage size -= partpage length = size & -pagesize if rmmap.clear_large_memory_chunk_aligned(baseaddr, length): baseaddr += length # clearing worked size -= length if size > 0: # clear the final misaligned part, if any llmemory.raw_memclear(baseaddr, size)
def op_raw_memclear(self, addr, size): checkadr(addr) llmemory.raw_memclear(addr, size)
def ll_malloc_fixedsize(size): size = gc_header_offset + size result = mh._ll_malloc_fixedsize(size) llmemory.raw_memclear(result, size) result += gc_header_offset return result
def llimpl_arena_reset(arena_addr, size, zero): if zero: if zero == 1: clear_large_memory_chunk(arena_addr, size) else: llmemory.raw_memclear(arena_addr, size)