diff --git a/Makefile.am b/Makefile.am index f44568f..816fe55 100644 --- a/Makefile.am +++ b/Makefile.am @@ -5,8 +5,11 @@ ACLOCAL_AMFLAGS=-I m4 r3_includedir = $(includedir)/r3 r3_include_HEADERS = \ include/r3.h \ + include/r3_define.h \ + include/r3_list.h \ include/r3_str.h \ include/str_array.h \ + include/zmalloc.h \ $(NULL) pkgconfigdir = $(libdir)/pkgconfig diff --git a/include/zmalloc.h b/include/zmalloc.h new file mode 100644 index 0000000..76a3a7f --- /dev/null +++ b/include/zmalloc.h @@ -0,0 +1,85 @@ +#ifndef ZMALLOC_H +#define ZMALLOC_H + +/* zmalloc - total amount of allocated memory aware version of malloc() + * + * Copyright (c) 2009-2010, Salvatore Sanfilippo + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Redis nor the names of its contributors may be used + * to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* Double expansion needed for stringification of macro values. */ +#define __xstr(s) __str(s) +#define __str(s) #s + +#if defined(USE_TCMALLOC) +#define ZMALLOC_LIB ("tcmalloc-" __xstr(TC_VERSION_MAJOR) "." __xstr(TC_VERSION_MINOR)) +#include +#if (TC_VERSION_MAJOR == 1 && TC_VERSION_MINOR >= 6) || (TC_VERSION_MAJOR > 1) +#define HAVE_MALLOC_SIZE 1 +#define zmalloc_size(p) tc_malloc_size(p) +#else +#error "Newer version of tcmalloc required" +#endif + +#elif defined(USE_JEMALLOC) +#define ZMALLOC_LIB ("jemalloc-" __xstr(JEMALLOC_VERSION_MAJOR) "." __xstr(JEMALLOC_VERSION_MINOR) "." __xstr(JEMALLOC_VERSION_BUGFIX)) +#include +#if (JEMALLOC_VERSION_MAJOR == 2 && JEMALLOC_VERSION_MINOR >= 1) || (JEMALLOC_VERSION_MAJOR > 2) +#define HAVE_MALLOC_SIZE 1 +#define zmalloc_size(p) je_malloc_usable_size(p) +#else +#error "Newer version of jemalloc required" +#endif + +#elif defined(__APPLE__) +#include +#define HAVE_MALLOC_SIZE 1 +#define zmalloc_size(p) malloc_size(p) +#endif + +#ifndef ZMALLOC_LIB +#define ZMALLOC_LIB "libc" +#endif + +void *zmalloc(size_t size); +void *zcalloc(size_t size); +void *zrealloc(void *ptr, size_t size); +void zfree(void *ptr); +char *zstrdup(const char *s); +size_t zmalloc_used_memory(void); +void zmalloc_enable_thread_safeness(void); +void zmalloc_set_oom_handler(void (*oom_handler)(size_t)); +float zmalloc_get_fragmentation_ratio(size_t rss); +size_t zmalloc_get_rss(void); +size_t zmalloc_get_private_dirty(void); +void zlibc_free(void *ptr); + +#ifndef HAVE_MALLOC_SIZE +size_t zmalloc_size(void *ptr); +#endif + +#endif // ZMALLOC_H diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 8ef2c55..3e0e268 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 2.8) include_directories("${PROJECT_SOURCE_DIR}/include") # install(TARGETS swiftnav-static DESTINATION lib${LIB_SUFFIX}) -set(R3_SRCS node.c str.c list.c token.c edge.c) +set(R3_SRCS node.c str.c list.c token.c edge.c zmalloc.c) set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -pipe -g3 -funroll-loops -O0") # set(LIBS ${LIBS} ${PCRE_LIBRARIES} ${Judy_LIBRARIES} ${Jemalloc_LIBRARIES} r3) diff --git a/src/Makefile.am b/src/Makefile.am index 782cf5e..2e6234c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1,7 +1,6 @@ lib_LTLIBRARIES = libr3.la # lib_LIBRARIES = libr3.a -libr3_la_SOURCES = node.c edge.c str.c token.c - +libr3_la_SOURCES = node.c edge.c str.c token.c zmalloc.c # libr3_la_LDFLAGS = -export-symbols-regex '^r3_|^match_' libr3_la_LIBADD=$(DEPS_LIBS) diff --git a/src/edge.c b/src/edge.c index ae3c4c8..19f5645 100644 --- a/src/edge.c +++ b/src/edge.c @@ -24,7 +24,7 @@ #include "str_array.h" edge * r3_edge_create(char * pattern, int pattern_len, node * child) { - edge * e = (edge*) malloc( sizeof(edge) ); + edge * e = (edge*) zmalloc( sizeof(edge) ); e->pattern = pattern; e->pattern_len = pattern_len; e->child = child; @@ -69,17 +69,17 @@ node * r3_edge_branch(edge *e, int dl) { new_child->data = e->child->data; // copy data pointer e->child->data = NULL; - // truncate the original edge pattern + // truncate the original edge pattern char *op = e->pattern; e->pattern = strndup(e->pattern, dl); e->pattern_len = dl; - free(op); + zfree(op); return new_child; } void r3_edge_free(edge * e) { if (e->pattern) { - free(e->pattern); + zfree(e->pattern); } if ( e->child ) { r3_tree_free(e->child); diff --git a/src/gvc.c b/src/gvc.c index 86ccb67..6f75112 100644 --- a/src/gvc.c +++ b/src/gvc.c @@ -10,10 +10,11 @@ #include #include "r3.h" #include "r3_gvc.h" +#include "zmalloc.h" static char * node_id_str(int id) { - char * name = malloc(sizeof(char) * 20); + char * name = zmalloc(sizeof(char) * 20); sprintf(name, "#%d", id); return name; } @@ -41,7 +42,7 @@ void r3_tree_build_ag_nodes(Agraph_t * g, Agnode_t * ag_parent_node, node * n, i /** - * Render a tree to tree graph image via graphviz (dot) + * Render a tree to tree graph image via graphviz (dot) */ int r3_tree_render_dot(node * tree) { @@ -69,7 +70,7 @@ int r3_tree_render_dot(node * tree) /** - * Render a tree to tree graph image via graphviz (dot) + * Render a tree to tree graph image via graphviz (dot) */ int r3_tree_render_file(node * tree, char * format, char * filename) { diff --git a/src/list.c b/src/list.c index 4e80695..62b7729 100644 --- a/src/list.c +++ b/src/list.c @@ -6,56 +6,57 @@ */ #include #include "r3_list.h" - +#include "zmalloc.h" + /* Naive linked list implementation */ - + list * list_create() { - list *l = (list *) malloc(sizeof(list)); + list *l = (list *) zmalloc(sizeof(list)); l->count = 0; l->head = NULL; l->tail = NULL; pthread_mutex_init(&(l->mutex), NULL); return l; } - + void list_free(l) list *l; { list_item *li, *tmp; - + pthread_mutex_lock(&(l->mutex)); - + if (l != NULL) { li = l->head; while (li != NULL) { tmp = li->next; - free(li); + zfree(li); li = tmp; } } - + pthread_mutex_unlock(&(l->mutex)); pthread_mutex_destroy(&(l->mutex)); - free(l); + zfree(l); } - + list_item * list_add_element(l, ptr) list *l; void *ptr; { list_item *li; - + pthread_mutex_lock(&(l->mutex)); - - li = (list_item *) malloc(sizeof(list_item)); + + li = (list_item *) zmalloc(sizeof(list_item)); li->value = ptr; li->next = NULL; li->prev = l->tail; - + if (l->tail == NULL) { l->head = l->tail = li; } @@ -63,12 +64,12 @@ list_add_element(l, ptr) l->tail = li; } l->count++; - + pthread_mutex_unlock(&(l->mutex)); - + return li; } - + int list_remove_element(l, ptr) list *l; @@ -76,9 +77,9 @@ list_remove_element(l, ptr) { int result = 0; list_item *li = l->head; - + pthread_mutex_lock(&(l->mutex)); - + while (li != NULL) { if (li->value == ptr) { if (li->prev == NULL) { @@ -87,7 +88,7 @@ list_remove_element(l, ptr) else { li->prev->next = li->next; } - + if (li->next == NULL) { l->tail = li->prev; } @@ -95,27 +96,27 @@ list_remove_element(l, ptr) li->next->prev = li->prev; } l->count--; - free(li); + zfree(li); result = 1; break; } li = li->next; } - + pthread_mutex_unlock(&(l->mutex)); - + return result; } - + void list_each_element(l, func) list *l; int (*func)(list_item *); { list_item *li; - + pthread_mutex_lock(&(l->mutex)); - + li = l->head; while (li != NULL) { if (func(li) == 1) { @@ -123,6 +124,6 @@ list_each_element(l, func) } li = li->next; } - + pthread_mutex_unlock(&(l->mutex)); } diff --git a/src/node.c b/src/node.c index 9741e40..7308f65 100644 --- a/src/node.c +++ b/src/node.c @@ -17,13 +17,14 @@ #include "r3_define.h" #include "r3_str.h" #include "str_array.h" +#include "zmalloc.h" // String value as the index http://judy.sourceforge.net/doc/JudySL_3x.htm static int strndiff(char * d1, char * d2, unsigned int n) { char * o = d1; - while ( *d1 == *d2 && n-- > 0 ) { + while ( *d1 == *d2 && n-- > 0 ) { d1++; d2++; } @@ -32,7 +33,7 @@ static int strndiff(char * d1, char * d2, unsigned int n) { static int strdiff(char * d1, char * d2) { char * o = d1; - while( *d1 == *d2 ) { + while( *d1 == *d2 ) { d1++; d2++; } @@ -44,9 +45,9 @@ static int strdiff(char * d1, char * d2) { * Create a node object */ node * r3_tree_create(int cap) { - node * n = (node*) malloc( sizeof(node) ); + node * n = (node*) zmalloc( sizeof(node) ); - n->edges = (edge**) malloc( sizeof(edge*) * cap ); + n->edges = (edge**) zmalloc( sizeof(edge*) * cap ); n->edge_len = 0; n->edge_cap = cap; @@ -70,18 +71,18 @@ void r3_tree_free(node * tree) { } } if (tree->edges) - free(tree->edges); + zfree(tree->edges); if (tree->routes) - free(tree->routes); + zfree(tree->routes); if (tree->combined_pattern) - free(tree->combined_pattern); + zfree(tree->combined_pattern); if (tree->pcre_pattern) - free(tree->pcre_pattern); + zfree(tree->pcre_pattern); if (tree->pcre_extra) - free(tree->pcre_extra); - if (tree->ov) - free(tree->ov); - free(tree); + zfree(tree->pcre_extra); + if (tree->ov) + zfree(tree->ov); + zfree(tree); tree = NULL; } @@ -110,11 +111,11 @@ edge * r3_node_add_child(node * n, char * pat , node *child) { void r3_node_append_edge(node *n, edge *e) { if (n->edges == NULL) { n->edge_cap = 3; - n->edges = malloc(sizeof(edge) * n->edge_cap); + n->edges = zmalloc(sizeof(edge) * n->edge_cap); } if (n->edge_len >= n->edge_cap) { n->edge_cap *= 2; - edge ** p = realloc(n->edges, sizeof(edge) * n->edge_cap); + edge ** p = zrealloc(n->edges, sizeof(edge) * n->edge_cap); if(p) { n->edges = p; } @@ -157,7 +158,7 @@ void r3_tree_compile_patterns(node * n) { char * cpat; char * p; - cpat = calloc(sizeof(char),128); + cpat = zcalloc(128); if (cpat==NULL) return; @@ -189,7 +190,7 @@ void r3_tree_compile_patterns(node * n) { info("pattern: %s\n",cpat); n->ov_cnt = (1 + n->edge_len) * 3; - n->ov = (int*) calloc(sizeof(int), n->ov_cnt); + n->ov = (int*) zcalloc(n->ov_cnt); n->combined_pattern = cpat; @@ -201,9 +202,9 @@ void r3_tree_compile_patterns(node * n) { unsigned int option_bits = 0; if (n->pcre_pattern) - free(n->pcre_pattern); + zfree(n->pcre_pattern); if (n->pcre_extra) - free(n->pcre_extra); + zfree(n->pcre_extra); // n->pcre_pattern; n->pcre_pattern = pcre_compile( @@ -225,7 +226,7 @@ void r3_tree_compile_patterns(node * n) { match_entry * match_entry_createl(char * path, int path_len) { - match_entry * entry = malloc(sizeof(match_entry)); + match_entry * entry = zmalloc(sizeof(match_entry)); if(!entry) return NULL; entry->vars = str_array_create(3); @@ -237,7 +238,7 @@ match_entry * match_entry_createl(char * path, int path_len) { void match_entry_free(match_entry * entry) { str_array_free(entry->vars); - free(entry); + zfree(entry); } @@ -363,7 +364,7 @@ inline edge * r3_node_find_edge_str(const node * n, char * str, int str_len) { node * r3_node_create() { - node * n = (node*) malloc( sizeof(node) ); + node * n = (node*) zmalloc( sizeof(node) ); n->edges = NULL; n->edge_len = 0; n->edge_cap = 0; @@ -384,11 +385,11 @@ route * r3_route_create(char * path) { } void r3_route_free(route * route) { - free(route); + zfree(route); } route * r3_route_createl(char * path, int path_len) { - route * info = malloc(sizeof(route)); + route * info = zmalloc(sizeof(route)); info->path = path; info->path_len = path_len; info->request_method = 0; // can be (GET || POST) @@ -522,7 +523,7 @@ bool r3_node_has_slug_edges(node *n) { for ( int i = 0 ; i < n->edge_len ; i++ ) { e = n->edges[i]; e->has_slug = contains_slug(e->pattern); - if (e->has_slug) + if (e->has_slug) found = TRUE; } return found; @@ -600,16 +601,16 @@ int r3_route_cmp(route *r1, match_entry *r2) { /** - * + * */ void r3_node_append_route(node * n, route * r) { if (n->routes == NULL) { n->route_cap = 3; - n->routes = malloc(sizeof(route) * n->route_cap); + n->routes = zmalloc(sizeof(route) * n->route_cap); } if (n->route_len >= n->route_cap) { n->route_cap *= 2; - n->routes = realloc(n->routes, sizeof(route) * n->route_cap); + n->routes = zrealloc(n->routes, sizeof(route) * n->route_cap); } n->routes[ n->route_len++ ] = r; } diff --git a/src/str.c b/src/str.c index 3d70b7e..564c754 100644 --- a/src/str.c +++ b/src/str.c @@ -11,6 +11,7 @@ #include "r3.h" #include "r3_str.h" #include "str_array.h" +#include "zmalloc.h" /** * provide a quick way to count slugs, simply search for '{' @@ -134,11 +135,11 @@ char * slug_compile(char * str, int len) s1 = find_slug_placeholder(str, &s1_len); if ( s1 == NULL ) { - return strdup(str); + return zstrdup(str); } char * out = NULL; - if ((out = calloc(sizeof(char),200)) == NULL) { + if ((out = zcalloc(200)) == NULL) { return (NULL); } @@ -171,7 +172,7 @@ char * ltrim_slash(char* str) { char * p = str; while (*p == '/') p++; - return strdup(p); + return zstrdup(p); } void str_repeat(char *s, char *c, int len) { @@ -188,13 +189,13 @@ void print_indent(int level) { } #ifndef HAVE_STRDUP -char *strdup(const char *s) { +char *zstrdup(const char *s) { char *out; int count = 0; while( s[count] ) ++count; ++count; - out = malloc(sizeof(char) * count); + out = zmalloc(sizeof(char) * count); out[--count] = 0; while( --count >= 0 ) out[count] = s[count]; @@ -209,7 +210,7 @@ char *strndup(const char *s, int n) { while( count < n && s[count] ) ++count; ++count; - out = malloc(sizeof(char) * count); + out = zmalloc(sizeof(char) * count); out[--count] = 0; while( --count >= 0 ) out[count] = s[count]; diff --git a/src/token.c b/src/token.c index 6f2bc27..e0f23a8 100644 --- a/src/token.c +++ b/src/token.c @@ -10,22 +10,22 @@ #include #include "str_array.h" #include "r3_str.h" - +#include "zmalloc.h" str_array * str_array_create(int cap) { - str_array * list = (str_array*) malloc( sizeof(str_array) ); + str_array * list = (str_array*) zmalloc( sizeof(str_array) ); list->len = 0; list->cap = cap; - list->tokens = (char**) malloc( sizeof(char*) * cap); + list->tokens = (char**) zmalloc( sizeof(char*) * cap); return list; } void str_array_free(str_array *l) { for ( int i = 0; i < l->len ; i++ ) { char * t = l->tokens[ i ]; - free(t); + zfree(t); } - free(l); + zfree(l); } bool str_array_is_full(str_array * l) { @@ -33,7 +33,7 @@ bool str_array_is_full(str_array * l) { } bool str_array_resize(str_array *l, int new_cap) { - l->tokens = realloc(l->tokens, sizeof(char**) * new_cap); + l->tokens = zrealloc(l->tokens, sizeof(char**) * new_cap); l->cap = new_cap; return l->tokens != NULL; } diff --git a/src/zmalloc.c b/src/zmalloc.c new file mode 100644 index 0000000..d0cf726 --- /dev/null +++ b/src/zmalloc.c @@ -0,0 +1,351 @@ +/* zmalloc - total amount of allocated memory aware version of malloc() + * + * Copyright (c) 2009-2010, Salvatore Sanfilippo + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Redis nor the names of its contributors may be used + * to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +/* This function provide us access to the original libc free(). This is useful + * for instance to free results obtained by backtrace_symbols(). We need + * to define this function before including zmalloc.h that may shadow the + * free implementation if we use jemalloc or another non standard allocator. */ +void zlibc_free(void *ptr) { + free(ptr); +} + +#include +#include +#include "config.h" +#include "zmalloc.h" + +#ifdef HAVE_MALLOC_SIZE +#define PREFIX_SIZE (0) +#else +#if defined(__sun) || defined(__sparc) || defined(__sparc__) +#define PREFIX_SIZE (sizeof(long long)) +#else +#define PREFIX_SIZE (sizeof(size_t)) +#endif +#endif + +/* Explicitly override malloc/free etc when using tcmalloc. */ +#if defined(USE_TCMALLOC) +#define malloc(size) tc_malloc(size) +#define calloc(count,size) tc_calloc(count,size) +#define realloc(ptr,size) tc_realloc(ptr,size) +#define free(ptr) tc_free(ptr) +#elif defined(USE_JEMALLOC) +#define malloc(size) je_malloc(size) +#define calloc(count,size) je_calloc(count,size) +#define realloc(ptr,size) je_realloc(ptr,size) +#define free(ptr) je_free(ptr) +#endif + +#ifdef HAVE_ATOMIC +#define update_zmalloc_stat_add(__n) __sync_add_and_fetch(&used_memory, (__n)) +#define update_zmalloc_stat_sub(__n) __sync_sub_and_fetch(&used_memory, (__n)) +#else +#define update_zmalloc_stat_add(__n) do { \ + pthread_mutex_lock(&used_memory_mutex); \ + used_memory += (__n); \ + pthread_mutex_unlock(&used_memory_mutex); \ +} while(0) + +#define update_zmalloc_stat_sub(__n) do { \ + pthread_mutex_lock(&used_memory_mutex); \ + used_memory -= (__n); \ + pthread_mutex_unlock(&used_memory_mutex); \ +} while(0) + +#endif + +#define update_zmalloc_stat_alloc(__n) do { \ + size_t _n = (__n); \ + if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ + if (zmalloc_thread_safe) { \ + update_zmalloc_stat_add(_n); \ + } else { \ + used_memory += _n; \ + } \ +} while(0) + +#define update_zmalloc_stat_free(__n) do { \ + size_t _n = (__n); \ + if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ + if (zmalloc_thread_safe) { \ + update_zmalloc_stat_sub(_n); \ + } else { \ + used_memory -= _n; \ + } \ +} while(0) + +static size_t used_memory = 0; +static int zmalloc_thread_safe = 0; +pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER; + +static void zmalloc_default_oom(size_t size) { + fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n", + size); + fflush(stderr); + abort(); +} + +static void (*zmalloc_oom_handler)(size_t) = zmalloc_default_oom; + +void *zmalloc(size_t size) { + void *ptr = malloc(size+PREFIX_SIZE); + + if (!ptr) zmalloc_oom_handler(size); +#ifdef HAVE_MALLOC_SIZE + update_zmalloc_stat_alloc(zmalloc_size(ptr)); + return ptr; +#else + *((size_t*)ptr) = size; + update_zmalloc_stat_alloc(size+PREFIX_SIZE); + return (char*)ptr+PREFIX_SIZE; +#endif +} + +void *zcalloc(size_t size) { + void *ptr = calloc(1, size+PREFIX_SIZE); + + if (!ptr) zmalloc_oom_handler(size); +#ifdef HAVE_MALLOC_SIZE + update_zmalloc_stat_alloc(zmalloc_size(ptr)); + return ptr; +#else + *((size_t*)ptr) = size; + update_zmalloc_stat_alloc(size+PREFIX_SIZE); + return (char*)ptr+PREFIX_SIZE; +#endif +} + +void *zrealloc(void *ptr, size_t size) { +#ifndef HAVE_MALLOC_SIZE + void *realptr; +#endif + size_t oldsize; + void *newptr; + + if (ptr == NULL) return zmalloc(size); +#ifdef HAVE_MALLOC_SIZE + oldsize = zmalloc_size(ptr); + newptr = realloc(ptr,size); + if (!newptr) zmalloc_oom_handler(size); + + update_zmalloc_stat_free(oldsize); + update_zmalloc_stat_alloc(zmalloc_size(newptr)); + return newptr; +#else + realptr = (char*)ptr-PREFIX_SIZE; + oldsize = *((size_t*)realptr); + newptr = realloc(realptr,size+PREFIX_SIZE); + if (!newptr) zmalloc_oom_handler(size); + + *((size_t*)newptr) = size; + update_zmalloc_stat_free(oldsize); + update_zmalloc_stat_alloc(size); + return (char*)newptr+PREFIX_SIZE; +#endif +} + +/* Provide zmalloc_size() for systems where this function is not provided by + * malloc itself, given that in that case we store a header with this + * information as the first bytes of every allocation. */ +#ifndef HAVE_MALLOC_SIZE +size_t zmalloc_size(void *ptr) { + void *realptr = (char*)ptr-PREFIX_SIZE; + size_t size = *((size_t*)realptr); + /* Assume at least that all the allocations are padded at sizeof(long) by + * the underlying allocator. */ + if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1)); + return size+PREFIX_SIZE; +} +#endif + +void zfree(void *ptr) { +#ifndef HAVE_MALLOC_SIZE + void *realptr; + size_t oldsize; +#endif + + if (ptr == NULL) return; +#ifdef HAVE_MALLOC_SIZE + update_zmalloc_stat_free(zmalloc_size(ptr)); + free(ptr); +#else + realptr = (char*)ptr-PREFIX_SIZE; + oldsize = *((size_t*)realptr); + update_zmalloc_stat_free(oldsize+PREFIX_SIZE); + free(realptr); +#endif +} + +char *zstrdup(const char *s) { + size_t l = strlen(s)+1; + char *p = zmalloc(l); + + memcpy(p,s,l); + return p; +} + +size_t zmalloc_used_memory(void) { + size_t um; + + if (zmalloc_thread_safe) { +#ifdef HAVE_ATOMIC + um = __sync_add_and_fetch(&used_memory, 0); +#else + pthread_mutex_lock(&used_memory_mutex); + um = used_memory; + pthread_mutex_unlock(&used_memory_mutex); +#endif + } + else { + um = used_memory; + } + + return um; +} + +void zmalloc_enable_thread_safeness(void) { + zmalloc_thread_safe = 1; +} + +void zmalloc_set_oom_handler(void (*oom_handler)(size_t)) { + zmalloc_oom_handler = oom_handler; +} + +/* Get the RSS information in an OS-specific way. + * + * WARNING: the function zmalloc_get_rss() is not designed to be fast + * and may not be called in the busy loops where Redis tries to release + * memory expiring or swapping out objects. + * + * For this kind of "fast RSS reporting" usages use instead the + * function RedisEstimateRSS() that is a much faster (and less precise) + * version of the function. */ + +#if defined(HAVE_PROC_STAT) +#include +#include +#include +#include + +size_t zmalloc_get_rss(void) { + int page = sysconf(_SC_PAGESIZE); + size_t rss; + char buf[4096]; + char filename[256]; + int fd, count; + char *p, *x; + + snprintf(filename,256,"/proc/%d/stat",getpid()); + if ((fd = open(filename,O_RDONLY)) == -1) return 0; + if (read(fd,buf,4096) <= 0) { + close(fd); + return 0; + } + close(fd); + + p = buf; + count = 23; /* RSS is the 24th field in /proc//stat */ + while(p && count--) { + p = strchr(p,' '); + if (p) p++; + } + if (!p) return 0; + x = strchr(p,' '); + if (!x) return 0; + *x = '\0'; + + rss = strtoll(p,NULL,10); + rss *= page; + return rss; +} +#elif defined(HAVE_TASKINFO) +#include +#include +#include +#include +#include +#include +#include + +size_t zmalloc_get_rss(void) { + task_t task = MACH_PORT_NULL; + struct task_basic_info t_info; + mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT; + + if (task_for_pid(current_task(), getpid(), &task) != KERN_SUCCESS) + return 0; + task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count); + + return t_info.resident_size; +} +#else +size_t zmalloc_get_rss(void) { + /* If we can't get the RSS in an OS-specific way for this system just + * return the memory usage we estimated in zmalloc().. + * + * Fragmentation will appear to be always 1 (no fragmentation) + * of course... */ + return zmalloc_used_memory(); +} +#endif + +/* Fragmentation = RSS / allocated-bytes */ +float zmalloc_get_fragmentation_ratio(size_t rss) { + return (float)rss/zmalloc_used_memory(); +} + +#if defined(HAVE_PROC_SMAPS) +size_t zmalloc_get_private_dirty(void) { + char line[1024]; + size_t pd = 0; + FILE *fp = fopen("/proc/self/smaps","r"); + + if (!fp) return 0; + while(fgets(line,sizeof(line),fp) != NULL) { + if (strncmp(line,"Private_Dirty:",14) == 0) { + char *p = strchr(line,'k'); + if (p) { + *p = '\0'; + pd += strtol(line+14,NULL,10) * 1024; + } + } + } + fclose(fp); + return pd; +} +#else +size_t zmalloc_get_private_dirty(void) { + return 0; +} +#endif diff --git a/tests/check_tree.c b/tests/check_tree.c index cd5306c..6565f3b 100644 --- a/tests/check_tree.c +++ b/tests/check_tree.c @@ -31,7 +31,7 @@ START_TEST (test_r3_node_find_edge) node * child = r3_tree_create(3); - fail_if( r3_node_add_child(n, strdup("/add") , child) == FALSE ); + fail_if( r3_node_add_child(n, zstrdup("/add") , child) == FALSE ); fail_if( r3_node_find_edge(n, "/add") == NULL ); fail_if( r3_node_find_edge(n, "/bar") != NULL ); @@ -218,16 +218,16 @@ START_TEST (test_str_array) str_array * l = str_array_create(3); fail_if( l == NULL ); - fail_if( FALSE == str_array_append(l, strdup("abc") ) ); + fail_if( FALSE == str_array_append(l, zstrdup("abc") ) ); fail_if( l->len != 1 ); - fail_if( FALSE == str_array_append(l, strdup("foo") ) ); + fail_if( FALSE == str_array_append(l, zstrdup("foo") ) ); fail_if( l->len != 2 ); - fail_if( FALSE == str_array_append(l, strdup("bar") ) ); + fail_if( FALSE == str_array_append(l, zstrdup("bar") ) ); fail_if( l->len != 3 ); - fail_if( FALSE == str_array_append(l, strdup("zoo") ) ); + fail_if( FALSE == str_array_append(l, zstrdup("zoo") ) ); fail_if( l->len != 4 ); fail_if( FALSE == str_array_resize(l, l->cap * 2) ); @@ -707,7 +707,7 @@ r3_tree_insert_path(n, "/garply/grault/corge", NULL); r3_tree_compile(n); // r3_tree_dump(n, 0); - // match_entry *entry = calloc( sizeof(entry) , 1 ); + // match_entry *entry = zcalloc( 1 ); node *m; m = r3_tree_match(n , "/qux/bar/corge", NULL);