def test_simple_access(self): AddressStack = get_address_stack() addr0 = raw_malloc(llmemory.sizeof(lltype.Signed)) addr1 = raw_malloc(llmemory.sizeof(lltype.Signed)) addr2 = raw_malloc(llmemory.sizeof(lltype.Signed)) ll = AddressStack() ll.append(addr0) ll.append(addr1) ll.append(addr2) assert ll.non_empty() a = ll.pop() assert a == addr2 assert ll.non_empty() a = ll.pop() assert a == addr1 assert ll.non_empty() a = ll.pop() assert a == addr0 assert not ll.non_empty() ll.append(addr0) ll.delete() ll = AddressStack() ll.append(addr0) ll.append(addr1) ll.append(addr2) ll.append(NULL) a = ll.pop() assert a == NULL ll.delete() raw_free(addr2) raw_free(addr1) raw_free(addr0)
def f(): addr = llmemory.raw_malloc(100) addr.signed[0] = 12 (addr + 10).signed[0] = 42 (addr + 20).char[0] = "a" addr1 = llmemory.raw_malloc(100) llmemory.raw_memcopy(addr, addr1, 100) result = addr1.signed[0] == 12 result = result and (addr1 + 10).signed[0] == 42 result = result and (addr1 + 20).char[0] == "a" llmemory.raw_free(addr) llmemory.raw_free(addr1) return result
def f(offset, char): char = chr(char) addr = llmemory.raw_malloc(10000) addr += offset addr.char[-offset] = char addr -= offset return ord(addr.char[0])
def f(): adr = llmemory.raw_malloc(sizeofs) s = llmemory.cast_adr_to_ptr(adr, STRUCTPTR) s.y = 5 # does not crash result = (adr + offsety).signed[0] * 10 + int(offsety < sizeofs) llmemory.raw_free(adr) return result
def f(): addr = raw_malloc(INT_SIZE*100) ll = AddressStack() ll.append(addr) ll.append(addr + INT_SIZE*1) ll.append(addr + INT_SIZE*2) a = ll.pop() res = (a - INT_SIZE*2 == addr) a = ll.pop() res = res and (a - INT_SIZE*1 == addr) res = res and ll.non_empty() a = ll.pop() res = res and a == addr res = res and not ll.non_empty() ll.append(addr) for i in range(300): ll.append(addr + INT_SIZE*i) for i in range(299, -1, -1): a = ll.pop() res = res and (a - INT_SIZE*i == addr) for i in range(300): ll.append(addr + INT_SIZE*i) for i in range(299, -1, -1): a = ll.pop() res = res and (a - INT_SIZE*i == addr) ll.delete() ll = AddressStack() ll.append(addr) ll.append(addr + INT_SIZE*1) ll.append(addr + INT_SIZE*2) ll.delete() raw_free(addr) return res
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_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(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 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 malloc_fixedsize(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 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 f(offset, char): char = chr(char) addr = llmemory.raw_malloc(10000) same_offset = (addr + 2 * offset - offset) - addr addr.char[offset] = char result = (addr + same_offset).char[0] llmemory.raw_free(addr) return ord(result)
def _emergency_initial_block(self, requested_size): # xxx before the GC is fully setup, we might get there. Hopefully # we will only allocate a couple of strings, e.g. in read_from_env(). # Just allocate them raw and leak them. debug_start("gc-initial-block") debug_print("leaking", requested_size, "bytes") debug_stop("gc-initial-block") return llmemory.raw_malloc(requested_size)
def do_malloc_fixedsize_clear(self, RESTYPE, type_id, size, can_collect, has_finalizer, contains_weakptr): assert can_collect assert not contains_weakptr p = llmemory.raw_malloc(size) p = llmemory.cast_adr_to_ptr(p, RESTYPE) flags = int(has_finalizer) << 16 tid = llop.combine_ushort(lltype.Signed, type_id, flags) self.record.append(("fixedsize", repr(size), tid, p)) return p
def do_malloc_varsize_clear(self, RESTYPE, type_id, length, size, itemsize, offset_to_length): p = llmemory.raw_malloc(size + itemsize * length) (p + offset_to_length).signed[0] = length p = llmemory.cast_adr_to_ptr(p, RESTYPE) tid = llop.combine_ushort(lltype.Signed, type_id, 0) self.record.append(("varsize", tid, length, repr(size), repr(itemsize), repr(offset_to_length), p)) return p
def do_malloc_varsize_clear(self, RESTYPE, type_id, length, size, itemsize, offset_to_length, can_collect): assert can_collect p = llmemory.raw_malloc(size + itemsize * length) (p + offset_to_length).signed[0] = length p = llmemory.cast_adr_to_ptr(p, RESTYPE) tid = llop.combine_ushort(lltype.Signed, type_id, 0) self.record.append(("varsize", tid, length, repr(size), repr(itemsize), repr(offset_to_length), p)) return p
def f(): result = 0 for addr1 in [llmemory.raw_malloc(1), llmemory.NULL]: addr2 = addr1 + 1 result = result * 2 + int(addr1 == addr2) result = result * 2 + int(addr1 != addr2) result = result * 2 + int(addr1 < addr2) result = result * 2 + int(addr1 <= addr2) result = result * 2 + int(addr1 > addr2) result = result * 2 + int(addr1 >= addr2) return result
def do_malloc_fixedsize_clear(self, RESTYPE, type_id, size, has_finalizer, has_light_finalizer, contains_weakptr): assert not contains_weakptr assert not has_finalizer # in these tests assert not has_light_finalizer # in these tests p = llmemory.raw_malloc(size) p = llmemory.cast_adr_to_ptr(p, RESTYPE) tid = llop.combine_ushort(lltype.Signed, type_id, 0) self.record.append(("fixedsize", repr(size), tid, p)) return p
def test_remove(self): AddressStack = get_address_stack() addrs = [raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(2200)] ll = AddressStack() for i in range(2200): ll.append(addrs[i]) ll.remove(addrs[-400]) expected = range(2200) del expected[-400] expected.reverse() for i in expected: a = ll.pop() assert a == addrs[i] assert not ll.non_empty()
def test_big_access(self): import random AddressDeque = get_address_deque(10) deque = AddressDeque() expected = [] for i in range(3000): assert deque.non_empty() == (len(expected) > 0) r = random.random() if r < 0.51 and expected: x = deque.popleft() y = expected.pop(0) assert x == y else: x = raw_malloc(llmemory.sizeof(lltype.Signed)) deque.append(x) expected.append(x)
def test_foreach(self): AddressStack = get_address_stack() addrs = [raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(3000)] ll = AddressStack() for i in range(3000): ll.append(addrs[i]) seen = [] def callback(addr, fortytwo): assert fortytwo == 42 seen.append(addr) ll.foreach(callback, 42) assert seen == addrs or seen[::-1] == addrs # order not guaranteed
def test_foreach(self): AddressDeque = get_address_deque(10) ll = AddressDeque() for num_entries in range(30, -1, -1): addrs = [raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(num_entries)] for a in addrs: ll.append(a) seen = [] def callback(addr, fortytwo): assert fortytwo == 42 seen.append(addr) ll.foreach(callback, 42) assert seen == addrs for a in addrs: b = ll.popleft() assert a == b assert not ll.non_empty()
def test_big_access(self): AddressStack = get_address_stack() addrs = [raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(3000)] ll = AddressStack() for i in range(3000): print i ll.append(addrs[i]) for i in range(3000)[::-1]: a = ll.pop() assert a == addrs[i] for i in range(3000): print i ll.append(addrs[i]) for i in range(3000)[::-1]: a = ll.pop() assert a == addrs[i] ll.delete() for addr in addrs: raw_free(addr)
def build_stack_root_iterator(self): xxx from pypy.rlib.rstack import stack_capture sizeofaddr = llmemory.sizeof(llmemory.Address) gcdata = self.gcdata captured_frame_holder = llmemory.raw_malloc(sizeofaddr) captured_frame_holder.address[0] = llmemory.NULL class StackRootIterator: _alloc_flavor_ = 'raw' def setup_root_stack(): pass setup_root_stack = staticmethod(setup_root_stack) need_root_stack = False def __init__(self): # XXX what should be done with the stack_capture()d frames # when we are finished? what about moving GCs? frame = llmemory.cast_ptr_to_adr(stack_capture()) self.static_current = gcdata.static_root_start captured_frame_holder.address[0] = frame self.finished = False def pop(self): while self.static_current != gcdata.static_root_end: result = self.static_current self.static_current += sizeofaddr if result.address[0].address[0] != llmemory.NULL: return result.address[0] if not self.finished: self.finished = True return captured_frame_holder return llmemory.NULL return StackRootIterator
def test_foreach(self): AddressDeque = get_address_deque(10) ll = AddressDeque() for num_entries in range(30, -1, -1): addrs = [ raw_malloc(llmemory.sizeof(lltype.Signed)) for i in range(num_entries) ] for a in addrs: ll.append(a) seen = [] def callback(addr, fortytwo): assert fortytwo == 42 seen.append(addr) ll.foreach(callback, 42) assert seen == addrs for a in addrs: b = ll.popleft() assert a == b assert not ll.non_empty()
def _prepare_unused_stack(self): if self.unused_full_stack == llmemory.NULL: root_stack_size = sizeofaddr * self.root_stack_depth self.unused_full_stack = llmemory.raw_malloc(root_stack_size) if self.unused_full_stack == llmemory.NULL: raise MemoryError
def alloc1(): return llmemory.raw_malloc(16)
def f(value): addr = llmemory.raw_malloc(16) addr.signed[0] = value res = addr.signed[0] llmemory.raw_free(addr) return res
def __init__(self): self.addr = llmemory.raw_malloc(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 allocate_external_object(self, totalsize): # XXX maybe we should use arena_malloc() above a certain size? # If so, we'd also use arena_reset() in malloc_varsize_marknsweep(). return llmemory.raw_malloc(totalsize)
def allocate_stack(self): result = llmemory.raw_malloc(self.rootstacksize) if result: llmemory.raw_memclear(result, self.rootstacksize) return result
def complex_struct(): adr = llmemory.raw_malloc(sizeofsbase) s = llmemory.cast_adr_to_ptr(adr, SBASEPTR) s.b.s2.a = 42 return (adr + offset_toa).signed[0]
def op_raw_malloc(self, size): assert lltype.typeOf(size) == lltype.Signed return llmemory.raw_malloc(size)
def llimpl_arena_malloc(nbytes, zero): addr = llmemory.raw_malloc(nbytes) if zero and bool(addr): clear_large_memory_chunk(addr, nbytes) return addr
def _malloc(self, type_id, size): tid = llop.combine_ushort(lltype.Signed, type_id, 0) x = llmemory.raw_malloc(self.gcheaderbuilder.size_gc_header + size) x += self.gcheaderbuilder.size_gc_header return x, tid
def allocate_stack(self): return llmemory.raw_malloc(self.rootstacksize)