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 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)
