Add new alloc metric: current_bytes_allocated.

pfalcon · pfalcon · commit 02de0c57d233 · 2014-01-03T18:55:23.000+02:00
Unlike total_bytes_allocated, this tracks m_free()'s too.
diff --git a/py/malloc.c b/py/malloc.c
@@ -4,6 +4,7 @@
 #include "misc.h"
 
 static int total_bytes_allocated = 0;
+static int current_bytes_allocated = 0;
 
 void *m_malloc(int num_bytes) {
     if (num_bytes == 0) {
@@ -15,6 +16,7 @@ void *m_malloc(int num_bytes) {
         return NULL;
     }
     total_bytes_allocated += num_bytes;
+    current_bytes_allocated += num_bytes;
     return ptr;
 }
 
@@ -28,6 +30,7 @@ void *m_malloc0(int num_bytes) {
         return NULL;
     }
     total_bytes_allocated += num_bytes;
+    current_bytes_allocated += num_bytes;
     return ptr;
 }
 
@@ -46,16 +49,23 @@ void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes) {
     // shrunk to 1K and then grown to 2K again. It's still 2K
     // allocated total. If we process only positive increments,
     // we'll count 3K.
-    total_bytes_allocated += new_num_bytes - old_num_bytes;
+    int diff = new_num_bytes - old_num_bytes;
+    total_bytes_allocated += diff;
+    current_bytes_allocated += diff;
     return ptr;
 }
 
 void m_free(void *ptr, int num_bytes) {
     if (ptr != NULL) {
         free(ptr);
     }
+    current_bytes_allocated -= num_bytes;
 }
 
 int m_get_total_bytes_allocated(void) {
     return total_bytes_allocated;
 }
+
+int m_get_current_bytes_allocated(void) {
+    return current_bytes_allocated;
+}
diff --git a/py/misc.h b/py/misc.h
@@ -32,6 +32,7 @@ void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes);
 void m_free(void *ptr, int num_bytes);
 
 int m_get_total_bytes_allocated(void);
+int m_get_current_bytes_allocated(void);
 
 /** unichar / UTF-8 *********************************************/
 

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`#include "misc.h"`
`5`	`5`
`6`	`6`	`static int total_bytes_allocated = 0;`
	`7`	`+static int current_bytes_allocated = 0;`
`7`	`8`
`8`	`9`	`void *m_malloc(int num_bytes) {`
`9`	`10`	`if (num_bytes == 0) {`
`@@ -15,6 +16,7 @@ void *m_malloc(int num_bytes) {`
`15`	`16`	`return NULL;`
`16`	`17`	`}`
`17`	`18`	`total_bytes_allocated += num_bytes;`
	`19`	`+ current_bytes_allocated += num_bytes;`
`18`	`20`	`return ptr;`
`19`	`21`	`}`
`20`	`22`
`@@ -28,6 +30,7 @@ void *m_malloc0(int num_bytes) {`
`28`	`30`	`return NULL;`
`29`	`31`	`}`
`30`	`32`	`total_bytes_allocated += num_bytes;`
	`33`	`+ current_bytes_allocated += num_bytes;`
`31`	`34`	`return ptr;`
`32`	`35`	`}`
`33`	`36`
`@@ -46,16 +49,23 @@ void m_realloc(void ptr, int old_num_bytes, int new_num_bytes) {`
`46`	`49`	`// shrunk to 1K and then grown to 2K again. It's still 2K`
`47`	`50`	`// allocated total. If we process only positive increments,`
`48`	`51`	`// we'll count 3K.`
`49`		`- total_bytes_allocated += new_num_bytes - old_num_bytes;`
	`52`	`+ int diff = new_num_bytes - old_num_bytes;`
	`53`	`+ total_bytes_allocated += diff;`
	`54`	`+ current_bytes_allocated += diff;`
`50`	`55`	`return ptr;`
`51`	`56`	`}`
`52`	`57`
`53`	`58`	`void m_free(void *ptr, int num_bytes) {`
`54`	`59`	`if (ptr != NULL) {`
`55`	`60`	`free(ptr);`
`56`	`61`	`}`
	`62`	`+ current_bytes_allocated -= num_bytes;`
`57`	`63`	`}`
`58`	`64`
`59`	`65`	`int m_get_total_bytes_allocated(void) {`
`60`	`66`	`return total_bytes_allocated;`
`61`	`67`	`}`
	`68`	`+`
	`69`	`+int m_get_current_bytes_allocated(void) {`
	`70`	`+ return current_bytes_allocated;`
	`71`	`+}`