def test_constfold(): layoutbuilder = TypeLayoutBuilder(FakeGC) tid1 = layoutbuilder.get_type_id(GC_A) tid2 = layoutbuilder.get_type_id(GC_S3) class MockGC: def set_query_functions(self, is_varsize, has_gcptr_in_varsize, is_gcarrayofgcptr, *rest): self.is_varsize = is_varsize self.has_gcptr_in_varsize = has_gcptr_in_varsize self.is_gcarrayofgcptr = is_gcarrayofgcptr gc = MockGC() layoutbuilder.initialize_gc_query_function(gc) # def f(): return (1 * gc.is_varsize(tid1) + 10 * gc.has_gcptr_in_varsize(tid1) + 100 * gc.is_gcarrayofgcptr(tid1) + 1000 * gc.is_varsize(tid2) + 10000 * gc.has_gcptr_in_varsize(tid2) + 100000 * gc.is_gcarrayofgcptr(tid2)) interp, graph = get_interpreter(f, [], backendopt=True) assert interp.eval_graph(graph, []) == 11001 assert graph.startblock.exits[0].args == [Constant(11001, lltype.Signed)]
def test_layout_builder(): # XXX a very minimal test layoutbuilder = TypeLayoutBuilder() for T1, T2 in [(GC_A, GC_S), (GC_A2, GC_S2), (GC_S3, GC_S2)]: tid1 = layoutbuilder.get_type_id(T1) tid2 = layoutbuilder.get_type_id(T2) gcdata = GCData(layoutbuilder.type_info_list) lst1 = gcdata.q_varsize_offsets_to_gcpointers_in_var_part(tid1) lst2 = gcdata.q_offsets_to_gc_pointers(tid2) assert len(lst1) == len(lst2)
def setup_method(self, meth): self.stackroots = [] self.gc = self.GCClass(**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 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 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()
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))
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 test_constfold(): layoutbuilder = TypeLayoutBuilder(FakeGC, {}) tid1 = layoutbuilder.get_type_id(GC_A) tid2 = layoutbuilder.get_type_id(GC_S3) class MockGC: def set_query_functions(self, is_varsize, has_gcptr_in_varsize, is_gcarrayofgcptr, *rest): self.is_varsize = is_varsize self.has_gcptr_in_varsize = has_gcptr_in_varsize self.is_gcarrayofgcptr = is_gcarrayofgcptr gc = MockGC() layoutbuilder.initialize_gc_query_function(gc) # def f(): return (1 * gc.is_varsize(tid1) + 10 * gc.has_gcptr_in_varsize(tid1) + 100 * gc.is_gcarrayofgcptr(tid1) + 1000 * gc.is_varsize(tid2) + 10000 * gc.has_gcptr_in_varsize(tid2) + 100000 * gc.is_gcarrayofgcptr(tid2)) interp, graph = get_interpreter(f, [], backendopt=True) assert interp.eval_graph(graph, []) == 11001 assert graph.startblock.exits[0].args == [Constant(11001, lltype.Signed)]
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()