py: First steps making GC reentrant.

dpgeorge · dpgeorge · commit 788f191e0693 · 2014-10-16T22:36:28.000+01:00
diff --git a/py/gc.c b/py/gc.c
diff --git a/py/gc.h b/py/gc.h
@@ -28,13 +28,12 @@ void gc_init(void *start, void *end);
 
 // These lock/unlock functions can be nested.
 // They can be used to prevent the GC from allocating/freeing.
-void gc_lock(void);
-void gc_unlock(void);
-bool gc_is_locked(void);
+void gc_disable(void);
+void gc_enable(void);
 
 // A given port must implement gc_collect by using the other collect functions.
 void gc_collect(void);
-void gc_collect_start(void);
+bool gc_collect_start(void); // returns true if collection can proceed
 void gc_collect_root(void **ptrs, mp_uint_t len);
 void gc_collect_end(void);
 
diff --git a/py/modgc.c b/py/modgc.c
@@ -55,19 +55,19 @@ MP_DEFINE_CONST_FUN_OBJ_0(gc_collect_obj, py_gc_collect);
 
 /// \function disable()
 /// Disable the garbage collector.
-STATIC mp_obj_t gc_disable(void) {
-    gc_lock();
+STATIC mp_obj_t mod_gc_disable(void) {
+    gc_disable();
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_0(gc_disable_obj, gc_disable);
+MP_DEFINE_CONST_FUN_OBJ_0(gc_disable_obj, mod_gc_disable);
 
 /// \function enable()
 /// Enable the garbage collector.
-STATIC mp_obj_t gc_enable(void) {
-    gc_unlock();
+STATIC mp_obj_t mod_gc_enable(void) {
+    gc_enable();
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_0(gc_enable_obj, gc_enable);
+MP_DEFINE_CONST_FUN_OBJ_0(gc_enable_obj, mod_gc_enable);
 
 /// \function mem_free()
 /// Return the number of bytes of available heap RAM.
diff --git a/py/objexcept.c b/py/objexcept.c
@@ -436,7 +436,8 @@ void mp_obj_exception_clear_traceback(mp_obj_t self_in) {
 void mp_obj_exception_add_traceback(mp_obj_t self_in, qstr file, mp_uint_t line, qstr block) {
     GET_NATIVE_EXCEPTION(self, self_in);
 
-    #if MICROPY_ENABLE_GC
+    #if 0 && MICROPY_ENABLE_GC
+    // TODO
     if (gc_is_locked()) {
         if (self->traceback == MP_OBJ_NULL) {
             // We can't allocate any memory, and no memory has been
diff --git a/py/runtime.c b/py/runtime.c
@@ -1208,17 +1208,8 @@ mp_obj_t mp_parse_compile_execute(mp_lexer_t *lex, mp_parse_input_kind_t parse_i
 
 void *m_malloc_fail(size_t num_bytes) {
     DEBUG_printf("memory allocation failed, allocating " UINT_FMT " bytes\n", num_bytes);
-    if (0) {
-        // dummy
-    #if MICROPY_ENABLE_GC
-    } else if (gc_is_locked()) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_MemoryError,
-                                           "memory allocation failed, heap is locked"));
-    #endif
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError,
-                                                "memory allocation failed, allocating " UINT_FMT " bytes", num_bytes));
-    }
+    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError,
+                                            "memory allocation failed, allocating " UINT_FMT " bytes", num_bytes));
 }
 
 NORETURN void mp_not_implemented(const char *msg) {
diff --git a/stmhal/extint.c b/stmhal/extint.c
@@ -361,9 +361,6 @@ void Handle_EXTI_Irq(uint32_t line) {
         if (line < EXTI_NUM_VECTORS) {
             extint_vector_t *v = &extint_vector[line];
             if (v->callback_obj != mp_const_none) {
-                // When executing code within a handler we must lock the GC to prevent
-                // any memory allocations.  We must also catch any exceptions.
-                gc_lock();
                 nlr_buf_t nlr;
                 if (nlr_push(&nlr) == 0) {
                     mp_call_function_1(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line));
@@ -375,7 +372,6 @@ void Handle_EXTI_Irq(uint32_t line) {
                     printf("Uncaught exception in ExtInt interrupt handler line %lu\n", line);
                     mp_obj_print_exception((mp_obj_t)nlr.ret_val);
                 }
-                gc_unlock();
             }
         }
     }
diff --git a/stmhal/gccollect.c b/stmhal/gccollect.c
@@ -45,7 +45,10 @@ void gc_collect(void) {
     uint32_t start = HAL_GetTick();
 
     // start the GC
-    gc_collect_start();
+    if (!gc_collect_start()) {
+        // gc is already running
+        return;
+    }
 
     // We need to scan everything in RAM that can hold a pointer.
     // The data segment is used, but should not contain pointers, so we just scan the bss.
diff --git a/stmhal/timer.c b/stmhal/timer.c
@@ -1229,9 +1229,6 @@ STATIC void timer_handle_irq_channel(pyb_timer_obj_t *tim, uint8_t channel, mp_o
 
             // execute callback if it's set
             if (callback != mp_const_none) {
-                // When executing code within a handler we must lock the GC to prevent
-                // any memory allocations.  We must also catch any exceptions.
-                gc_lock();
                 nlr_buf_t nlr;
                 if (nlr_push(&nlr) == 0) {
                     mp_call_function_1(callback, tim);
@@ -1247,7 +1244,6 @@ STATIC void timer_handle_irq_channel(pyb_timer_obj_t *tim, uint8_t channel, mp_o
                     }
                     mp_obj_print_exception((mp_obj_t)nlr.ret_val);
                 }
-                gc_unlock();
             }
         }
     }
diff --git a/unix/gccollect.c b/unix/gccollect.c
@@ -128,7 +128,11 @@ void gc_helper_get_regs(regs_t arr) {
 void gc_collect(void) {
     //gc_dump_info();
 
-    gc_collect_start();
+    if (!gc_collect_start()) {
+        // gc is already running
+        return;
+    }
+
     // this traces the .bss section
 #if defined( __CYGWIN__ )
 #define BSS_START __bss_start__

Original file line number	Diff line number	Diff line change
`@@ -361,9 +361,6 @@ void Handle_EXTI_Irq(uint32_t line) {`
`361`	`361`	`if (line < EXTI_NUM_VECTORS) {`
`362`	`362`	`extint_vector_t *v = &extint_vector[line];`
`363`	`363`	`if (v->callback_obj != mp_const_none) {`
`364`		`- // When executing code within a handler we must lock the GC to prevent`
`365`		`- // any memory allocations. We must also catch any exceptions.`
`366`		`- gc_lock();`
`367`	`364`	`nlr_buf_t nlr;`
`368`	`365`	`if (nlr_push(&nlr) == 0) {`
`369`	`366`	`mp_call_function_1(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line));`
`@@ -375,7 +372,6 @@ void Handle_EXTI_Irq(uint32_t line) {`
`375`	`372`	`printf("Uncaught exception in ExtInt interrupt handler line %lu\n", line);`
`376`	`373`	`mp_obj_print_exception((mp_obj_t)nlr.ret_val);`
`377`	`374`	`}`
`378`		`- gc_unlock();`
`379`	`375`	`}`
`380`	`376`	`}`
`381`	`377`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1229,9 +1229,6 @@ STATIC void timer_handle_irq_channel(pyb_timer_obj_t *tim, uint8_t channel, mp_o`
`1229`	`1229`
`1230`	`1230`	`// execute callback if it's set`
`1231`	`1231`	`if (callback != mp_const_none) {`
`1232`		`- // When executing code within a handler we must lock the GC to prevent`
`1233`		`- // any memory allocations. We must also catch any exceptions.`
`1234`		`- gc_lock();`
`1235`	`1232`	`nlr_buf_t nlr;`
`1236`	`1233`	`if (nlr_push(&nlr) == 0) {`
`1237`	`1234`	`mp_call_function_1(callback, tim);`
`@@ -1247,7 +1244,6 @@ STATIC void timer_handle_irq_channel(pyb_timer_obj_t *tim, uint8_t channel, mp_o`
`1247`	`1244`	`}`
`1248`	`1245`	`mp_obj_print_exception((mp_obj_t)nlr.ret_val);`
`1249`	`1246`	`}`
`1250`		`- gc_unlock();`
`1251`	`1247`	`}`
`1252`	`1248`	`}`
`1253`	`1249`	`}`