def __init__(self, chunk_size=DEFAULT_CHUNK_SIZE, start_heap_size=4096):
self.heap_usage = 0 # at the end of the latest collection
self.bytes_malloced = 0 # since the latest collection
self.bytes_malloced_threshold = start_heap_size
self.total_collection_time = 0.0
self.AddressStack = get_address_stack(chunk_size)
self.malloced_objects = lltype.nullptr(self.HDR)
self.malloced_objects_with_finalizer = lltype.nullptr(self.HDR)
# these are usually only the small bits of memory that make a
# weakref object
self.objects_with_weak_pointers = lltype.nullptr(self.HDR)
self.gcheaderbuilder = GCHeaderBuilder(self.HDR)
# pools, for x_swap_pool():
# 'curpool' is the current pool, lazily allocated (i.e. NULL means
# the current POOL object is not yet malloc'ed). POOL objects are
# usually at the start of a linked list of objects, via the HDRs.
# The exception is 'curpool' whose linked list of objects is in
# 'self.malloced_objects' instead of in the header of 'curpool'.
# POOL objects are never in the middle of a linked list themselves.
# XXX a likely cause for the current problems with pools is:
# not all objects live in malloced_objects, some also live in
# malloced_objects_with_finalizer and objects_with_weak_pointers
self.curpool = lltype.nullptr(self.POOL)
# 'poolnodes' is a linked list of all such linked lists. Each
# linked list will usually start with a POOL object, but it can
# also contain only normal objects if the POOL object at the head
# was already freed. The objects in 'malloced_objects' are not
# found via 'poolnodes'.
self.poolnodes = lltype.nullptr(self.POOLNODE)
self.collect_in_progress = False
self.prev_collect_end_time = 0.0
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 __init__(self, chunk_size=DEFAULT_CHUNK_SIZE, start_heap_size=4096):
self.heap_usage = 0 # at the end of the latest collection
self.bytes_malloced = 0 # since the latest collection
self.bytes_malloced_threshold = start_heap_size
self.total_collection_time = 0.0
self.AddressStack = get_address_stack(chunk_size)
self.malloced_objects = lltype.nullptr(self.HDR)
self.malloced_objects_with_finalizer = lltype.nullptr(self.HDR)
# these are usually only the small bits of memory that make a
# weakref object
self.objects_with_weak_pointers = lltype.nullptr(self.HDR)
self.gcheaderbuilder = GCHeaderBuilder(self.HDR)
# pools, for x_swap_pool():
# 'curpool' is the current pool, lazily allocated (i.e. NULL means
# the current POOL object is not yet malloc'ed). POOL objects are
# usually at the start of a linked list of objects, via the HDRs.
# The exception is 'curpool' whose linked list of objects is in
# 'self.malloced_objects' instead of in the header of 'curpool'.
# POOL objects are never in the middle of a linked list themselves.
# XXX a likely cause for the current problems with pools is:
# not all objects live in malloced_objects, some also live in
# malloced_objects_with_finalizer and objects_with_weak_pointers
self.curpool = lltype.nullptr(self.POOL)
# 'poolnodes' is a linked list of all such linked lists. Each
# linked list will usually start with a POOL object, but it can
# also contain only normal objects if the POOL object at the head
# was already freed. The objects in 'malloced_objects' are not
# found via 'poolnodes'.
self.poolnodes = lltype.nullptr(self.POOLNODE)
self.collect_in_progress = False
self.prev_collect_end_time = 0.0
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 __init__(self, config, chunk_size=DEFAULT_CHUNK_SIZE):
self.gcheaderbuilder = GCHeaderBuilder(self.HDR)
self.AddressStack = get_address_stack(chunk_size)
self.AddressDeque = get_address_deque(chunk_size)
self.AddressDict = AddressDict
self.finalizer_lock_count = 0
self.config = config
def __init__(self, config, chunk_size=DEFAULT_CHUNK_SIZE,
translated_to_c=True):
self.gcheaderbuilder = GCHeaderBuilder(self.HDR)
self.AddressStack = get_address_stack(chunk_size)
self.AddressDeque = get_address_deque(chunk_size)
self.AddressDict = AddressDict
self.null_address_dict = null_address_dict
self.config = config
assert isinstance(translated_to_c, bool)
self.translated_to_c = translated_to_c
def __init__(self, chunk_size=DEFAULT_CHUNK_SIZE, space_size=4096,
max_space_size=sys.maxint//2+1):
MovingGCBase.__init__(self)
self.space_size = space_size
self.max_space_size = max_space_size
self.gcheaderbuilder = GCHeaderBuilder(self.HDR)
self.AddressStack = get_address_stack(chunk_size)
self.AddressDeque = get_address_deque(chunk_size)
self.finalizer_lock_count = 0
self.red_zone = 0
def test_stack_annotate():
AddressStack = get_address_stack(60)
INT_SIZE = llmemory.sizeof(lltype.Signed)
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
assert f()
AddressStack = get_address_stack()
res = interpret(f, [], malloc_check=False)
assert res
def test_stack_annotate():
AddressStack = get_address_stack(60)
INT_SIZE = llmemory.sizeof(lltype.Signed)
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
assert f()
AddressStack = get_address_stack()
res = interpret(f, [], malloc_check=False)
assert res
def __init__(self,
config,
chunk_size=DEFAULT_CHUNK_SIZE,
translated_to_c=True):
self.gcheaderbuilder = GCHeaderBuilder(self.HDR)
self.AddressStack = get_address_stack(chunk_size)
self.AddressDeque = get_address_deque(chunk_size)
self.AddressDict = AddressDict
self.null_address_dict = null_address_dict
self.config = config
assert isinstance(translated_to_c, bool)
self.translated_to_c = translated_to_c
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_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_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):
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_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 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 __init__(self, config, chunk_size=DEFAULT_CHUNK_SIZE):
self.gcheaderbuilder = GCHeaderBuilder(self.HDR)
self.AddressStack = get_address_stack(chunk_size)
self.AddressDeque = get_address_deque(chunk_size)
self.AddressDict = AddressDict
self.config = config
def get_rpy_type_index(gc, gcref):
typeid = gc.get_type_id(llmemory.cast_ptr_to_adr(gcref))
return gc.get_member_index(typeid)
def is_rpy_instance(gc, gcref):
typeid = gc.get_type_id(llmemory.cast_ptr_to_adr(gcref))
return gc.is_rpython_class(typeid)
# ----------
raw_os_write = rffi.llexternal(underscore_on_windows+'write',
[rffi.INT, llmemory.Address, rffi.SIZE_T],
rffi.SIZE_T,
sandboxsafe=True, _nowrapper=True)
AddressStack = get_address_stack()
class HeapDumper(object):
_alloc_flavor_ = "raw"
BUFSIZE = 8192 # words
def __init__(self, gc, fd):
self.gc = gc
self.gcflag = gc.gcflag_extra
self.fd = rffi.cast(rffi.INT, fd)
self.writebuffer = lltype.malloc(rffi.LONGP.TO, self.BUFSIZE,
flavor='raw')
self.buf_count = 0
if self.gcflag == 0:
self.seen = AddressDict()
self.pending = AddressStack()
