def test_address_order():
a = arena_malloc(20, False)
assert eq(a, a)
assert lt(a, a+1)
assert lt(a+5, a+20)
b = arena_malloc(20, False)
if a > b:
a, b = b, a
assert lt(a, b)
assert lt(a+19, b)
assert lt(a, b+19)
c = b + round_up_for_allocation(llmemory.sizeof(lltype.Char))
arena_reserve(c, precomputed_size)
assert lt(b, c)
assert lt(a, c)
assert lt(llmemory.NULL, c)
d = c + llmemory.offsetof(SX, 'x')
assert lt(c, d)
assert lt(b, d)
assert lt(a, d)
assert lt(llmemory.NULL, d)
e = c + precomputed_size
assert lt(d, e)
assert lt(c, e)
assert lt(b, e)
assert lt(a, e)
assert lt(llmemory.NULL, e)
def double_space_size(self):
self.red_zone = 0
old_fromspace = self.fromspace
newsize = self.space_size * 2
newspace = llarena.arena_malloc(newsize, True)
if not newspace:
return False # out of memory
llarena.arena_free(old_fromspace)
self.fromspace = newspace
# now self.tospace contains the existing objects and
# self.fromspace is the freshly allocated bigger space
self.semispace_collect(size_changing=True)
self.top_of_space = self.tospace + newsize
# now self.tospace is the freshly allocated bigger space,
# and self.fromspace is the old smaller space, now empty
llarena.arena_free(self.fromspace)
newspace = llarena.arena_malloc(newsize, True)
if not newspace:
# Complex failure case: we have in self.tospace a big chunk
# of memory, and the two smaller original spaces are already gone.
# Unsure if it's worth these efforts, but we can artificially
# split self.tospace in two again...
self.max_space_size = self.space_size # don't try to grow again,
# because doing arena_free(self.fromspace) would crash
self.fromspace = self.tospace + self.space_size
self.top_of_space = self.fromspace
ll_assert(self.free <= self.top_of_space,
"unexpected growth of GC space usage during collect")
return False # out of memory
self.fromspace = newspace
self.space_size = newsize
return True # success
def double_space_size(self):
self.red_zone = 0
old_fromspace = self.fromspace
newsize = self.space_size * 2
newspace = llarena.arena_malloc(newsize, True)
if not newspace:
return False # out of memory
llarena.arena_free(old_fromspace)
self.fromspace = newspace
# now self.tospace contains the existing objects and
# self.fromspace is the freshly allocated bigger space
self.semispace_collect(size_changing=True)
self.top_of_space = self.tospace + newsize
# now self.tospace is the freshly allocated bigger space,
# and self.fromspace is the old smaller space, now empty
llarena.arena_free(self.fromspace)
newspace = llarena.arena_malloc(newsize, True)
if not newspace:
# Complex failure case: we have in self.tospace a big chunk
# of memory, and the two smaller original spaces are already gone.
# Unsure if it's worth these efforts, but we can artificially
# split self.tospace in two again...
self.max_space_size = self.space_size # don't try to grow again,
# because doing arena_free(self.fromspace) would crash
self.fromspace = self.tospace + self.space_size
self.top_of_space = self.fromspace
ll_assert(self.free <= self.top_of_space,
"unexpected growth of GC space usage during collect")
return False # out of memory
self.fromspace = newspace
self.space_size = newsize
return True # success
def test_address_order():
a = arena_malloc(24, False)
assert eq(a, a)
assert lt(a, a + 1)
assert lt(a + 5, a + 20)
b = arena_malloc(24, False)
if a > b:
a, b = b, a
assert lt(a, b)
assert lt(a + 19, b)
assert lt(a, b + 19)
c = b + round_up_for_allocation(llmemory.sizeof(lltype.Char))
arena_reserve(c, precomputed_size)
assert lt(b, c)
assert lt(a, c)
assert lt(llmemory.NULL, c)
d = c + llmemory.offsetof(SX, 'x')
assert lt(c, d)
assert lt(b, d)
assert lt(a, d)
assert lt(llmemory.NULL, d)
e = c + precomputed_size
assert lt(d, e)
assert lt(c, e)
assert lt(b, e)
assert lt(a, e)
assert lt(llmemory.NULL, e)
def setup(self):
if self.config.gcconfig.debugprint:
self.program_start_time = time.time()
self.tospace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.tospace), "couldn't allocate tospace")
self.top_of_space = self.tospace + self.space_size
self.fromspace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.fromspace), "couldn't allocate fromspace")
self.free = self.tospace
MovingGCBase.setup(self)
self.objects_with_finalizers = self.AddressDeque()
self.objects_with_weakrefs = self.AddressStack()
def setup(self):
if DEBUG_PRINT:
import time
self.program_start_time = time.time()
self.tospace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.tospace), "couldn't allocate tospace")
self.top_of_space = self.tospace + self.space_size
self.fromspace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.fromspace), "couldn't allocate fromspace")
self.free = self.tospace
self.objects_with_finalizers = self.AddressDeque()
self.run_finalizers = self.AddressDeque()
self.objects_with_weakrefs = self.AddressStack()
def setup(self):
#self.total_collection_time = 0.0
self.total_collection_count = 0
self.space_size = self.param_space_size
self.max_space_size = self.param_max_space_size
self.red_zone = 0
#self.program_start_time = time.time()
self.tospace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.tospace), "couldn't allocate tospace")
self.top_of_space = self.tospace + self.space_size
self.fromspace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.fromspace), "couldn't allocate fromspace")
self.free = self.tospace
MovingGCBase.setup(self)
self.objects_with_finalizers = self.AddressDeque()
self.objects_with_weakrefs = self.AddressStack()
def setup(self):
#self.total_collection_time = 0.0
self.total_collection_count = 0
self.space_size = self.param_space_size
self.max_space_size = self.param_max_space_size
self.red_zone = 0
#self.program_start_time = time.time()
self.tospace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.tospace), "couldn't allocate tospace")
self.top_of_space = self.tospace + self.space_size
self.fromspace = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.fromspace), "couldn't allocate fromspace")
self.free = self.tospace
MovingGCBase.setup(self)
self.objects_with_finalizers = self.AddressDeque()
self.objects_with_weakrefs = self.AddressStack()
def setup(self):
if self.config.gcconfig.debugprint:
self.program_start_time = time.time()
self.space = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.space), "couldn't allocate arena")
self.free = self.space
self.top_of_space = self.space + self.next_collect_after
MovingGCBase.setup(self)
self.objects_with_finalizers = self.AddressDeque()
self.objects_with_weakrefs = self.AddressStack()
self.tid_backup = lltype.nullptr(self.TID_BACKUP)
def test_shrink_obj():
from pypy.rpython.memory.gcheader import GCHeaderBuilder
HDR = lltype.Struct('HDR', ('h', lltype.Signed))
gcheaderbuilder = GCHeaderBuilder(HDR)
size_gc_header = gcheaderbuilder.size_gc_header
S = lltype.GcStruct('S', ('x', lltype.Signed),
('a', lltype.Array(lltype.Signed)))
myarenasize = 200
a = arena_malloc(myarenasize, False)
arena_reserve(a, size_gc_header + llmemory.sizeof(S, 10))
arena_shrink_obj(a, size_gc_header + llmemory.sizeof(S, 5))
arena_reset(a, size_gc_header + llmemory.sizeof(S, 5), False)
def test_shrink_obj():
from pypy.rpython.memory.gcheader import GCHeaderBuilder
HDR = lltype.Struct('HDR', ('h', lltype.Signed))
gcheaderbuilder = GCHeaderBuilder(HDR)
size_gc_header = gcheaderbuilder.size_gc_header
S = lltype.GcStruct('S', ('x', lltype.Signed),
('a', lltype.Array(lltype.Signed)))
myarenasize = 200
a = arena_malloc(myarenasize, False)
arena_reserve(a, size_gc_header + llmemory.sizeof(S, 10))
arena_shrink_obj(a, size_gc_header + llmemory.sizeof(S, 5))
arena_reset(a, size_gc_header + llmemory.sizeof(S, 5), False)
def test_address_eq_as_int():
a = arena_malloc(50, False)
arena_reserve(a, precomputed_size)
p = llmemory.cast_adr_to_ptr(a, SPTR)
a1 = llmemory.cast_ptr_to_adr(p)
assert a == a1
assert not (a != a1)
assert (a + 1) != a1
assert not ((a + 1) == a1)
py.test.skip("cast_adr_to_int() is hard to get consistent")
assert llmemory.cast_adr_to_int(a) == llmemory.cast_adr_to_int(a1)
assert llmemory.cast_adr_to_int(a + 1) == llmemory.cast_adr_to_int(a1) + 1
def test_address_eq_as_int():
a = arena_malloc(50, False)
arena_reserve(a, precomputed_size)
p = llmemory.cast_adr_to_ptr(a, SPTR)
a1 = llmemory.cast_ptr_to_adr(p)
assert a == a1
assert not (a != a1)
assert (a+1) != a1
assert not ((a+1) == a1)
py.test.skip("cast_adr_to_int() is hard to get consistent")
assert llmemory.cast_adr_to_int(a) == llmemory.cast_adr_to_int(a1)
assert llmemory.cast_adr_to_int(a+1) == llmemory.cast_adr_to_int(a1) + 1
def setup(self):
self.space_size = self.param_space_size
self.next_collect_after = self.param_space_size / 2 # whatever...
if self.config.gcconfig.debugprint:
self.program_start_time = time.time()
self.space = llarena.arena_malloc(self.space_size, True)
ll_assert(bool(self.space), "couldn't allocate arena")
self.free = self.space
self.top_of_space = self.space + self.next_collect_after
MovingGCBase.setup(self)
self.objects_with_finalizers = self.AddressDeque()
self.objects_with_weakrefs = self.AddressStack()
self.tid_backup = lltype.nullptr(self.TID_BACKUP)
def test_partial_arena_reset():
a = arena_malloc(72, False)
def reserve(i):
b = a + i * llmemory.raw_malloc_usage(precomputed_size)
arena_reserve(b, precomputed_size)
return b
blist = []
plist = []
for i in range(4):
b = reserve(i)
(b + llmemory.offsetof(SX, 'x')).signed[0] = 100 + i
blist.append(b)
plist.append(llmemory.cast_adr_to_ptr(b, SPTR))
# clear blist[1] and blist[2] but not blist[0] nor blist[3]
arena_reset(blist[1],
llmemory.raw_malloc_usage(precomputed_size) * 2, False)
py.test.raises(RuntimeError, "plist[1].x") # marked as freed
py.test.raises(RuntimeError, "plist[2].x") # marked as freed
# re-reserve object at index 1 and 2
blist[1] = reserve(1)
blist[2] = reserve(2)
# check via object pointers
assert plist[0].x == 100
assert plist[3].x == 103
py.test.raises(RuntimeError, "plist[1].x") # marked as freed
py.test.raises(RuntimeError, "plist[2].x") # marked as freed
# but we can still cast the old ptrs to addresses, which compare equal
# to the new ones we gotq
assert llmemory.cast_ptr_to_adr(plist[1]) == blist[1]
assert llmemory.cast_ptr_to_adr(plist[2]) == blist[2]
# check via addresses
assert (blist[0] + llmemory.offsetof(SX, 'x')).signed[0] == 100
assert (blist[3] + llmemory.offsetof(SX, 'x')).signed[0] == 103
py.test.raises(lltype.UninitializedMemoryAccess,
"(blist[1] + llmemory.offsetof(SX, 'x')).signed[0]")
py.test.raises(lltype.UninitializedMemoryAccess,
"(blist[2] + llmemory.offsetof(SX, 'x')).signed[0]")
# clear and zero-fill the area over blist[0] and blist[1]
arena_reset(blist[0],
llmemory.raw_malloc_usage(precomputed_size) * 2, True)
# re-reserve and check it's zero
blist[0] = reserve(0)
blist[1] = reserve(1)
assert (blist[0] + llmemory.offsetof(SX, 'x')).signed[0] == 0
assert (blist[1] + llmemory.offsetof(SX, 'x')).signed[0] == 0
assert (blist[3] + llmemory.offsetof(SX, 'x')).signed[0] == 103
py.test.raises(lltype.UninitializedMemoryAccess,
"(blist[2] + llmemory.offsetof(SX, 'x')).signed[0]")
def test_arena_protect():
a = arena_malloc(100, False)
S = lltype.Struct('S', ('x', lltype.Signed))
arena_reserve(a, llmemory.sizeof(S))
p = llmemory.cast_adr_to_ptr(a, lltype.Ptr(S))
p.x = 123
assert p.x == 123
arena_protect(a, 100, True)
py.test.raises(ArenaError, arena_reserve, a + 48, llmemory.sizeof(S))
py.test.raises(RuntimeError, "p.x")
py.test.raises(RuntimeError, "p.x = 124")
arena_protect(a, 100, False)
assert p.x == 123
p.x = 125
assert p.x == 125
def test_look_inside_object():
# this code is also used in translation tests below
myarenasize = 50
a = arena_malloc(myarenasize, False)
b = a + round_up_for_allocation(llmemory.sizeof(lltype.Char))
arena_reserve(b, precomputed_size)
(b + llmemory.offsetof(SX, 'x')).signed[0] = 123
assert llmemory.cast_adr_to_ptr(b, SPTR).x == 123
llmemory.cast_adr_to_ptr(b, SPTR).x += 1
assert (b + llmemory.offsetof(SX, 'x')).signed[0] == 124
arena_reset(a, myarenasize, True)
arena_reserve(b, round_up_for_allocation(llmemory.sizeof(SX)))
assert llmemory.cast_adr_to_ptr(b, SPTR).x == 0
arena_free(a)
return 42
def test_look_inside_object():
# this code is also used in translation tests below
myarenasize = 50
a = arena_malloc(myarenasize, False)
b = a + round_up_for_allocation(llmemory.sizeof(lltype.Char))
arena_reserve(b, precomputed_size)
(b + llmemory.offsetof(SX, 'x')).signed[0] = 123
assert llmemory.cast_adr_to_ptr(b, SPTR).x == 123
llmemory.cast_adr_to_ptr(b, SPTR).x += 1
assert (b + llmemory.offsetof(SX, 'x')).signed[0] == 124
arena_reset(a, myarenasize, True)
arena_reserve(b, round_up_for_allocation(llmemory.sizeof(SX)))
assert llmemory.cast_adr_to_ptr(b, SPTR).x == 0
arena_free(a)
return 42
def test_partial_arena_reset():
a = arena_malloc(50, False)
def reserve(i):
b = a + i * llmemory.raw_malloc_usage(precomputed_size)
arena_reserve(b, precomputed_size)
return b
blist = []
plist = []
for i in range(4):
b = reserve(i)
(b + llmemory.offsetof(SX, 'x')).signed[0] = 100 + i
blist.append(b)
plist.append(llmemory.cast_adr_to_ptr(b, SPTR))
# clear blist[1] and blist[2] but not blist[0] nor blist[3]
arena_reset(blist[1], llmemory.raw_malloc_usage(precomputed_size)*2, False)
py.test.raises(RuntimeError, "plist[1].x") # marked as freed
py.test.raises(RuntimeError, "plist[2].x") # marked as freed
# re-reserve object at index 1 and 2
blist[1] = reserve(1)
blist[2] = reserve(2)
# check via object pointers
assert plist[0].x == 100
assert plist[3].x == 103
py.test.raises(RuntimeError, "plist[1].x") # marked as freed
py.test.raises(RuntimeError, "plist[2].x") # marked as freed
# but we can still cast the old ptrs to addresses, which compare equal
# to the new ones we gotq
assert llmemory.cast_ptr_to_adr(plist[1]) == blist[1]
assert llmemory.cast_ptr_to_adr(plist[2]) == blist[2]
# check via addresses
assert (blist[0] + llmemory.offsetof(SX, 'x')).signed[0] == 100
assert (blist[3] + llmemory.offsetof(SX, 'x')).signed[0] == 103
py.test.raises(lltype.UninitializedMemoryAccess,
"(blist[1] + llmemory.offsetof(SX, 'x')).signed[0]")
py.test.raises(lltype.UninitializedMemoryAccess,
"(blist[2] + llmemory.offsetof(SX, 'x')).signed[0]")
# clear and zero-fill the area over blist[0] and blist[1]
arena_reset(blist[0], llmemory.raw_malloc_usage(precomputed_size)*2, True)
# re-reserve and check it's zero
blist[0] = reserve(0)
blist[1] = reserve(1)
assert (blist[0] + llmemory.offsetof(SX, 'x')).signed[0] == 0
assert (blist[1] + llmemory.offsetof(SX, 'x')).signed[0] == 0
assert (blist[3] + llmemory.offsetof(SX, 'x')).signed[0] == 103
py.test.raises(lltype.UninitializedMemoryAccess,
"(blist[2] + llmemory.offsetof(SX, 'x')).signed[0]")
def fn(argv):
testrun = int(argv[1])
a = arena_malloc(65536, False)
arena_reserve(a, llmemory.sizeof(S))
p = llmemory.cast_adr_to_ptr(a + 23432, lltype.Ptr(S))
p.x = 123
assert p.x == 123
arena_protect(a, 65536, True)
result = 0
if testrun == 1:
print p.x # segfault
if testrun == 2:
p.x = 124 # segfault
arena_protect(a, 65536, False)
p.x += 10
print p.x
return 0
def setup(self):
envsize = env.read_from_env('PYPY_MARKCOMPACTGC_MAX')
if envsize >= 4096:
self.space_size = envsize & ~4095
mincollect = env.read_from_env('PYPY_MARKCOMPACTGC_MIN')
if mincollect >= 4096:
self.min_next_collect_after = mincollect
#self.program_start_time = time.time()
self.space = llarena.arena_malloc(self.space_size, False)
if not self.space:
raise CannotAllocateGCArena
self.free = self.space
MovingGCBase.setup(self)
self.objects_with_finalizers = self.AddressDeque()
self.tid_backup = lltype.nullptr(TID_BACKUP)
self.next_collect_after = self.next_collection(0, 0, 0)
def setup(self):
envsize = env.read_from_env("PYPY_MARKCOMPACTGC_MAX")
if envsize >= 4096:
self.space_size = envsize & ~4095
mincollect = env.read_from_env("PYPY_MARKCOMPACTGC_MIN")
if mincollect >= 4096:
self.min_next_collect_after = mincollect
# self.program_start_time = time.time()
self.space = llarena.arena_malloc(self.space_size, False)
if not self.space:
raise CannotAllocateGCArena
self.free = self.space
MovingGCBase.setup(self)
self.objects_with_finalizers = self.AddressDeque()
self.tid_backup = lltype.nullptr(TID_BACKUP)
self.next_collect_after = self.next_collection(0, 0, 0)
def allocate_new_arena(self):
"""Loads in self.current_arena the arena to allocate from next."""
#
# Pick an arena from 'arenas_lists[i]', with i as small as possible
# but > 0. Use caching with 'min_empty_nfreepages', which guarantees
# that 'arenas_lists[1:min_empty_nfreepages]' are all empty.
i = self.min_empty_nfreepages
while i < self.max_pages_per_arena:
#
if self.arenas_lists[i] != ARENA_NULL:
#
# Found it.
self.current_arena = self.arenas_lists[i]
self.arenas_lists[i] = self.current_arena.nextarena
return
#
i += 1
self.min_empty_nfreepages = i
#
# No more arena with any free page. We must allocate a new arena.
if not we_are_translated():
for a in self._all_arenas():
assert a.nfreepages == 0
#
# 'arena_base' points to the start of malloced memory; it might not
# be a page-aligned address
arena_base = llarena.arena_malloc(self.arena_size, False)
if not arena_base:
raise MemoryError("couldn't allocate the next arena")
arena_end = arena_base + self.arena_size
#
# 'firstpage' points to the first unused page
firstpage = start_of_page(arena_base + self.page_size - 1,
self.page_size)
# 'npages' is the number of full pages just allocated
npages = (arena_end - firstpage) // self.page_size
#
# Allocate an ARENA object and initialize it
arena = lltype.malloc(ARENA, flavor='raw', track_allocation=False)
arena.base = arena_base
arena.nfreepages = 0 # they are all uninitialized pages
arena.totalpages = npages
arena.freepages = firstpage
self.num_uninitialized_pages = npages
self.current_arena = arena
def allocate_new_arena(self):
"""Loads in self.current_arena the arena to allocate from next."""
#
# Pick an arena from 'arenas_lists[i]', with i as small as possible
# but > 0. Use caching with 'min_empty_nfreepages', which guarantees
# that 'arenas_lists[1:min_empty_nfreepages]' are all empty.
i = self.min_empty_nfreepages
while i < self.max_pages_per_arena:
#
if self.arenas_lists[i] != ARENA_NULL:
#
# Found it.
self.current_arena = self.arenas_lists[i]
self.arenas_lists[i] = self.current_arena.nextarena
return
#
i += 1
self.min_empty_nfreepages = i
#
# No more arena with any free page. We must allocate a new arena.
if not we_are_translated():
for a in self._all_arenas():
assert a.nfreepages == 0
#
# 'arena_base' points to the start of malloced memory; it might not
# be a page-aligned address
arena_base = llarena.arena_malloc(self.arena_size, False)
if not arena_base:
raise MemoryError("couldn't allocate the next arena")
arena_end = arena_base + self.arena_size
#
# 'firstpage' points to the first unused page
firstpage = start_of_page(arena_base + self.page_size - 1,
self.page_size)
# 'npages' is the number of full pages just allocated
npages = (arena_end - firstpage) // self.page_size
#
# Allocate an ARENA object and initialize it
arena = lltype.malloc(ARENA, flavor='raw', track_allocation=False)
arena.base = arena_base
arena.nfreepages = 0 # they are all uninitialized pages
arena.totalpages = npages
arena.freepages = firstpage
self.num_uninitialized_pages = npages
self.current_arena = arena
def test_replace_object_with_stub():
from pypy.rpython.memory.gcheader import GCHeaderBuilder
HDR = lltype.Struct('HDR', ('x', lltype.Signed))
S = lltype.GcStruct('S', ('y', lltype.Signed), ('z', lltype.Signed))
STUB = lltype.GcStruct('STUB', ('t', lltype.Char))
gcheaderbuilder = GCHeaderBuilder(HDR)
size_gc_header = gcheaderbuilder.size_gc_header
ssize = llmemory.raw_malloc_usage(llmemory.sizeof(S))
a = arena_malloc(13*ssize, True)
hdraddr = a + 3*ssize
arena_reserve(hdraddr, size_gc_header + llmemory.sizeof(S))
hdr = llmemory.cast_adr_to_ptr(hdraddr, lltype.Ptr(HDR))
hdr.x = 42
obj = llmemory.cast_adr_to_ptr(hdraddr + size_gc_header, lltype.Ptr(S))
obj.y = -5
obj.z = -6
hdraddr = llmemory.cast_ptr_to_adr(obj) - size_gc_header
arena_reset(hdraddr, size_gc_header + llmemory.sizeof(S), False)
arena_reserve(hdraddr, size_gc_header + llmemory.sizeof(STUB))
# check that it possible to reach the newly reserved HDR+STUB
# via the header of the old 'obj' pointer, both via the existing
# 'hdraddr':
hdr = llmemory.cast_adr_to_ptr(hdraddr, lltype.Ptr(HDR))
hdr.x = 46
stub = llmemory.cast_adr_to_ptr(hdraddr + size_gc_header, lltype.Ptr(STUB))
stub.t = '!'
# and via a (now-invalid) pointer to the old 'obj': (this is needed
# because during a garbage collection there are still pointers to
# the old 'obj' around to be fixed)
hdraddr = llmemory.cast_ptr_to_adr(obj) - size_gc_header
hdr = llmemory.cast_adr_to_ptr(hdraddr, lltype.Ptr(HDR))
assert hdr.x == 46
stub = llmemory.cast_adr_to_ptr(hdraddr + size_gc_header,
lltype.Ptr(STUB))
assert stub.t == '!'
def test_replace_object_with_stub():
from pypy.rpython.memory.gcheader import GCHeaderBuilder
HDR = lltype.Struct('HDR', ('x', lltype.Signed))
S = lltype.GcStruct('S', ('y', lltype.Signed), ('z', lltype.Signed))
STUB = lltype.GcStruct('STUB', ('t', lltype.Char))
gcheaderbuilder = GCHeaderBuilder(HDR)
size_gc_header = gcheaderbuilder.size_gc_header
ssize = llmemory.raw_malloc_usage(llmemory.sizeof(S))
a = arena_malloc(13 * ssize, True)
hdraddr = a + 3 * ssize
arena_reserve(hdraddr, size_gc_header + llmemory.sizeof(S))
hdr = llmemory.cast_adr_to_ptr(hdraddr, lltype.Ptr(HDR))
hdr.x = 42
obj = llmemory.cast_adr_to_ptr(hdraddr + size_gc_header, lltype.Ptr(S))
obj.y = -5
obj.z = -6
hdraddr = llmemory.cast_ptr_to_adr(obj) - size_gc_header
arena_reset(hdraddr, size_gc_header + llmemory.sizeof(S), False)
arena_reserve(hdraddr, size_gc_header + llmemory.sizeof(STUB))
# check that it possible to reach the newly reserved HDR+STUB
# via the header of the old 'obj' pointer, both via the existing
# 'hdraddr':
hdr = llmemory.cast_adr_to_ptr(hdraddr, lltype.Ptr(HDR))
hdr.x = 46
stub = llmemory.cast_adr_to_ptr(hdraddr + size_gc_header, lltype.Ptr(STUB))
stub.t = '!'
# and via a (now-invalid) pointer to the old 'obj': (this is needed
# because during a garbage collection there are still pointers to
# the old 'obj' around to be fixed)
hdraddr = llmemory.cast_ptr_to_adr(obj) - size_gc_header
hdr = llmemory.cast_adr_to_ptr(hdraddr, lltype.Ptr(HDR))
assert hdr.x == 46
stub = llmemory.cast_adr_to_ptr(hdraddr + size_gc_header, lltype.Ptr(STUB))
assert stub.t == '!'
def test_arena_new_view():
a = arena_malloc(50, False)
arena_reserve(a, precomputed_size)
# we can now allocate the same space in new view
b = arena_new_view(a)
arena_reserve(b, precomputed_size)
def test_arena_new_view():
a = arena_malloc(50, False)
arena_reserve(a, precomputed_size)
# we can now allocate the same space in new view
b = arena_new_view(a)
arena_reserve(b, precomputed_size)
def test_arena():
S = lltype.Struct('S', ('x',lltype.Signed))
SPTR = lltype.Ptr(S)
ssize = llmemory.raw_malloc_usage(llmemory.sizeof(S))
myarenasize = 2*ssize+1
a = arena_malloc(myarenasize, False)
assert a != llmemory.NULL
assert a + 3 != llmemory.NULL
arena_reserve(a, llmemory.sizeof(S))
s1_ptr1 = cast_adr_to_ptr(a, SPTR)
s1_ptr1.x = 1
s1_ptr2 = cast_adr_to_ptr(a, SPTR)
assert s1_ptr2.x == 1
assert s1_ptr1 == s1_ptr2
py.test.raises(ArenaError, arena_reserve, a + ssize + 1, # misaligned
llmemory.sizeof(S))
arena_reserve(a + ssize + 1, llmemory.sizeof(S), check_alignment=False)
s2_ptr1 = cast_adr_to_ptr(a + ssize + 1, SPTR)
py.test.raises(lltype.UninitializedMemoryAccess, 's2_ptr1.x')
s2_ptr1.x = 2
s2_ptr2 = cast_adr_to_ptr(a + ssize + 1, SPTR)
assert s2_ptr2.x == 2
assert s2_ptr1 == s2_ptr2
assert s1_ptr1 != s2_ptr1
assert not (s2_ptr2 == s1_ptr2)
assert s1_ptr1 == cast_adr_to_ptr(a, SPTR)
S2 = lltype.Struct('S2', ('y',lltype.Char))
S2PTR = lltype.Ptr(S2)
py.test.raises(lltype.InvalidCast, cast_adr_to_ptr, a, S2PTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a+1, SPTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a+ssize, SPTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a+2*ssize, SPTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a+2*ssize+1, SPTR)
py.test.raises(ArenaError, arena_reserve, a+1, llmemory.sizeof(S),
False)
py.test.raises(ArenaError, arena_reserve, a+ssize, llmemory.sizeof(S),
False)
py.test.raises(ArenaError, arena_reserve, a+2*ssize, llmemory.sizeof(S),
False)
py.test.raises(ArenaError, arena_reserve, a+2*ssize+1, llmemory.sizeof(S),
False)
arena_reset(a, myarenasize, True)
py.test.raises(ArenaError, cast_adr_to_ptr, a, SPTR)
arena_reserve(a, llmemory.sizeof(S))
s1_ptr1 = cast_adr_to_ptr(a, SPTR)
assert s1_ptr1.x == 0
s1_ptr1.x = 5
arena_reserve(a + ssize, llmemory.sizeof(S2), check_alignment=False)
s2_ptr1 = cast_adr_to_ptr(a + ssize, S2PTR)
assert s2_ptr1.y == '\x00'
s2_ptr1.y = 'X'
assert cast_adr_to_ptr(a + 0, SPTR).x == 5
assert cast_adr_to_ptr((a + ssize + 1) - 1, S2PTR).y == 'X'
assert (a + 4) - (a + 1) == 3
def test_arena():
S = lltype.Struct('S', ('x', lltype.Signed))
SPTR = lltype.Ptr(S)
ssize = llmemory.raw_malloc_usage(llmemory.sizeof(S))
myarenasize = 2 * ssize + 1
a = arena_malloc(myarenasize, False)
assert a != llmemory.NULL
assert a + 3 != llmemory.NULL
arena_reserve(a, llmemory.sizeof(S))
s1_ptr1 = cast_adr_to_ptr(a, SPTR)
s1_ptr1.x = 1
s1_ptr2 = cast_adr_to_ptr(a, SPTR)
assert s1_ptr2.x == 1
assert s1_ptr1 == s1_ptr2
py.test.raises(
ArenaError,
arena_reserve,
a + ssize + 1, # misaligned
llmemory.sizeof(S))
arena_reserve(a + ssize + 1, llmemory.sizeof(S), check_alignment=False)
s2_ptr1 = cast_adr_to_ptr(a + ssize + 1, SPTR)
py.test.raises(lltype.UninitializedMemoryAccess, 's2_ptr1.x')
s2_ptr1.x = 2
s2_ptr2 = cast_adr_to_ptr(a + ssize + 1, SPTR)
assert s2_ptr2.x == 2
assert s2_ptr1 == s2_ptr2
assert s1_ptr1 != s2_ptr1
assert not (s2_ptr2 == s1_ptr2)
assert s1_ptr1 == cast_adr_to_ptr(a, SPTR)
S2 = lltype.Struct('S2', ('y', lltype.Char))
S2PTR = lltype.Ptr(S2)
py.test.raises(lltype.InvalidCast, cast_adr_to_ptr, a, S2PTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a + 1, SPTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a + ssize, SPTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a + 2 * ssize, SPTR)
py.test.raises(ArenaError, cast_adr_to_ptr, a + 2 * ssize + 1, SPTR)
py.test.raises(ArenaError, arena_reserve, a + 1, llmemory.sizeof(S), False)
py.test.raises(ArenaError, arena_reserve, a + ssize, llmemory.sizeof(S),
False)
py.test.raises(ArenaError, arena_reserve, a + 2 * ssize,
llmemory.sizeof(S), False)
py.test.raises(ArenaError, arena_reserve, a + 2 * ssize + 1,
llmemory.sizeof(S), False)
arena_reset(a, myarenasize, True)
py.test.raises(ArenaError, cast_adr_to_ptr, a, SPTR)
arena_reserve(a, llmemory.sizeof(S))
s1_ptr1 = cast_adr_to_ptr(a, SPTR)
assert s1_ptr1.x == 0
s1_ptr1.x = 5
arena_reserve(a + ssize, llmemory.sizeof(S2), check_alignment=False)
s2_ptr1 = cast_adr_to_ptr(a + ssize, S2PTR)
assert s2_ptr1.y == '\x00'
s2_ptr1.y = 'X'
assert cast_adr_to_ptr(a + 0, SPTR).x == 5
assert cast_adr_to_ptr((a + ssize + 1) - 1, S2PTR).y == 'X'
assert (a + 4) - (a + 1) == 3
def double_space_size(self, minimal_size):
while self.space_size <= minimal_size:
self.space_size *= 2
toaddr = llarena.arena_malloc(self.space_size, True)
return toaddr
def f():
a = llarena.arena_malloc(800, False)
llarena.arena_reset(a, 800, 2)
llarena.arena_free(a)
def double_space_size(self, minimal_size):
while self.space_size <= minimal_size:
self.space_size *= 2
toaddr = llarena.arena_malloc(self.space_size, True)
return toaddr
