src/zmalloc.c

   1 /* zmalloc - total amount of allocated memory aware version of malloc()
   2  *
   3  * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   * Redistributions of source code must retain the above copyright notice,
  10  *     this list of conditions and the following disclaimer.
  11  *   * Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  *   * Neither the name of Redis nor the names of its contributors may be used
  15  *     to endorse or promote products derived from this software without
  16  *     specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <pthread.h>
  35
  36 #include "config.h"
  37
  38 #if defined(__sun)
  39 #define PREFIX_SIZE sizeof(long long)
  40 #else
  41 #define PREFIX_SIZE sizeof(size_t)
  42 #endif
  43
  44 #define increment_used_memory(__n) do { \
  45     size_t _n = (__n); \
  46     if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \
  47     if (zmalloc_thread_safe) { \
  48         pthread_mutex_lock(&used_memory_mutex);  \
  49         used_memory += _n; \
  50         pthread_mutex_unlock(&used_memory_mutex); \
  51     } else { \
  52         used_memory += _n; \
  53     } \
  54 } while(0)
  55
  56 #define decrement_used_memory(__n) do { \
  57     size_t _n = (__n); \
  58     if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \
  59     if (zmalloc_thread_safe) { \
  60         pthread_mutex_lock(&used_memory_mutex);  \
  61         used_memory -= _n; \
  62         pthread_mutex_unlock(&used_memory_mutex); \
  63     } else { \
  64         used_memory -= _n; \
  65     } \
  66 } while(0)
  67
  68 static size_t used_memory = 0;
  69 static int zmalloc_thread_safe = 0;
  70 pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER;
  71
  72 static void zmalloc_oom(size_t size) {
  73     fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n",
  74         size);
  75     fflush(stderr);
  76     abort();
  77 }
  78
  79 void *zmalloc(size_t size) {
  80     void *ptr = malloc(size+PREFIX_SIZE);
  81
  82     if (!ptr) zmalloc_oom(size);
  83 #ifdef HAVE_MALLOC_SIZE
  84     increment_used_memory(redis_malloc_size(ptr));
  85     return ptr;
  86 #else
  87     *((size_t*)ptr) = size;
  88     increment_used_memory(size+PREFIX_SIZE);
  89     return (char*)ptr+PREFIX_SIZE;
  90 #endif
  91 }
  92
  93 void *zcalloc(size_t size) {
  94     void *ptr = calloc(1, size+PREFIX_SIZE);
  95
  96     if (!ptr) zmalloc_oom(size);
  97 #ifdef HAVE_MALLOC_SIZE
  98     increment_used_memory(redis_malloc_size(ptr));
  99     return ptr;
 100 #else
 101     *((size_t*)ptr) = size;
 102     increment_used_memory(size+PREFIX_SIZE);
 103     return (char*)ptr+PREFIX_SIZE;
 104 #endif
 105 }
 106
 107 void *zrealloc(void *ptr, size_t size) {
 108 #ifndef HAVE_MALLOC_SIZE
 109     void *realptr;
 110 #endif
 111     size_t oldsize;
 112     void *newptr;
 113
 114     if (ptr == NULL) return zmalloc(size);
 115 #ifdef HAVE_MALLOC_SIZE
 116     oldsize = redis_malloc_size(ptr);
 117     newptr = realloc(ptr,size);
 118     if (!newptr) zmalloc_oom(size);
 119
 120     decrement_used_memory(oldsize);
 121     increment_used_memory(redis_malloc_size(newptr));
 122     return newptr;
 123 #else
 124     realptr = (char*)ptr-PREFIX_SIZE;
 125     oldsize = *((size_t*)realptr);
 126     newptr = realloc(realptr,size+PREFIX_SIZE);
 127     if (!newptr) zmalloc_oom(size);
 128
 129     *((size_t*)newptr) = size;
 130     decrement_used_memory(oldsize);
 131     increment_used_memory(size);
 132     return (char*)newptr+PREFIX_SIZE;
 133 #endif
 134 }
 135
 136 void zfree(void *ptr) {
 137 #ifndef HAVE_MALLOC_SIZE
 138     void *realptr;
 139     size_t oldsize;
 140 #endif
 141
 142     if (ptr == NULL) return;
 143 #ifdef HAVE_MALLOC_SIZE
 144     decrement_used_memory(redis_malloc_size(ptr));
 145     free(ptr);
 146 #else
 147     realptr = (char*)ptr-PREFIX_SIZE;
 148     oldsize = *((size_t*)realptr);
 149     decrement_used_memory(oldsize+PREFIX_SIZE);
 150     free(realptr);
 151 #endif
 152 }
 153
 154 char *zstrdup(const char *s) {
 155     size_t l = strlen(s)+1;
 156     char *p = zmalloc(l);
 157
 158     memcpy(p,s,l);
 159     return p;
 160 }
 161
 162 size_t zmalloc_used_memory(void) {
 163     size_t um;
 164
 165     if (zmalloc_thread_safe) pthread_mutex_lock(&used_memory_mutex);
 166     um = used_memory;
 167     if (zmalloc_thread_safe) pthread_mutex_unlock(&used_memory_mutex);
 168     return um;
 169 }
 170
 171 void zmalloc_enable_thread_safeness(void) {
 172     zmalloc_thread_safe = 1;
 173 }
 174
 175 /* Fragmentation = RSS / allocated-bytes */
 176
 177 #if defined(HAVE_PROCFS)
 178 #include <unistd.h>
 179 #include <sys/types.h>
 180 #include <sys/stat.h>
 181 #include <fcntl.h>
 182
 183 float zmalloc_get_fragmentation_ratio(void) {
 184     size_t allocated = zmalloc_used_memory();
 185     int page = sysconf(_SC_PAGESIZE);
 186     size_t rss;
 187     char buf[4096];
 188     char filename[256];
 189     int fd, count;
 190     char *p, *x;
 191
 192     snprintf(filename,256,"/proc/%d/stat",getpid());
 193     if ((fd = open(filename,O_RDONLY)) == -1) return 0;
 194     if (read(fd,buf,4096) <= 0) {
 195         close(fd);
 196         return 0;
 197     }
 198     close(fd);
 199
 200     p = buf;
 201     count = 23; /* RSS is the 24th field in /proc/<pid>/stat */
 202     while(p && count--) {
 203         p = strchr(p,' ');
 204         if (p) p++;
 205     }
 206     if (!p) return 0;
 207     x = strchr(p,' ');
 208     if (!x) return 0;
 209     *x = '\0';
 210
 211     rss = strtoll(p,NULL,10);
 212     rss *= page;
 213     return (float)rss/allocated;
 214 }
 215 #elif defined(HAVE_TASKINFO)
 216 #include <unistd.h>
 217 #include <stdio.h>
 218 #include <stdlib.h>
 219 #include <sys/types.h>
 220 #include <sys/sysctl.h>
 221 #include <mach/task.h>
 222 #include <mach/mach_init.h>
 223
 224 float zmalloc_get_fragmentation_ratio(void) {
 225     task_t task = MACH_PORT_NULL;
 226     struct task_basic_info t_info;
 227     mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
 228
 229     if (task_for_pid(current_task(), getpid(), &task) != KERN_SUCCESS)
 230         return 0;
 231     task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count);
 232
 233     return (float)t_info.resident_size/zmalloc_used_memory();
 234 }
 235 #else
 236 float zmalloc_get_fragmentation_ratio(void) {
 237     return 0;
 238 }
 239 #endif