Author: Remi Meier <[email protected]>
Branch: finalizer-queues
Changeset: r1997:2101463c93d1
Date: 2016-11-16 08:59 +0100
http://bitbucket.org/pypy/stmgc/changeset/2101463c93d1/
Log: rename light_finalizer to destructor
diff --git a/c8/stm/core.c b/c8/stm/core.c
--- a/c8/stm/core.c
+++ b/c8/stm/core.c
@@ -1047,7 +1047,7 @@
assert(tree_is_cleared(STM_PSEGMENT->nursery_objects_shadows));
assert(tree_is_cleared(STM_PSEGMENT->callbacks_on_commit_and_abort[0]));
assert(tree_is_cleared(STM_PSEGMENT->callbacks_on_commit_and_abort[1]));
- assert(list_is_empty(STM_PSEGMENT->young_objects_with_light_finalizers));
+ assert(list_is_empty(STM_PSEGMENT->young_objects_with_destructors));
assert(STM_PSEGMENT->finalizers == NULL);
assert(STM_PSEGMENT->active_queues == NULL);
#ifndef NDEBUG
diff --git a/c8/stm/core.h b/c8/stm/core.h
--- a/c8/stm/core.h
+++ b/c8/stm/core.h
@@ -13,6 +13,7 @@
#include <errno.h>
#include <pthread.h>
#include <signal.h>
+#include <stdbool.h>
/************************************************************/
@@ -145,8 +146,8 @@
#endif
/* light finalizers */
- struct list_s *young_objects_with_light_finalizers;
- struct list_s *old_objects_with_light_finalizers;
+ struct list_s *young_objects_with_destructors;
+ struct list_s *old_objects_with_destructors;
/* regular finalizers (objs from the current transaction only) */
struct finalizers_s *finalizers;
diff --git a/c8/stm/finalizer.c b/c8/stm/finalizer.c
--- a/c8/stm/finalizer.c
+++ b/c8/stm/finalizer.c
@@ -4,7 +4,7 @@
#endif
/* callbacks */
-void (*stmcb_light_finalizer)(object_t *);
+void (*stmcb_destructor)(object_t *);
void (*stmcb_finalizer)(object_t *);
@@ -91,7 +91,7 @@
char *old_gs_register = STM_SEGMENT->segment_base;
bool must_fix_gs = old_gs_register != pseg->pub.segment_base;
- struct list_s *lst = pseg->young_objects_with_light_finalizers;
+ struct list_s *lst = pseg->young_objects_with_destructors;
long i, count = list_count(lst);
if (lst > 0) {
for (i = 0; i < count; i++) {
@@ -101,15 +101,15 @@
set_gs_register(pseg->pub.segment_base);
must_fix_gs = false;
}
- stmcb_light_finalizer(obj);
+ stmcb_destructor(obj);
}
list_clear(lst);
}
/* also deals with overflow objects: they are at the tail of
- old_objects_with_light_finalizers (this list is kept in order
+ old_objects_with_destructors (this list is kept in order
and we cannot add any already-committed object) */
- lst = pseg->old_objects_with_light_finalizers;
+ lst = pseg->old_objects_with_destructors;
count = list_count(lst);
while (count > 0) {
object_t *obj = (object_t *)list_item(lst, --count);
@@ -120,7 +120,7 @@
set_gs_register(pseg->pub.segment_base);
must_fix_gs = false;
}
- stmcb_light_finalizer(obj);
+ stmcb_destructor(obj);
}
if (STM_SEGMENT->segment_base != old_gs_register)
@@ -128,14 +128,14 @@
}
-void stm_enable_light_finalizer(object_t *obj)
+void stm_enable_destructor(object_t *obj)
{
if (_is_young(obj)) {
- LIST_APPEND(STM_PSEGMENT->young_objects_with_light_finalizers, obj);
+ LIST_APPEND(STM_PSEGMENT->young_objects_with_destructors, obj);
}
else {
assert(_is_from_same_transaction(obj));
- LIST_APPEND(STM_PSEGMENT->old_objects_with_light_finalizers, obj);
+ LIST_APPEND(STM_PSEGMENT->old_objects_with_destructors, obj);
}
}
@@ -165,7 +165,7 @@
{
/* for light finalizers: executes finalizers for objs that don't survive
this minor gc */
- struct list_s *lst = STM_PSEGMENT->young_objects_with_light_finalizers;
+ struct list_s *lst = STM_PSEGMENT->young_objects_with_destructors;
long i, count = list_count(lst);
for (i = 0; i < count; i++) {
object_t *obj = (object_t *)list_item(lst, i);
@@ -174,12 +174,12 @@
object_t *TLPREFIX *pforwarded_array = (object_t *TLPREFIX *)obj;
if (pforwarded_array[0] != GCWORD_MOVED) {
/* not moved: the object dies */
- stmcb_light_finalizer(obj);
+ stmcb_destructor(obj);
}
else {
obj = pforwarded_array[1]; /* moved location */
assert(!_is_young(obj));
- LIST_APPEND(STM_PSEGMENT->old_objects_with_light_finalizers, obj);
+ LIST_APPEND(STM_PSEGMENT->old_objects_with_destructors, obj);
}
}
list_clear(lst);
@@ -191,11 +191,11 @@
int old_gs_register = STM_SEGMENT->segment_num;
int current_gs_register = old_gs_register;
long j;
-
assert(list_is_empty(get_priv_segment(0)->old_objects_with_light_finalizers));
+ assert(list_is_empty(get_priv_segment(0)->old_objects_with_destructors));
for (j = 1; j < NB_SEGMENTS; j++) {
struct stm_priv_segment_info_s *pseg = get_priv_segment(j);
- struct list_s *lst = pseg->old_objects_with_light_finalizers;
+ struct list_s *lst = pseg->old_objects_with_destructors;
long i, count = list_count(lst);
lst->count = 0;
for (i = 0; i < count; i++) {
@@ -217,7 +217,7 @@
set_gs_register(get_segment_base(j));
current_gs_register = j;
}
- stmcb_light_finalizer(obj);
+ stmcb_destructor(obj);
}
else {
/* object survives */
diff --git a/c8/stm/finalizer.h b/c8/stm/finalizer.h
--- a/c8/stm/finalizer.h
+++ b/c8/stm/finalizer.h
@@ -1,3 +1,4 @@
+#include <stdint.h>
/* see deal_with_objects_with_finalizers() for explanation of these fields */
struct finalizers_s {
diff --git a/c8/stm/setup.c b/c8/stm/setup.c
--- a/c8/stm/setup.c
+++ b/c8/stm/setup.c
@@ -100,8 +100,8 @@
pr->nursery_objects_shadows = tree_create();
pr->callbacks_on_commit_and_abort[0] = tree_create();
pr->callbacks_on_commit_and_abort[1] = tree_create();
- pr->young_objects_with_light_finalizers = list_create();
- pr->old_objects_with_light_finalizers = list_create();
+ pr->young_objects_with_destructors = list_create();
+ pr->old_objects_with_destructors = list_create();
pr->last_commit_log_entry = &commit_log_root;
pr->overflow_number = GCFLAG_OVERFLOW_NUMBER_bit0 * i;
@@ -156,8 +156,8 @@
tree_free(pr->nursery_objects_shadows);
tree_free(pr->callbacks_on_commit_and_abort[0]);
tree_free(pr->callbacks_on_commit_and_abort[1]);
- list_free(pr->young_objects_with_light_finalizers);
- list_free(pr->old_objects_with_light_finalizers);
+ list_free(pr->young_objects_with_destructors);
+ list_free(pr->old_objects_with_destructors);
if (pr->active_queues) tree_free(pr->active_queues);
}
diff --git a/c8/stmgc.h b/c8/stmgc.h
--- a/c8/stmgc.h
+++ b/c8/stmgc.h
@@ -710,11 +710,11 @@
void stm_force_transaction_break(stm_thread_local_t *tl);
-/* Support for light finalizers. This is a simple version of
+/* Support for destructors. This is a simple version of
finalizers that guarantees not to do anything fancy, like not
resurrecting objects. */
-extern void (*stmcb_light_finalizer)(object_t *);
-void stm_enable_light_finalizer(object_t *);
+extern void (*stmcb_destructor)(object_t *);
+void stm_enable_destructor(object_t *);
/* Support for regular finalizers. Unreachable objects with
finalizers are kept alive, as well as everything they point to, and
@@ -742,7 +742,7 @@
'object_t *'. Note that the type 'stm_hashtable_t' is not an
object type at all; you need to allocate and free it explicitly.
If you want to embed the hashtable inside an 'object_t' you
- probably need a light finalizer to do the freeing. */
+ probably need a destructor to do the freeing. */
typedef struct stm_hashtable_s stm_hashtable_t;
typedef TLPREFIX struct stm_hashtable_entry_s stm_hashtable_entry_t;
@@ -797,8 +797,8 @@
/* Queues. The items you put() and get() back are in random order.
Like hashtables, the type 'stm_queue_t' is not an object type at
all; you need to allocate and free it explicitly. If you want to
- embed the queue inside an 'object_t' you probably need a light
- finalizer to do the freeing. */
+ embed the queue inside an 'object_t' you probably need a destructor
+ to do the freeing. */
typedef struct stm_queue_s stm_queue_t;
stm_queue_t *stm_queue_create(void);
diff --git a/c8/test/support.py b/c8/test/support.py
--- a/c8/test/support.py
+++ b/c8/test/support.py
@@ -206,9 +206,8 @@
bool (*_stm_smallmalloc_keep)(char *data);
void _stm_smallmalloc_sweep_test(void);
-
-void (*stmcb_light_finalizer)(object_t *);
-void stm_enable_light_finalizer(object_t *);
+void (*stmcb_destructor)(object_t *);
+void stm_enable_destructor(object_t *);
void (*stmcb_finalizer)(object_t *);
diff --git a/c8/test/test_finalizer.py b/c8/test/test_finalizer.py
--- a/c8/test/test_finalizer.py
+++ b/c8/test/test_finalizer.py
@@ -2,13 +2,13 @@
import py
-class TestLightFinalizer(BaseTest):
+class TestDestructors(BaseTest):
def setup_method(self, meth):
BaseTest.setup_method(self, meth)
#
@ffi.callback("void(object_t *)")
- def light_finalizer(obj):
+ def destructor(obj):
assert stm_get_obj_size(obj) == 48
segnum = lib.current_segment_num()
tlnum = '?'
@@ -17,21 +17,21 @@
if tl.last_associated_segment_num == segnum:
tlnum = n
break
- self.light_finalizers_called.append((obj, tlnum))
- self.light_finalizers_called = []
- lib.stmcb_light_finalizer = light_finalizer
- self._light_finalizer_keepalive = light_finalizer
+ self.destructors_called.append((obj, tlnum))
+ self.destructors_called = []
+ lib.stmcb_destructor = destructor
+ self._destructor_keepalive = destructor
def teardown_method(self, meth):
- lib.stmcb_light_finalizer = ffi.NULL
+ lib.stmcb_destructor = ffi.NULL
BaseTest.teardown_method(self, meth)
def expect_finalized(self, objs, from_tlnum=None):
- assert [obj for (obj, tlnum) in self.light_finalizers_called] == objs
+ assert [obj for (obj, tlnum) in self.destructors_called] == objs
if from_tlnum is not None:
- for obj, tlnum in self.light_finalizers_called:
+ for obj, tlnum in self.destructors_called:
assert tlnum == from_tlnum
- self.light_finalizers_called = []
+ self.destructors_called = []
def test_no_finalizer(self):
self.start_transaction()
@@ -39,45 +39,45 @@
self.commit_transaction()
self.expect_finalized([])
- def test_young_light_finalizer(self):
+ def test_young_destructor(self):
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.expect_finalized([])
self.commit_transaction()
self.expect_finalized([lp1], from_tlnum=0)
- def test_young_light_finalizer_survives(self):
+ def test_young_destructor_survives(self):
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.push_root(lp1) # stays alive
self.commit_transaction()
self.expect_finalized([])
- def test_young_light_finalizer_aborts(self):
+ def test_young_destructor_aborts(self):
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.expect_finalized([])
self.abort_transaction()
self.start_transaction()
self.expect_finalized([lp1], from_tlnum=0)
- def test_old_light_finalizer(self):
+ def test_old_destructor(self):
self.start_transaction()
lp1 = stm_allocate(48)
self.push_root(lp1)
stm_minor_collect()
lp1 = self.pop_root()
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.commit_transaction()
self.expect_finalized([])
- def test_old_light_finalizer_2(self):
+ def test_old_destructor_2(self):
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.push_root(lp1)
stm_minor_collect()
lp1 = self.pop_root()
@@ -86,10 +86,10 @@
self.expect_finalized([lp1])
self.commit_transaction()
- def test_old_light_finalizer_survives(self):
+ def test_old_destructor_survives(self):
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.push_root(lp1)
stm_minor_collect()
lp1 = self.pop_root()
@@ -98,13 +98,13 @@
self.commit_transaction()
self.expect_finalized([])
- def test_old_light_finalizer_segment(self):
+ def test_old_destructor_segment(self):
self.start_transaction()
#
self.switch(1)
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.push_root(lp1)
stm_minor_collect()
lp1 = self.pop_root()
@@ -114,10 +114,10 @@
stm_major_collect()
self.expect_finalized([lp1], from_tlnum=1)
- def test_old_light_finalizer_aborts(self):
+ def test_old_destructor_aborts(self):
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.push_root(lp1)
self.commit_transaction()
#
@@ -126,10 +126,10 @@
self.abort_transaction()
self.expect_finalized([])
- def test_overflow_light_finalizer_aborts(self):
+ def test_overflow_destructor_aborts(self):
self.start_transaction()
lp1 = stm_allocate(48)
- lib.stm_enable_light_finalizer(lp1)
+ lib.stm_enable_destructor(lp1)
self.push_root(lp1)
stm_minor_collect()
lp1 = self.pop_root()
diff --git a/c8/test/test_hashtable.py b/c8/test/test_hashtable.py
--- a/c8/test/test_hashtable.py
+++ b/c8/test/test_hashtable.py
@@ -43,8 +43,8 @@
BaseTest.setup_method(self, meth)
#
@ffi.callback("void(object_t *)")
- def light_finalizer(obj):
- print 'light_finalizer:', obj
+ def destructor(obj):
+ print 'destructor:', obj
try:
assert lib._get_type_id(obj) == 421419
self.seen_hashtables -= 1
@@ -54,20 +54,20 @@
self.errors.append(sys.exc_info()[2])
raise
- lib.stmcb_light_finalizer = light_finalizer
- self._light_finalizer_keepalive = light_finalizer
+ lib.stmcb_destructor = destructor
+ self._destructor_keepalive = destructor
self.seen_hashtables = 0
self.errors = []
def teardown_method(self, meth):
BaseTest.teardown_method(self, meth)
- lib.stmcb_light_finalizer = ffi.NULL
+ lib.stmcb_destructor = ffi.NULL
assert self.errors == []
assert self.seen_hashtables == 0
def allocate_hashtable(self):
h = stm_allocate_hashtable()
- lib.stm_enable_light_finalizer(h)
+ lib.stm_enable_destructor(h)
self.seen_hashtables += 1
return h
diff --git a/c8/test/test_queue.py b/c8/test/test_queue.py
--- a/c8/test/test_queue.py
+++ b/c8/test/test_queue.py
@@ -13,8 +13,8 @@
BaseTest.setup_method(self, meth)
#
@ffi.callback("void(object_t *)")
- def light_finalizer(obj):
- print 'light_finalizer:', obj
+ def destructor(obj):
+ print 'destructor:', obj
try:
assert lib._get_type_id(obj) == 421417
self.seen_queues -= 1
@@ -24,20 +24,20 @@
self.errors.append(sys.exc_info()[2])
raise
- lib.stmcb_light_finalizer = light_finalizer
- self._light_finalizer_keepalive = light_finalizer
+ lib.stmcb_destructor = destructor
+ self._destructor_keepalive = destructor
self.seen_queues = 0
self.errors = []
def teardown_method(self, meth):
BaseTest.teardown_method(self, meth)
- lib.stmcb_light_finalizer = ffi.NULL
+ lib.stmcb_destructor = ffi.NULL
assert self.errors == []
assert self.seen_queues == 0
def allocate_queue(self):
q = stm_allocate_queue()
- lib.stm_enable_light_finalizer(q)
+ lib.stm_enable_destructor(q)
self.seen_queues += 1
return q
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
