def malloc_fixedsize_clear(self, typeid16, size, can_collect,
has_finalizer=False, contains_weakptr=False):
if can_collect:
self.maybe_collect()
size_gc_header = self.gcheaderbuilder.size_gc_header
try:
tot_size = size_gc_header + size
usage = raw_malloc_usage(tot_size)
bytes_malloced = ovfcheck(self.bytes_malloced+usage)
ovfcheck(self.heap_usage + bytes_malloced)
except OverflowError:
raise memoryError
result = raw_malloc(tot_size)
if not result:
raise memoryError
raw_memclear(result, tot_size)
hdr = llmemory.cast_adr_to_ptr(result, self.HDRPTR)
hdr.typeid16 = typeid16
hdr.mark = False
hdr.flags = '\x00'
if has_finalizer:
hdr.next = self.malloced_objects_with_finalizer
self.malloced_objects_with_finalizer = hdr
elif contains_weakptr:
hdr.next = self.objects_with_weak_pointers
self.objects_with_weak_pointers = hdr
else:
hdr.next = self.malloced_objects
self.malloced_objects = hdr
self.bytes_malloced = bytes_malloced
result += size_gc_header
#llop.debug_print(lltype.Void, 'malloc typeid', typeid16,
# '->', llmemory.cast_adr_to_int(result))
self.write_malloc_statistics(typeid16, tot_size, result, False)
return llmemory.cast_adr_to_ptr(result, llmemory.GCREF)
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_varsize_clear(self, typeid16, length, size, itemsize,
offset_to_length, can_collect):
if can_collect:
self.maybe_collect()
size_gc_header = self.gcheaderbuilder.size_gc_header
try:
fixsize = size_gc_header + size
varsize = ovfcheck(itemsize * length)
tot_size = ovfcheck(fixsize + varsize)
usage = raw_malloc_usage(tot_size)
bytes_malloced = ovfcheck(self.bytes_malloced+usage)
ovfcheck(self.heap_usage + bytes_malloced)
except OverflowError:
raise memoryError
result = raw_malloc(tot_size)
if not result:
raise memoryError
raw_memclear(result, tot_size)
(result + size_gc_header + offset_to_length).signed[0] = length
hdr = llmemory.cast_adr_to_ptr(result, self.HDRPTR)
hdr.typeid16 = typeid16
hdr.mark = False
hdr.flags = '\x00'
hdr.next = self.malloced_objects
self.malloced_objects = hdr
self.bytes_malloced = bytes_malloced
result += size_gc_header
#llop.debug_print(lltype.Void, 'malloc_varsize length', length,
# 'typeid', typeid16,
# '->', llmemory.cast_adr_to_int(result))
self.write_malloc_statistics(typeid16, tot_size, result, True)
return llmemory.cast_adr_to_ptr(result, llmemory.GCREF)
def malloc_fixedsize_clear(self, typeid16, size,
has_finalizer=False, contains_weakptr=False):
size_gc_header = self.gcheaderbuilder.size_gc_header
totalsize = size_gc_header + size
result = self._get_memory(totalsize)
llmemory.raw_memclear(result, totalsize)
return self._setup_object(result, typeid16, has_finalizer)
def malloc_varsize_clear(self, typeid16, length, size, itemsize,
offset_to_length):
self.maybe_collect()
size_gc_header = self.gcheaderbuilder.size_gc_header
try:
fixsize = size_gc_header + size
varsize = ovfcheck(itemsize * length)
tot_size = ovfcheck(fixsize + varsize)
usage = raw_malloc_usage(tot_size)
bytes_malloced = ovfcheck(self.bytes_malloced + usage)
ovfcheck(self.heap_usage + bytes_malloced)
except OverflowError:
raise memoryError
result = raw_malloc(tot_size)
if not result:
raise memoryError
raw_memclear(result, tot_size)
(result + size_gc_header + offset_to_length).signed[0] = length
hdr = llmemory.cast_adr_to_ptr(result, self.HDRPTR)
hdr.typeid16 = typeid16
hdr.mark = False
hdr.flags = '\x00'
hdr.next = self.malloced_objects
self.malloced_objects = hdr
self.bytes_malloced = bytes_malloced
result += size_gc_header
#llop.debug_print(lltype.Void, 'malloc_varsize length', length,
# 'typeid', typeid16,
# '->', llmemory.cast_adr_to_int(result))
self.write_malloc_statistics(typeid16, tot_size, result, True)
return llmemory.cast_adr_to_ptr(result, llmemory.GCREF)
def malloc_fixedsize_clear(self, typeid, size, can_collect,
has_finalizer=False, contains_weakptr=False):
if can_collect:
self.maybe_collect()
size_gc_header = self.gcheaderbuilder.size_gc_header
try:
tot_size = size_gc_header + size
usage = raw_malloc_usage(tot_size)
bytes_malloced = ovfcheck(self.bytes_malloced+usage)
ovfcheck(self.heap_usage + bytes_malloced)
except OverflowError:
raise memoryError
result = raw_malloc(tot_size)
if not result:
raise memoryError
raw_memclear(result, tot_size)
hdr = llmemory.cast_adr_to_ptr(result, self.HDRPTR)
hdr.typeid = typeid << 1
if has_finalizer:
hdr.next = self.malloced_objects_with_finalizer
self.malloced_objects_with_finalizer = hdr
elif contains_weakptr:
hdr.next = self.objects_with_weak_pointers
self.objects_with_weak_pointers = hdr
else:
hdr.next = self.malloced_objects
self.malloced_objects = hdr
self.bytes_malloced = bytes_malloced
result += size_gc_header
#llop.debug_print(lltype.Void, 'malloc typeid', typeid,
# '->', llmemory.cast_adr_to_int(result))
self.write_malloc_statistics(typeid, tot_size, result, False)
return llmemory.cast_adr_to_ptr(result, llmemory.GCREF)
def malloc_fixedsize_clear(self, typeid16, size, can_collect,
has_finalizer=False, contains_weakptr=False):
size_gc_header = self.gcheaderbuilder.size_gc_header
totalsize = size_gc_header + size
result = self._get_memory(totalsize)
llmemory.raw_memclear(result, totalsize)
return self._setup_object(result, typeid16, has_finalizer)
def malloc_varsize_clear(self, typeid16, length, size, itemsize, offset_to_length):
size_gc_header = self.gcheaderbuilder.size_gc_header
nonvarsize = size_gc_header + size
totalsize = self._get_totalsize_var(nonvarsize, itemsize, length)
result = self._get_memory(totalsize)
llmemory.raw_memclear(result, totalsize)
(result + size_gc_header + offset_to_length).signed[0] = length
return self._setup_object(result, typeid16, False)
def malloc_varsize_clear(self, typeid16, length, size, itemsize,
offset_to_length):
size_gc_header = self.gcheaderbuilder.size_gc_header
nonvarsize = size_gc_header + size
totalsize = self._get_totalsize_var(nonvarsize, itemsize, length)
result = self._get_memory(totalsize)
llmemory.raw_memclear(result, totalsize)
(result + size_gc_header + offset_to_length).signed[0] = length
return self._setup_object(result, typeid16, False)
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 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 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):
pagesize = linuxpagesize.pagesize
if pagesize == 0:
pagesize = rffi.cast(lltype.Signed, linux_getpagesize())
linuxpagesize.pagesize = pagesize
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
madv_length = rffi.cast(rffi.SIZE_T, length)
madv_flags = rffi.cast(rffi.INT, MADV_DONTNEED)
err = linux_madvise(baseaddr, madv_length, madv_flags)
if rffi.cast(lltype.Signed, err) == 0:
baseaddr += length # madvise() worked
size -= length
if size > 0: # clear the final misaligned part, if any
llmemory.raw_memclear(baseaddr, size)
def malloc_varsize_marknsweep(self, totalsize, resizable=False):
# 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' bytes of large objects.
# XXX we should probably track the total raw_malloc'ed size
# XXX and adjust sizes based on it; otherwise we risk doing
# XXX many many collections if the program allocates a lot
# XXX more than the current self.space_size.
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
if resizable:
self.gen2_resizable_objects.append(result + size_gc_header)
else:
self.gen2_rawmalloced_objects.append(result + size_gc_header)
return result
def malloc_varsize_marknsweep(self, totalsize, resizable=False):
# 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' bytes of large objects.
# XXX we should probably track the total raw_malloc'ed size
# XXX and adjust sizes based on it; otherwise we risk doing
# XXX many many collections if the program allocates a lot
# XXX more than the current self.space_size.
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
if resizable:
self.gen2_resizable_objects.append(result + size_gc_header)
else:
self.gen2_rawmalloced_objects.append(result + size_gc_header)
return result
def clear_large_memory_chunk(baseaddr, size):
pagesize = linuxpagesize.pagesize
if pagesize == 0:
pagesize = rffi.cast(lltype.Signed, linux_getpagesize())
linuxpagesize.pagesize = pagesize
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
madv_length = rffi.cast(rffi.SIZE_T, length)
madv_flags = rffi.cast(rffi.INT, MADV_DONTNEED)
err = linux_madvise(baseaddr, madv_length, madv_flags)
if rffi.cast(lltype.Signed, err) == 0:
baseaddr += length # madvise() worked
size -= length
if size > 0: # clear the final misaligned part, if any
llmemory.raw_memclear(baseaddr, size)
def clear_large_memory_chunk(baseaddr, size):
# on some Unixy platforms, reading from /dev/zero is the fastest way
# to clear arenas, because the kernel knows that it doesn't
# need to even allocate the pages before they are used.
# NB.: careful, don't do anything that could malloc here!
# this code is called during GC initialization.
fd = raw_os_open(_dev_zero, rffi.cast(rffi.INT, os.O_RDONLY),
rffi.cast(rffi.MODE_T, 0644))
if rffi.cast(lltype.Signed, fd) != -1:
while size > 0:
size1 = rffi.cast(rffi.SIZE_T, min(READ_MAX, size))
count = raw_os_read(fd, baseaddr, size1)
count = rffi.cast(lltype.Signed, count)
if count <= 0:
break
size -= count
baseaddr += count
raw_os_close(fd)
if size > 0: # reading from /dev/zero failed, fallback
llmemory.raw_memclear(baseaddr, size)
def clear_large_memory_chunk(baseaddr, size):
# on some Unixy platforms, reading from /dev/zero is the fastest way
# to clear arenas, because the kernel knows that it doesn't
# need to even allocate the pages before they are used.
# NB.: careful, don't do anything that could malloc here!
# this code is called during GC initialization.
fd = raw_os_open(_dev_zero,
rffi.cast(rffi.INT, os.O_RDONLY),
rffi.cast(rffi.MODE_T, 0644))
if rffi.cast(lltype.Signed, fd) != -1:
while size > 0:
size1 = rffi.cast(rffi.SIZE_T, min(READ_MAX, size))
count = raw_os_read(fd, baseaddr, size1)
count = rffi.cast(lltype.Signed, count)
if count <= 0:
break
size -= count
baseaddr += count
raw_os_close(fd)
if size > 0: # reading from /dev/zero failed, fallback
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)
def setup_root_walker(self):
stackbase = llmemory.raw_malloc(self.rootstacksize)
ll_assert(bool(stackbase), "could not allocate root stack")
llmemory.raw_memclear(stackbase, self.rootstacksize)
self.gcdata.root_stack_top = stackbase
self.gcdata.root_stack_base = stackbase
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 setup_root_walker(self):
stackbase = llmemory.raw_malloc(self.rootstacksize)
ll_assert(bool(stackbase), "could not allocate root stack")
llmemory.raw_memclear(stackbase, self.rootstacksize)
self.gcdata.root_stack_top = stackbase
self.gcdata.root_stack_base = stackbase
def allocate_stack(self):
result = llmemory.raw_malloc(self.rootstacksize)
if result:
llmemory.raw_memclear(result, self.rootstacksize)
return result
def allocate_stack(self):
result = llmemory.raw_malloc(self.rootstacksize)
if result:
llmemory.raw_memclear(result, self.rootstacksize)
return result
def raw_memclear(addr, size):
from pypy.rpython.lltypesystem.llmemory import fakeaddress, raw_memclear
if isinstance(addr, fakeaddress):
raw_memclear(addr, size)
else:
simulator.memclear(addr.intaddress, size)
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)
def op_raw_memclear(self, addr, size):
checkadr(addr)
llmemory.raw_memclear(addr, size)
