py/gc: Add MICROPY_GC_CONSERVATIVE_CLEAR option to always zero memory.

dpgeorge · dpgeorge · commit 5ffe1d8dc079 · 2016-08-26T15:35:26.000+10:00
There can be stray pointers in memory blocks that are not properly zero'd after allocation. This patch adds a new config option to always zero all allocated memory (via gc_alloc and gc_realloc) and hence help to eliminate stray pointers. See issue adafruit#2195.
diff --git a/py/gc.c b/py/gc.c
@@ -480,12 +480,17 @@ void *gc_alloc(size_t n_bytes, bool has_finaliser) {
 
     GC_EXIT();
 
+    #if MICROPY_GC_CONSERVATIVE_CLEAR
+    // be conservative and zero out all the newly allocated blocks
+    memset((byte*)ret_ptr, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK);
+    #else
     // zero out the additional bytes of the newly allocated blocks
     // This is needed because the blocks may have previously held pointers
     // to the heap and will not be set to something else if the caller
     // doesn't actually use the entire block.  As such they will continue
     // to point to the heap and may prevent other blocks from being reclaimed.
     memset((byte*)ret_ptr + n_bytes, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK - n_bytes);
+    #endif
 
     #if MICROPY_ENABLE_FINALISER
     if (has_finaliser) {
@@ -713,8 +718,13 @@ void *gc_realloc(void *ptr_in, size_t n_bytes, bool allow_move) {
 
         GC_EXIT();
 
+        #if MICROPY_GC_CONSERVATIVE_CLEAR
+        // be conservative and zero out all the newly allocated blocks
+        memset((byte*)ptr_in + n_blocks * BYTES_PER_BLOCK, 0, (new_blocks - n_blocks) * BYTES_PER_BLOCK);
+        #else
         // zero out the additional bytes of the newly allocated blocks (see comment above in gc_alloc)
         memset((byte*)ptr_in + n_bytes, 0, new_blocks * BYTES_PER_BLOCK - n_bytes);
+        #endif
 
         #if EXTENSIVE_HEAP_PROFILING
         gc_dump_alloc_table();
diff --git a/py/malloc.c b/py/malloc.c
@@ -117,7 +117,10 @@ void *m_malloc0(size_t num_bytes) {
     if (ptr == NULL && num_bytes != 0) {
         return m_malloc_fail(num_bytes);
     }
+    // If this config is set then the GC clears all memory, so we don't need to.
+    #if !MICROPY_GC_CONSERVATIVE_CLEAR
     memset(ptr, 0, num_bytes);
+    #endif
     return ptr;
 }
 
diff --git a/py/mpconfig.h b/py/mpconfig.h
@@ -107,6 +107,15 @@
 #define MICROPY_ALLOC_GC_STACK_SIZE (64)
 #endif
 
+// Be conservative and always clear to zero newly (re)allocated memory in the GC.
+// This helps eliminate stray pointers that hold on to memory that's no longer
+// used.  It decreases performance due to unnecessary memory clearing.
+// TODO Do analysis to understand why some memory is not properly cleared and
+// find a more efficient way to clear it.
+#ifndef MICROPY_GC_CONSERVATIVE_CLEAR
+#define MICROPY_GC_CONSERVATIVE_CLEAR (1)
+#endif
+
 // Support automatic GC when reaching allocation threshold,
 // configurable by gc.threshold().
 #ifndef MICROPY_GC_ALLOC_THRESHOLD

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,10 @@ void *m_malloc0(size_t num_bytes) {`
`117`	`117`	`if (ptr == NULL && num_bytes != 0) {`
`118`	`118`	`return m_malloc_fail(num_bytes);`
`119`	`119`	`}`
	`120`	`+ // If this config is set then the GC clears all memory, so we don't need to.`
	`121`	`+ #if !MICROPY_GC_CONSERVATIVE_CLEAR`
`120`	`122`	`memset(ptr, 0, num_bytes);`
	`123`	`+ #endif`
`121`	`124`	`return ptr;`
`122`	`125`	`}`
`123`	`126`