class BaseDirectGCTest(object):
GC_PARAMS = {}
def setup_method(self, meth):
from pypy.config.pypyoption import get_pypy_config
config = get_pypy_config(translating=True).translation
self.stackroots = []
GC_PARAMS = self.GC_PARAMS.copy()
if hasattr(meth, 'GC_PARAMS'):
GC_PARAMS.update(meth.GC_PARAMS)
GC_PARAMS['translated_to_c'] = False
self.gc = self.GCClass(config, **GC_PARAMS)
self.gc.DEBUG = True
self.rootwalker = DirectRootWalker(self)
self.gc.set_root_walker(self.rootwalker)
self.layoutbuilder = TypeLayoutBuilder(self.GCClass)
self.get_type_id = self.layoutbuilder.get_type_id
self.layoutbuilder.initialize_gc_query_function(self.gc)
self.gc.setup()
def consider_constant(self, p):
obj = p._obj
TYPE = lltype.typeOf(obj)
self.layoutbuilder.consider_constant(TYPE, obj, self.gc)
def write(self, p, fieldname, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
self.gc.write_barrier(newaddr, addr_struct)
setattr(p, fieldname, newvalue)
def writearray(self, p, index, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
if hasattr(self.gc, 'write_barrier_from_array'):
self.gc.write_barrier_from_array(newaddr, addr_struct, index)
else:
self.gc.write_barrier(newaddr, addr_struct)
p[index] = newvalue
def malloc(self, TYPE, n=None):
addr = self.gc.malloc(self.get_type_id(TYPE), n, zero=True)
return llmemory.cast_adr_to_ptr(addr, lltype.Ptr(TYPE))
class BaseDirectGCTest(object):
GC_PARAMS = {}
def setup_method(self, meth):
from pypy.config.pypyoption import get_pypy_config
config = get_pypy_config(translating=True).translation
self.stackroots = []
GC_PARAMS = self.GC_PARAMS.copy()
if hasattr(meth, 'GC_PARAMS'):
GC_PARAMS.update(meth.GC_PARAMS)
GC_PARAMS['translated_to_c'] = False
self.gc = self.GCClass(config, **GC_PARAMS)
self.gc.DEBUG = True
self.rootwalker = DirectRootWalker(self)
self.gc.set_root_walker(self.rootwalker)
self.layoutbuilder = TypeLayoutBuilder(self.GCClass)
self.get_type_id = self.layoutbuilder.get_type_id
self.layoutbuilder.initialize_gc_query_function(self.gc)
self.gc.setup()
def consider_constant(self, p):
obj = p._obj
TYPE = lltype.typeOf(obj)
self.layoutbuilder.consider_constant(TYPE, obj, self.gc)
def write(self, p, fieldname, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
self.gc.write_barrier(newaddr, addr_struct)
setattr(p, fieldname, newvalue)
def writearray(self, p, index, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
if hasattr(self.gc, 'write_barrier_from_array'):
self.gc.write_barrier_from_array(newaddr, addr_struct, index)
else:
self.gc.write_barrier(newaddr, addr_struct)
p[index] = newvalue
def malloc(self, TYPE, n=None):
addr = self.gc.malloc(self.get_type_id(TYPE), n, zero=True)
return llmemory.cast_adr_to_ptr(addr, lltype.Ptr(TYPE))
class DirectGCTest(object):
GC_PARAMS = {}
def setup_method(self, meth):
from pypy.config.pypyoption import get_pypy_config
config = get_pypy_config(translating=True).translation
self.stackroots = []
self.gc = self.GCClass(config, **self.GC_PARAMS)
self.gc.DEBUG = True
self.rootwalker = DirectRootWalker(self)
self.gc.set_root_walker(self.rootwalker)
self.layoutbuilder = TypeLayoutBuilder()
self.get_type_id = self.layoutbuilder.get_type_id
self.layoutbuilder.initialize_gc_query_function(self.gc)
self.gc.setup()
def consider_constant(self, p):
obj = p._obj
TYPE = lltype.typeOf(obj)
self.layoutbuilder.consider_constant(TYPE, obj, self.gc)
def write(self, p, fieldname, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
self.gc.write_barrier(newaddr, addr_struct)
setattr(p, fieldname, newvalue)
def writearray(self, p, index, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
self.gc.write_barrier(newaddr, addr_struct)
p[index] = newvalue
def malloc(self, TYPE, n=None):
addr = self.gc.malloc(self.get_type_id(TYPE), n)
return llmemory.cast_adr_to_ptr(addr, lltype.Ptr(TYPE))
def test_simple(self):
p = self.malloc(S)
p.x = 5
self.stackroots.append(p)
self.gc.collect()
p = self.stackroots[0]
assert p.x == 5
def test_missing_stack_root(self):
p = self.malloc(S)
p.x = 5
self.gc.collect() # 'p' should go away
py.test.raises(RuntimeError, 'p.x')
def test_prebuilt_gc(self):
k = lltype.malloc(S, immortal=True)
k.x = 42
self.consider_constant(k)
self.write(k, 'next', self.malloc(S))
k.next.x = 43
self.write(k.next, 'next', self.malloc(S))
k.next.next.x = 44
self.gc.collect()
assert k.x == 42
assert k.next.x == 43
assert k.next.next.x == 44
def test_prebuilt_nongc(self):
raw = lltype.malloc(RAW, immortal=True)
self.consider_constant(raw)
raw.p = self.malloc(S)
raw.p.x = 43
raw.q = self.malloc(S)
raw.q.x = 44
self.gc.collect()
assert raw.p.x == 43
assert raw.q.x == 44
def test_many_objects(self):
def alloc2(i):
a1 = self.malloc(S)
a1.x = i
self.stackroots.append(a1)
a2 = self.malloc(S)
a1 = self.stackroots.pop()
a2.x = i + 1000
return a1, a2
def growloop(loop, a1, a2):
self.write(a1, 'prev', loop.prev)
self.write(a1.prev, 'next', a1)
self.write(a1, 'next', loop)
self.write(loop, 'prev', a1)
self.write(a2, 'prev', loop)
self.write(a2, 'next', loop.next)
self.write(a2.next, 'prev', a2)
self.write(loop, 'next', a2)
def newloop():
p = self.malloc(S)
p.next = p # initializing stores, no write barrier
p.prev = p
return p
# a loop attached to a stack root
self.stackroots.append(newloop())
# another loop attached to a prebuilt gc node
k = lltype.malloc(S, immortal=True)
k.next = k
k.prev = k
self.consider_constant(k)
# a third loop attached to a prebuilt nongc
raw = lltype.malloc(RAW, immortal=True)
self.consider_constant(raw)
raw.p = newloop()
# run!
for i in range(100):
a1, a2 = alloc2(i)
growloop(self.stackroots[0], a1, a2)
a1, a2 = alloc2(i)
growloop(k, a1, a2)
a1, a2 = alloc2(i)
growloop(raw.p, a1, a2)
def test_varsized_from_stack(self):
expected = {}
def verify():
for (index, index2), value in expected.items():
assert self.stackroots[index][index2].x == value
x = 0
for i in range(40):
self.stackroots.append(self.malloc(VAR, i))
for j in range(5):
p = self.malloc(S)
p.x = x
index = x % len(self.stackroots)
if index > 0:
index2 = (x / len(self.stackroots)) % index
a = self.stackroots[index]
assert len(a) == index
self.writearray(a, index2, p)
expected[index, index2] = x
x += 1291
verify()
self.gc.collect()
verify()
self.gc.collect()
verify()
def test_varsized_from_prebuilt_gc(self):
expected = {}
def verify():
for (index, index2), value in expected.items():
assert prebuilt[index].a[index2].x == value
x = 0
prebuilt = [lltype.malloc(VARNODE, immortal=True, zero=True)
for i in range(40)]
for node in prebuilt:
self.consider_constant(node)
for i in range(len(prebuilt)):
self.write(prebuilt[i], 'a', self.malloc(VAR, i))
for j in range(20):
p = self.malloc(S)
p.x = x
index = x % (i+1)
if index > 0:
index2 = (x / (i+1)) % index
a = prebuilt[index].a
assert len(a) == index
self.writearray(a, index2, p)
expected[index, index2] = x
x += 1291
verify()
self.gc.collect()
verify()
self.gc.collect()
verify()
def test_id(self):
ids = {}
def allocate_bunch(count=50):
base = len(self.stackroots)
for i in range(count):
p = self.malloc(S)
self.stackroots.append(p)
for i in range(count):
j = base + (i*1291) % count
pid = self.gc.id(self.stackroots[j])
assert isinstance(pid, int)
ids[j] = pid
def verify():
for j, expected in ids.items():
assert self.gc.id(self.stackroots[j]) == expected
allocate_bunch(5)
verify()
allocate_bunch(75)
verify()
allocate_bunch(5)
verify()
self.gc.collect()
verify()
self.gc.collect()
verify()
class DirectGCTest(object):
GC_PARAMS = {}
def setup_method(self, meth):
from pypy.config.pypyoption import get_pypy_config
config = get_pypy_config(translating=True).translation
self.stackroots = []
self.gc = self.GCClass(config, **self.GC_PARAMS)
self.gc.DEBUG = True
self.rootwalker = DirectRootWalker(self)
self.gc.set_root_walker(self.rootwalker)
self.layoutbuilder = TypeLayoutBuilder(self.GCClass, {})
self.get_type_id = self.layoutbuilder.get_type_id
self.layoutbuilder.initialize_gc_query_function(self.gc)
self.gc.setup()
def consider_constant(self, p):
obj = p._obj
TYPE = lltype.typeOf(obj)
self.layoutbuilder.consider_constant(TYPE, obj, self.gc)
def write(self, p, fieldname, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
self.gc.write_barrier(newaddr, addr_struct)
setattr(p, fieldname, newvalue)
def writearray(self, p, index, newvalue):
if self.gc.needs_write_barrier:
newaddr = llmemory.cast_ptr_to_adr(newvalue)
addr_struct = llmemory.cast_ptr_to_adr(p)
self.gc.write_barrier(newaddr, addr_struct)
p[index] = newvalue
def malloc(self, TYPE, n=None):
addr = self.gc.malloc(self.get_type_id(TYPE), n)
return llmemory.cast_adr_to_ptr(addr, lltype.Ptr(TYPE))
def test_simple(self):
p = self.malloc(S)
p.x = 5
self.stackroots.append(p)
self.gc.collect()
p = self.stackroots[0]
assert p.x == 5
def test_missing_stack_root(self):
p = self.malloc(S)
p.x = 5
self.gc.collect() # 'p' should go away
py.test.raises(RuntimeError, 'p.x')
def test_prebuilt_gc(self):
k = lltype.malloc(S, immortal=True)
k.x = 42
self.consider_constant(k)
self.write(k, 'next', self.malloc(S))
k.next.x = 43
self.write(k.next, 'next', self.malloc(S))
k.next.next.x = 44
self.gc.collect()
assert k.x == 42
assert k.next.x == 43
assert k.next.next.x == 44
def test_prebuilt_nongc(self):
raw = lltype.malloc(RAW, immortal=True)
self.consider_constant(raw)
raw.p = self.malloc(S)
raw.p.x = 43
raw.q = self.malloc(S)
raw.q.x = 44
self.gc.collect()
assert raw.p.x == 43
assert raw.q.x == 44
def test_many_objects(self):
def alloc2(i):
a1 = self.malloc(S)
a1.x = i
self.stackroots.append(a1)
a2 = self.malloc(S)
a1 = self.stackroots.pop()
a2.x = i + 1000
return a1, a2
def growloop(loop, a1, a2):
self.write(a1, 'prev', loop.prev)
self.write(a1.prev, 'next', a1)
self.write(a1, 'next', loop)
self.write(loop, 'prev', a1)
self.write(a2, 'prev', loop)
self.write(a2, 'next', loop.next)
self.write(a2.next, 'prev', a2)
self.write(loop, 'next', a2)
def newloop():
p = self.malloc(S)
p.next = p # initializing stores, no write barrier
p.prev = p
return p
# a loop attached to a stack root
self.stackroots.append(newloop())
# another loop attached to a prebuilt gc node
k = lltype.malloc(S, immortal=True)
k.next = k
k.prev = k
self.consider_constant(k)
# a third loop attached to a prebuilt nongc
raw = lltype.malloc(RAW, immortal=True)
self.consider_constant(raw)
raw.p = newloop()
# run!
for i in range(100):
a1, a2 = alloc2(i)
growloop(self.stackroots[0], a1, a2)
a1, a2 = alloc2(i)
growloop(k, a1, a2)
a1, a2 = alloc2(i)
growloop(raw.p, a1, a2)
def test_varsized_from_stack(self):
expected = {}
def verify():
for (index, index2), value in expected.items():
assert self.stackroots[index][index2].x == value
x = 0
for i in range(40):
self.stackroots.append(self.malloc(VAR, i))
for j in range(5):
p = self.malloc(S)
p.x = x
index = x % len(self.stackroots)
if index > 0:
index2 = (x / len(self.stackroots)) % index
a = self.stackroots[index]
assert len(a) == index
self.writearray(a, index2, p)
expected[index, index2] = x
x += 1291
verify()
self.gc.collect()
verify()
self.gc.collect()
verify()
def test_varsized_from_prebuilt_gc(self):
expected = {}
def verify():
for (index, index2), value in expected.items():
assert prebuilt[index].a[index2].x == value
x = 0
prebuilt = [lltype.malloc(VARNODE, immortal=True, zero=True)
for i in range(40)]
for node in prebuilt:
self.consider_constant(node)
for i in range(len(prebuilt)):
self.write(prebuilt[i], 'a', self.malloc(VAR, i))
for j in range(20):
p = self.malloc(S)
p.x = x
index = x % (i+1)
if index > 0:
index2 = (x / (i+1)) % index
a = prebuilt[index].a
assert len(a) == index
self.writearray(a, index2, p)
expected[index, index2] = x
x += 1291
verify()
self.gc.collect()
verify()
self.gc.collect()
verify()
def test_id(self):
ids = {}
def allocate_bunch(count=50):
base = len(self.stackroots)
for i in range(count):
p = self.malloc(S)
self.stackroots.append(p)
for i in range(count):
j = base + (i*1291) % count
pid = self.gc.id(self.stackroots[j])
assert isinstance(pid, int)
ids[j] = pid
def verify():
for j, expected in ids.items():
assert self.gc.id(self.stackroots[j]) == expected
allocate_bunch(5)
verify()
allocate_bunch(75)
verify()
allocate_bunch(5)
verify()
self.gc.collect()
verify()
self.gc.collect()
verify()
