[pypy-commit] stmgc c7-refactor: Fix test_largemalloc.
arigo
noreply at buildbot.pypy.org
Tue Feb 25 07:39:54 CET 2014
Author: Armin Rigo <arigo at tunes.org>
Branch: c7-refactor
Changeset: r850:2cda4cd67403
Date: 2014-02-25 07:39 +0100
http://bitbucket.org/pypy/stmgc/changeset/2cda4cd67403/
Log: Fix test_largemalloc.
diff --git a/c7/stm/gcpage.c b/c7/stm/gcpage.c
--- a/c7/stm/gcpage.c
+++ b/c7/stm/gcpage.c
@@ -9,7 +9,7 @@
reset_all_creation_markers() */
char *base = stm_object_pages + END_NURSERY_PAGE * 4096UL;
uintptr_t length = (NB_PAGES - END_NURSERY_PAGE - 1) * 4096UL;
- largemalloc_init_arena(base, length);
+ _stm_largemalloc_init_arena(base, length);
uninitialized_page_start = stm_object_pages + END_NURSERY_PAGE * 4096UL;
uninitialized_page_stop = stm_object_pages + NB_PAGES * 4096UL;
@@ -40,8 +40,8 @@
uninitialized_page_stop -= decrease_by;
- if (!largemalloc_resize_arena(uninitialized_page_stop -
- uninitialized_page_start))
+ if (!_stm_largemalloc_resize_arena(uninitialized_page_stop -
+ uninitialized_page_start))
goto out_of_memory;
setup_N_pages(uninitialized_page_start, GCPAGE_NUM_PAGES);
@@ -70,14 +70,16 @@
}
-static object_t *allocate_outside_nursery_large(uint64_t size)
+static char *allocate_outside_nursery_large(uint64_t size)
{
/* thread-safe: use the lock of pages.c to prevent any remapping
from occurring under our feet */
mutex_pages_lock();
/* Allocate the object with largemalloc.c from the lower addresses. */
- char *addr = large_malloc(size);
+ char *addr = _stm_large_malloc(size);
+ if (addr == NULL)
+ stm_fatalerror("not enough memory!\n");
if (addr + size > uninitialized_page_start) {
uintptr_t npages;
@@ -93,14 +95,16 @@
mutex_pages_unlock();
- return (object_t *)(addr - stm_object_pages);
+ return addr;
}
object_t *_stm_allocate_old(ssize_t size_rounded_up)
{
/* only for tests */
- object_t *o = allocate_outside_nursery_large(size_rounded_up);
- memset(REAL_ADDRESS(stm_object_pages, o), 0, size_rounded_up);
+ char *p = allocate_outside_nursery_large(size_rounded_up);
+ memset(p, 0, size_rounded_up);
+
+ object_t *o = (object_t *)(p - stm_object_pages);
o->stm_flags = STM_FLAGS_PREBUILT;
return o;
}
diff --git a/c7/stm/gcpage.h b/c7/stm/gcpage.h
--- a/c7/stm/gcpage.h
+++ b/c7/stm/gcpage.h
@@ -27,7 +27,7 @@
static void setup_gcpage(void);
static void teardown_gcpage(void);
-static object_t *allocate_outside_nursery_large(uint64_t size);
+static char *allocate_outside_nursery_large(uint64_t size);
static char *_allocate_small_slowpath(uint64_t size);
diff --git a/c7/stm/largemalloc.c b/c7/stm/largemalloc.c
--- a/c7/stm/largemalloc.c
+++ b/c7/stm/largemalloc.c
@@ -170,7 +170,7 @@
really_sort_bin(index);
}
-static char *large_malloc(size_t request_size)
+char *_stm_large_malloc(size_t request_size)
{
/* 'request_size' should already be a multiple of the word size here */
assert((request_size & (sizeof(char *)-1)) == 0);
@@ -208,8 +208,6 @@
}
/* not enough memory. */
- fprintf(stderr, "not enough memory!\n");
- abort();
return NULL;
found:
@@ -243,7 +241,7 @@
return (char *)&mscan->d;
}
-static void large_free(char *data)
+void _stm_large_free(char *data)
{
mchunk_t *chunk = data2chunk(data);
assert((chunk->size & (sizeof(char *) - 1)) == 0);
@@ -341,7 +339,12 @@
assert(data - 16 == (char *)last_chunk);
}
-static void largemalloc_init_arena(char *data_start, size_t data_size)
+char *_stm_largemalloc_data_start(void)
+{
+ return (char *)first_chunk;
+}
+
+void _stm_largemalloc_init_arena(char *data_start, size_t data_size)
{
int i;
for (i = 0; i < N_BINS; i++) {
@@ -362,7 +365,7 @@
insert_unsorted(first_chunk);
}
-static int largemalloc_resize_arena(size_t new_size)
+int _stm_largemalloc_resize_arena(size_t new_size)
{
if (new_size < 2 * sizeof(struct malloc_chunk))
return 0;
@@ -413,7 +416,7 @@
assert(last_chunk == next_chunk_u(old_last_chunk));
/* then free the last_chunk (turn it from "used" to "free) */
- large_free((char *)&old_last_chunk->d);
+ _stm_large_free((char *)&old_last_chunk->d);
}
return 1;
}
diff --git a/c7/stm/largemalloc.h b/c7/stm/largemalloc.h
--- a/c7/stm/largemalloc.h
+++ b/c7/stm/largemalloc.h
@@ -1,11 +1,14 @@
/* all addresses passed to this interface should be "char *" pointers
in the segment 0. */
-static void largemalloc_init_arena(char *data_start, size_t data_size);
-static int largemalloc_resize_arena(size_t new_size);
+void _stm_largemalloc_init_arena(char *data_start, size_t data_size);
+int _stm_largemalloc_resize_arena(size_t new_size);
+char *_stm_largemalloc_data_start(void);
/* large_malloc() and large_free() are not thread-safe. This is
due to the fact that they should be mostly called during minor or
major collections, which have their own synchronization mecanisms. */
-static char *large_malloc(size_t request_size);
-static void large_free(char *data) __attribute__((unused));
+char *_stm_large_malloc(size_t request_size);
+void _stm_large_free(char *data);
+
+void _stm_large_dump(void);
diff --git a/c7/stm/nursery.c b/c7/stm/nursery.c
--- a/c7/stm/nursery.c
+++ b/c7/stm/nursery.c
@@ -87,7 +87,8 @@
/* case 1: object is not small enough.
Ask gcpage.c for an allocation via largemalloc. */
- nobj = allocate_outside_nursery_large(size);
+ char *allocated = allocate_outside_nursery_large(size);
+ nobj = (object_t *)(allocated - stm_object_pages);
nobj_sync_now = (uintptr_t)nobj;
/* Copy the object */
diff --git a/c7/stmgc.h b/c7/stmgc.h
--- a/c7/stmgc.h
+++ b/c7/stmgc.h
@@ -76,6 +76,11 @@
char *_stm_get_segment_base(long index);
void _stm_test_switch(stm_thread_local_t *tl);
object_t *_stm_allocate_old(ssize_t size_rounded_up);
+void _stm_largemalloc_init_arena(char *data_start, size_t data_size);
+int _stm_largemalloc_resize_arena(size_t new_size);
+char *_stm_largemalloc_data_start(void);
+char *_stm_large_malloc(size_t request_size);
+void _stm_large_free(char *data);
void _stm_large_dump(void);
void _stm_start_safe_point(void);
void _stm_stop_safe_point(void);
diff --git a/c7/test/support.py b/c7/test/support.py
--- a/c7/test/support.py
+++ b/c7/test/support.py
@@ -74,6 +74,13 @@
bool _check_stop_safe_point(void);
void _stm_set_nursery_free_count(uint64_t free_count);
+void _stm_largemalloc_init_arena(char *data_start, size_t data_size);
+int _stm_largemalloc_resize_arena(size_t new_size);
+char *_stm_largemalloc_data_start(void);
+char *_stm_large_malloc(size_t request_size);
+void _stm_large_free(char *data);
+void _stm_large_dump(void);
+void *memset(void *s, int c, size_t n);
ssize_t stmcb_size_rounded_up(struct object_s *obj);
diff --git a/c7/test/test_largemalloc.py b/c7/test/test_largemalloc.py
--- a/c7/test/test_largemalloc.py
+++ b/c7/test/test_largemalloc.py
@@ -1,7 +1,7 @@
from support import *
import sys, random
-ra = stm_get_real_address
+ra = lambda x: x # backward compat.
class TestLargeMalloc(BaseTest):
def setup_method(self, meth):
@@ -13,85 +13,85 @@
self.rawmem = lib._stm_largemalloc_data_start()
lib.memset(self.rawmem, 0xcd, self.size)
- lib.stm_largemalloc_init(self.rawmem, self.size)
+ lib._stm_largemalloc_init_arena(self.rawmem, self.size)
def test_simple(self):
- d1 = lib.stm_large_malloc(7000)
- d2 = lib.stm_large_malloc(8000)
+ d1 = lib._stm_large_malloc(7000)
+ d2 = lib._stm_large_malloc(8000)
print d1
print d2
assert ra(d2) - ra(d1) == 7016
- d3 = lib.stm_large_malloc(9000)
+ d3 = lib._stm_large_malloc(9000)
assert ra(d3) - ra(d2) == 8016
#
- lib.stm_large_free(d1)
- lib.stm_large_free(d2)
+ lib._stm_large_free(d1)
+ lib._stm_large_free(d2)
#
- d4 = lib.stm_large_malloc(600)
+ d4 = lib._stm_large_malloc(600)
assert d4 == d1
- d5 = lib.stm_large_malloc(600)
+ d5 = lib._stm_large_malloc(600)
assert ra(d5) == ra(d4) + 616
#
- lib.stm_large_free(d5)
+ lib._stm_large_free(d5)
#
- d6 = lib.stm_large_malloc(600)
+ d6 = lib._stm_large_malloc(600)
assert d6 == d5
#
- lib.stm_large_free(d4)
+ lib._stm_large_free(d4)
#
- d7 = lib.stm_large_malloc(608)
+ d7 = lib._stm_large_malloc(608)
assert ra(d7) == ra(d6) + 616
- d8 = lib.stm_large_malloc(600)
+ d8 = lib._stm_large_malloc(600)
assert d8 == d4
#
lib._stm_large_dump()
def test_overflow_1(self):
- d = lib.stm_large_malloc(self.size - 32)
+ d = lib._stm_large_malloc(self.size - 32)
assert ra(d) == self.rawmem + 16
lib._stm_large_dump()
def test_overflow_2(self):
- d = lib.stm_large_malloc(self.size - 16)
+ d = lib._stm_large_malloc(self.size - 16)
assert d == ffi.NULL
lib._stm_large_dump()
def test_overflow_3(self):
- d = lib.stm_large_malloc(sys.maxint & ~7)
+ d = lib._stm_large_malloc(sys.maxint & ~7)
assert d == ffi.NULL
lib._stm_large_dump()
def test_resize_arena_reduce_1(self):
- r = lib.stm_largemalloc_resize_arena(self.size - 32)
+ r = lib._stm_largemalloc_resize_arena(self.size - 32)
assert r == 1
- d = lib.stm_large_malloc(self.size - 32)
+ d = lib._stm_large_malloc(self.size - 32)
assert d == ffi.NULL
lib._stm_large_dump()
def test_resize_arena_reduce_2(self):
- lib.stm_large_malloc(self.size // 2 - 64)
- r = lib.stm_largemalloc_resize_arena(self.size // 2)
+ lib._stm_large_malloc(self.size // 2 - 64)
+ r = lib._stm_largemalloc_resize_arena(self.size // 2)
assert r == 1
lib._stm_large_dump()
def test_resize_arena_reduce_3(self):
- d1 = lib.stm_large_malloc(128)
- r = lib.stm_largemalloc_resize_arena(self.size // 2)
+ d1 = lib._stm_large_malloc(128)
+ r = lib._stm_largemalloc_resize_arena(self.size // 2)
assert r == 1
- d2 = lib.stm_large_malloc(128)
+ d2 = lib._stm_large_malloc(128)
assert ra(d1) == self.rawmem + 16
assert ra(d2) == ra(d1) + 128 + 16
lib._stm_large_dump()
def test_resize_arena_cannot_reduce_1(self):
- lib.stm_large_malloc(self.size // 2)
- r = lib.stm_largemalloc_resize_arena(self.size // 2)
+ lib._stm_large_malloc(self.size // 2)
+ r = lib._stm_largemalloc_resize_arena(self.size // 2)
assert r == 0
lib._stm_large_dump()
def test_resize_arena_cannot_reduce_2(self):
- lib.stm_large_malloc(self.size // 2 - 56)
- r = lib.stm_largemalloc_resize_arena(self.size // 2)
+ lib._stm_large_malloc(self.size // 2 - 56)
+ r = lib._stm_largemalloc_resize_arena(self.size // 2)
assert r == 0
lib._stm_large_dump()
@@ -105,10 +105,10 @@
print ' free %5d (%s)' % (length, d)
assert ra(d)[0] == content1
assert ra(d)[length - 1] == content2
- lib.stm_large_free(d)
+ lib._stm_large_free(d)
else:
sz = r.randrange(8, 160) * 8
- d = lib.stm_large_malloc(sz)
+ d = lib._stm_large_malloc(sz)
print 'alloc %5d (%s)' % (sz, d)
assert d != ffi.NULL
lib.memset(ra(d), 0xdd, sz)
More information about the pypy-commit
mailing list