macosx specific zmalloc.c, uses malloc_size function in order to avoid to waste memor...

diff --git a/TODO b/TODO
index 9addd6e62bc1c33a6333bdd8a296f496ab0a2e1e..4fff80a850b6e5cdcef34f068c2b6fff145ca2cf 100644 (file)
--- a/TODO
+++ b/TODO
@@ -29,7 +29,8 @@ AFTER 1.0 stable release
    side the type also takes an hash table with key->score mapping, so that when
    there is an update we lookup the current score and can traverse the tree.
  * BITMAP type
    side the type also takes an hash table with key->score mapping, so that when
    there is an update we lookup the current score and can traverse the tree.
  * BITMAP type

- * LRANGE 4 0 should return the same elements as LRANGE 0 4 but in reverse order
+ * LRANGE 4 0 should return the same elements as LRANGE 0 4 but in reverse order (only if we get enough motivated requests about it)
+ * zmalloc() should avoid to add a private header for archs where there is some other kind of libc-specific way to get the size of a malloced block.

 
 FUTURE HINTS
 
 
 FUTURE HINTS
 

diff --git a/zmalloc.c b/zmalloc.c
index c76b2746e30c7063735c3b411205c127d44c99c7..4cb2c53c635002bae4b27d7aec3ba7dba91604b5 100644 (file)
--- a/zmalloc.c
+++ b/zmalloc.c
@@ -31,23 +31,45 @@
 #include <stdlib.h>
 #include <string.h>
 
 #include <stdlib.h>
 #include <string.h>
 

+#ifdef __APPLE__
+#include <malloc/malloc.h>
+#define HAVE_MALLOC_SIZE
+#define redis_malloc_size(p) malloc_size(p)
+#endif
+

 static size_t used_memory = 0;
 
 void *zmalloc(size_t size) {
     void *ptr = malloc(size+sizeof(size_t));
 
     if (!ptr) return NULL;
 static size_t used_memory = 0;
 
 void *zmalloc(size_t size) {
     void *ptr = malloc(size+sizeof(size_t));
 
     if (!ptr) return NULL;

+#ifdef HAVE_MALLOC_SIZE
+    used_memory += redis_malloc_size(ptr);
+    return ptr;
+#else

     *((size_t*)ptr) = size;
     used_memory += size+sizeof(size_t);
     return (char*)ptr+sizeof(size_t);
     *((size_t*)ptr) = size;
     used_memory += size+sizeof(size_t);
     return (char*)ptr+sizeof(size_t);

+#endif

 }
 
 void *zrealloc(void *ptr, size_t size) {
 }
 
 void *zrealloc(void *ptr, size_t size) {

+#ifndef HAVE_MALLOC_SIZE

     void *realptr;
     void *realptr;

+#endif

     size_t oldsize;
     void *newptr;
 
     if (ptr == NULL) return zmalloc(size);
     size_t oldsize;
     void *newptr;
 
     if (ptr == NULL) return zmalloc(size);

+#ifdef HAVE_MALLOC_SIZE
+    oldsize = redis_malloc_size(ptr);
+    newptr = realloc(ptr,size);
+    if (!newptr) return NULL;
+
+    used_memory -= oldsize;
+    used_memory += redis_malloc_size(newptr);
+    return newptr;
+#else

     realptr = (char*)ptr-sizeof(size_t);
     oldsize = *((size_t*)realptr);
     newptr = realloc(realptr,size+sizeof(size_t));
     realptr = (char*)ptr-sizeof(size_t);
     oldsize = *((size_t*)realptr);
     newptr = realloc(realptr,size+sizeof(size_t));


@@ -57,17 +79,25 @@ void *zrealloc(void *ptr, size_t size) {
     used_memory -= oldsize;
     used_memory += size;
     return (char*)newptr+sizeof(size_t);
     used_memory -= oldsize;
     used_memory += size;
     return (char*)newptr+sizeof(size_t);

+#endif

 }
 
 void zfree(void *ptr) {
 }
 
 void zfree(void *ptr) {

+#ifndef HAVE_MALLOC_SIZE

     void *realptr;
     size_t oldsize;
     void *realptr;
     size_t oldsize;

+#endif

 
     if (ptr == NULL) return;
 
     if (ptr == NULL) return;

+#ifdef HAVE_MALLOC_SIZE
+    used_memory -= redis_malloc_size(ptr);
+    free(ptr);
+#else

     realptr = (char*)ptr-sizeof(size_t);
     oldsize = *((size_t*)realptr);
     used_memory -= oldsize+sizeof(size_t);
     free(realptr);
     realptr = (char*)ptr-sizeof(size_t);
     oldsize = *((size_t*)realptr);
     used_memory -= oldsize+sizeof(size_t);
     free(realptr);

+#endif

 }
 
 char *zstrdup(const char *s) {
 }
 
 char *zstrdup(const char *s) {