Merge branch 'topic/zmalloc' of https://github.com/thedrow/r3 into thedrow-topic/zmalloc

This commit is contained in:
c9s 2014-05-21 14:51:25 +08:00
commit b1939e287d
12 changed files with 524 additions and 82 deletions

View file

@ -5,8 +5,11 @@ ACLOCAL_AMFLAGS=-I m4
r3_includedir = $(includedir)/r3 r3_includedir = $(includedir)/r3
r3_include_HEADERS = \ r3_include_HEADERS = \
include/r3.h \ include/r3.h \
include/r3_define.h \
include/r3_list.h \
include/r3_str.h \ include/r3_str.h \
include/str_array.h \ include/str_array.h \
include/zmalloc.h \
$(NULL) $(NULL)
pkgconfigdir = $(libdir)/pkgconfig pkgconfigdir = $(libdir)/pkgconfig

85
include/zmalloc.h Normal file
View file

@ -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 <antirez at gmail dot com>
* 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 <google/tcmalloc.h>
#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 <jemalloc/jemalloc.h>
#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 <malloc/malloc.h>
#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

View file

@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 2.8)
include_directories("${PROJECT_SOURCE_DIR}/include") include_directories("${PROJECT_SOURCE_DIR}/include")
# install(TARGETS swiftnav-static DESTINATION lib${LIB_SUFFIX}) # 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 (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -pipe -g3 -funroll-loops -O0")
# set(LIBS ${LIBS} ${PCRE_LIBRARIES} ${Judy_LIBRARIES} ${Jemalloc_LIBRARIES} r3) # set(LIBS ${LIBS} ${PCRE_LIBRARIES} ${Judy_LIBRARIES} ${Jemalloc_LIBRARIES} r3)

View file

@ -1,7 +1,6 @@
lib_LTLIBRARIES = libr3.la lib_LTLIBRARIES = libr3.la
# lib_LIBRARIES = libr3.a # 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_LDFLAGS = -export-symbols-regex '^r3_|^match_'
libr3_la_LIBADD=$(DEPS_LIBS) libr3_la_LIBADD=$(DEPS_LIBS)

View file

@ -24,7 +24,7 @@
#include "str_array.h" #include "str_array.h"
edge * r3_edge_create(char * pattern, int pattern_len, node * child) { 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 = pattern;
e->pattern_len = pattern_len; e->pattern_len = pattern_len;
e->child = child; e->child = child;
@ -69,17 +69,17 @@ node * r3_edge_branch(edge *e, int dl) {
new_child->data = e->child->data; // copy data pointer new_child->data = e->child->data; // copy data pointer
e->child->data = NULL; e->child->data = NULL;
// truncate the original edge pattern // truncate the original edge pattern
char *op = e->pattern; char *op = e->pattern;
e->pattern = strndup(e->pattern, dl); e->pattern = strndup(e->pattern, dl);
e->pattern_len = dl; e->pattern_len = dl;
free(op); zfree(op);
return new_child; return new_child;
} }
void r3_edge_free(edge * e) { void r3_edge_free(edge * e) {
if (e->pattern) { if (e->pattern) {
free(e->pattern); zfree(e->pattern);
} }
if ( e->child ) { if ( e->child ) {
r3_tree_free(e->child); r3_tree_free(e->child);

View file

@ -10,10 +10,11 @@
#include <stdlib.h> #include <stdlib.h>
#include "r3.h" #include "r3.h"
#include "r3_gvc.h" #include "r3_gvc.h"
#include "zmalloc.h"
static char * node_id_str(int id) { static char * node_id_str(int id) {
char * name = malloc(sizeof(char) * 20); char * name = zmalloc(sizeof(char) * 20);
sprintf(name, "#%d", id); sprintf(name, "#%d", id);
return name; 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) 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) int r3_tree_render_file(node * tree, char * format, char * filename)
{ {

View file

@ -6,56 +6,57 @@
*/ */
#include <stdlib.h> #include <stdlib.h>
#include "r3_list.h" #include "r3_list.h"
#include "zmalloc.h"
/* Naive linked list implementation */ /* Naive linked list implementation */
list * list *
list_create() list_create()
{ {
list *l = (list *) malloc(sizeof(list)); list *l = (list *) zmalloc(sizeof(list));
l->count = 0; l->count = 0;
l->head = NULL; l->head = NULL;
l->tail = NULL; l->tail = NULL;
pthread_mutex_init(&(l->mutex), NULL); pthread_mutex_init(&(l->mutex), NULL);
return l; return l;
} }
void void
list_free(l) list_free(l)
list *l; list *l;
{ {
list_item *li, *tmp; list_item *li, *tmp;
pthread_mutex_lock(&(l->mutex)); pthread_mutex_lock(&(l->mutex));
if (l != NULL) { if (l != NULL) {
li = l->head; li = l->head;
while (li != NULL) { while (li != NULL) {
tmp = li->next; tmp = li->next;
free(li); zfree(li);
li = tmp; li = tmp;
} }
} }
pthread_mutex_unlock(&(l->mutex)); pthread_mutex_unlock(&(l->mutex));
pthread_mutex_destroy(&(l->mutex)); pthread_mutex_destroy(&(l->mutex));
free(l); zfree(l);
} }
list_item * list_item *
list_add_element(l, ptr) list_add_element(l, ptr)
list *l; list *l;
void *ptr; void *ptr;
{ {
list_item *li; list_item *li;
pthread_mutex_lock(&(l->mutex)); pthread_mutex_lock(&(l->mutex));
li = (list_item *) malloc(sizeof(list_item)); li = (list_item *) zmalloc(sizeof(list_item));
li->value = ptr; li->value = ptr;
li->next = NULL; li->next = NULL;
li->prev = l->tail; li->prev = l->tail;
if (l->tail == NULL) { if (l->tail == NULL) {
l->head = l->tail = li; l->head = l->tail = li;
} }
@ -63,12 +64,12 @@ list_add_element(l, ptr)
l->tail = li; l->tail = li;
} }
l->count++; l->count++;
pthread_mutex_unlock(&(l->mutex)); pthread_mutex_unlock(&(l->mutex));
return li; return li;
} }
int int
list_remove_element(l, ptr) list_remove_element(l, ptr)
list *l; list *l;
@ -76,9 +77,9 @@ list_remove_element(l, ptr)
{ {
int result = 0; int result = 0;
list_item *li = l->head; list_item *li = l->head;
pthread_mutex_lock(&(l->mutex)); pthread_mutex_lock(&(l->mutex));
while (li != NULL) { while (li != NULL) {
if (li->value == ptr) { if (li->value == ptr) {
if (li->prev == NULL) { if (li->prev == NULL) {
@ -87,7 +88,7 @@ list_remove_element(l, ptr)
else { else {
li->prev->next = li->next; li->prev->next = li->next;
} }
if (li->next == NULL) { if (li->next == NULL) {
l->tail = li->prev; l->tail = li->prev;
} }
@ -95,27 +96,27 @@ list_remove_element(l, ptr)
li->next->prev = li->prev; li->next->prev = li->prev;
} }
l->count--; l->count--;
free(li); zfree(li);
result = 1; result = 1;
break; break;
} }
li = li->next; li = li->next;
} }
pthread_mutex_unlock(&(l->mutex)); pthread_mutex_unlock(&(l->mutex));
return result; return result;
} }
void void
list_each_element(l, func) list_each_element(l, func)
list *l; list *l;
int (*func)(list_item *); int (*func)(list_item *);
{ {
list_item *li; list_item *li;
pthread_mutex_lock(&(l->mutex)); pthread_mutex_lock(&(l->mutex));
li = l->head; li = l->head;
while (li != NULL) { while (li != NULL) {
if (func(li) == 1) { if (func(li) == 1) {
@ -123,6 +124,6 @@ list_each_element(l, func)
} }
li = li->next; li = li->next;
} }
pthread_mutex_unlock(&(l->mutex)); pthread_mutex_unlock(&(l->mutex));
} }

View file

@ -17,13 +17,14 @@
#include "r3_define.h" #include "r3_define.h"
#include "r3_str.h" #include "r3_str.h"
#include "str_array.h" #include "str_array.h"
#include "zmalloc.h"
// String value as the index http://judy.sourceforge.net/doc/JudySL_3x.htm // String value as the index http://judy.sourceforge.net/doc/JudySL_3x.htm
static int strndiff(char * d1, char * d2, unsigned int n) { static int strndiff(char * d1, char * d2, unsigned int n) {
char * o = d1; char * o = d1;
while ( *d1 == *d2 && n-- > 0 ) { while ( *d1 == *d2 && n-- > 0 ) {
d1++; d1++;
d2++; d2++;
} }
@ -32,7 +33,7 @@ static int strndiff(char * d1, char * d2, unsigned int n) {
static int strdiff(char * d1, char * d2) { static int strdiff(char * d1, char * d2) {
char * o = d1; char * o = d1;
while( *d1 == *d2 ) { while( *d1 == *d2 ) {
d1++; d1++;
d2++; d2++;
} }
@ -44,9 +45,9 @@ static int strdiff(char * d1, char * d2) {
* Create a node object * Create a node object
*/ */
node * r3_tree_create(int cap) { 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_len = 0;
n->edge_cap = cap; n->edge_cap = cap;
@ -70,18 +71,18 @@ void r3_tree_free(node * tree) {
} }
} }
if (tree->edges) if (tree->edges)
free(tree->edges); zfree(tree->edges);
if (tree->routes) if (tree->routes)
free(tree->routes); zfree(tree->routes);
if (tree->combined_pattern) if (tree->combined_pattern)
free(tree->combined_pattern); zfree(tree->combined_pattern);
if (tree->pcre_pattern) if (tree->pcre_pattern)
free(tree->pcre_pattern); zfree(tree->pcre_pattern);
if (tree->pcre_extra) if (tree->pcre_extra)
free(tree->pcre_extra); zfree(tree->pcre_extra);
if (tree->ov) if (tree->ov)
free(tree->ov); zfree(tree->ov);
free(tree); zfree(tree);
tree = NULL; 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) { void r3_node_append_edge(node *n, edge *e) {
if (n->edges == NULL) { if (n->edges == NULL) {
n->edge_cap = 3; 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) { if (n->edge_len >= n->edge_cap) {
n->edge_cap *= 2; 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) { if(p) {
n->edges = p; n->edges = p;
} }
@ -157,7 +158,7 @@ void r3_tree_compile_patterns(node * n) {
char * cpat; char * cpat;
char * p; char * p;
cpat = calloc(sizeof(char),128); cpat = zcalloc(128);
if (cpat==NULL) if (cpat==NULL)
return; return;
@ -189,7 +190,7 @@ void r3_tree_compile_patterns(node * n) {
info("pattern: %s\n",cpat); info("pattern: %s\n",cpat);
n->ov_cnt = (1 + n->edge_len) * 3; 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; n->combined_pattern = cpat;
@ -201,9 +202,9 @@ void r3_tree_compile_patterns(node * n) {
unsigned int option_bits = 0; unsigned int option_bits = 0;
if (n->pcre_pattern) if (n->pcre_pattern)
free(n->pcre_pattern); zfree(n->pcre_pattern);
if (n->pcre_extra) if (n->pcre_extra)
free(n->pcre_extra); zfree(n->pcre_extra);
// n->pcre_pattern; // n->pcre_pattern;
n->pcre_pattern = pcre_compile( 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 * match_entry_createl(char * path, int path_len) {
match_entry * entry = malloc(sizeof(match_entry)); match_entry * entry = zmalloc(sizeof(match_entry));
if(!entry) if(!entry)
return NULL; return NULL;
entry->vars = str_array_create(3); 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) { void match_entry_free(match_entry * entry) {
str_array_free(entry->vars); 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 * r3_node_create() {
node * n = (node*) malloc( sizeof(node) ); node * n = (node*) zmalloc( sizeof(node) );
n->edges = NULL; n->edges = NULL;
n->edge_len = 0; n->edge_len = 0;
n->edge_cap = 0; n->edge_cap = 0;
@ -384,11 +385,11 @@ route * r3_route_create(char * path) {
} }
void r3_route_free(route * route) { void r3_route_free(route * route) {
free(route); zfree(route);
} }
route * r3_route_createl(char * path, int path_len) { route * r3_route_createl(char * path, int path_len) {
route * info = malloc(sizeof(route)); route * info = zmalloc(sizeof(route));
info->path = path; info->path = path;
info->path_len = path_len; info->path_len = path_len;
info->request_method = 0; // can be (GET || POST) 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++ ) { for ( int i = 0 ; i < n->edge_len ; i++ ) {
e = n->edges[i]; e = n->edges[i];
e->has_slug = contains_slug(e->pattern); e->has_slug = contains_slug(e->pattern);
if (e->has_slug) if (e->has_slug)
found = TRUE; found = TRUE;
} }
return found; return found;
@ -600,16 +601,16 @@ int r3_route_cmp(route *r1, match_entry *r2) {
/** /**
* *
*/ */
void r3_node_append_route(node * n, route * r) { void r3_node_append_route(node * n, route * r) {
if (n->routes == NULL) { if (n->routes == NULL) {
n->route_cap = 3; 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) { if (n->route_len >= n->route_cap) {
n->route_cap *= 2; 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; n->routes[ n->route_len++ ] = r;
} }

View file

@ -11,6 +11,7 @@
#include "r3.h" #include "r3.h"
#include "r3_str.h" #include "r3_str.h"
#include "str_array.h" #include "str_array.h"
#include "zmalloc.h"
/** /**
* provide a quick way to count slugs, simply search for '{' * 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); s1 = find_slug_placeholder(str, &s1_len);
if ( s1 == NULL ) { if ( s1 == NULL ) {
return strdup(str); return zstrdup(str);
} }
char * out = NULL; char * out = NULL;
if ((out = calloc(sizeof(char),200)) == NULL) { if ((out = zcalloc(200)) == NULL) {
return (NULL); return (NULL);
} }
@ -171,7 +172,7 @@ char * ltrim_slash(char* str)
{ {
char * p = str; char * p = str;
while (*p == '/') p++; while (*p == '/') p++;
return strdup(p); return zstrdup(p);
} }
void str_repeat(char *s, char *c, int len) { void str_repeat(char *s, char *c, int len) {
@ -188,13 +189,13 @@ void print_indent(int level) {
} }
#ifndef HAVE_STRDUP #ifndef HAVE_STRDUP
char *strdup(const char *s) { char *zstrdup(const char *s) {
char *out; char *out;
int count = 0; int count = 0;
while( s[count] ) while( s[count] )
++count; ++count;
++count; ++count;
out = malloc(sizeof(char) * count); out = zmalloc(sizeof(char) * count);
out[--count] = 0; out[--count] = 0;
while( --count >= 0 ) while( --count >= 0 )
out[count] = s[count]; out[count] = s[count];
@ -209,7 +210,7 @@ char *strndup(const char *s, int n) {
while( count < n && s[count] ) while( count < n && s[count] )
++count; ++count;
++count; ++count;
out = malloc(sizeof(char) * count); out = zmalloc(sizeof(char) * count);
out[--count] = 0; out[--count] = 0;
while( --count >= 0 ) while( --count >= 0 )
out[count] = s[count]; out[count] = s[count];

View file

@ -10,22 +10,22 @@
#include <assert.h> #include <assert.h>
#include "str_array.h" #include "str_array.h"
#include "r3_str.h" #include "r3_str.h"
#include "zmalloc.h"
str_array * str_array_create(int cap) { 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->len = 0;
list->cap = cap; list->cap = cap;
list->tokens = (char**) malloc( sizeof(char*) * cap); list->tokens = (char**) zmalloc( sizeof(char*) * cap);
return list; return list;
} }
void str_array_free(str_array *l) { void str_array_free(str_array *l) {
for ( int i = 0; i < l->len ; i++ ) { for ( int i = 0; i < l->len ; i++ ) {
char * t = l->tokens[ i ]; char * t = l->tokens[ i ];
free(t); zfree(t);
} }
free(l); zfree(l);
} }
bool str_array_is_full(str_array * 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) { 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; l->cap = new_cap;
return l->tokens != NULL; return l->tokens != NULL;
} }

351
src/zmalloc.c Normal file
View file

@ -0,0 +1,351 @@
/* zmalloc - total amount of allocated memory aware version of malloc()
*
* Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
* 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 <stdio.h>
#include <stdlib.h>
/* 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 <string.h>
#include <pthread.h>
#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 <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
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/<pid>/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 <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <mach/task.h>
#include <mach/mach_init.h>
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

View file

@ -31,7 +31,7 @@ START_TEST (test_r3_node_find_edge)
node * child = r3_tree_create(3); 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, "/add") == NULL );
fail_if( r3_node_find_edge(n, "/bar") != 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); str_array * l = str_array_create(3);
fail_if( l == NULL ); 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( 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( 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( 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( l->len != 4 );
fail_if( FALSE == str_array_resize(l, l->cap * 2) ); 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_compile(n);
// r3_tree_dump(n, 0); // r3_tree_dump(n, 0);
// match_entry *entry = calloc( sizeof(entry) , 1 ); // match_entry *entry = zcalloc( 1 );
node *m; node *m;
m = r3_tree_match(n , "/qux/bar/corge", NULL); m = r3_tree_match(n , "/qux/bar/corge", NULL);