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 34 /* This function provide us access to the original libc free(). This is useful 35 * for instance to free results obtained by backtrace_symbols(). We need 36 * to define this function before including zmalloc.h that may shadow the 37 * free implementation if we use jemalloc or another non standard allocator. */ 38 void zlibc_free(void *ptr) { 39 free(ptr); 40 } 41 42 #include <string.h> 43 #include <pthread.h> 44 #include "config.h" 45 #include "zmalloc.h" 46 47 #ifdef HAVE_MALLOC_SIZE 48 #define PREFIX_SIZE (0) 49 #else 50 #if defined(__sun) || defined(__sparc) || defined(__sparc__) 51 #define PREFIX_SIZE (sizeof(long long)) 52 #else 53 #define PREFIX_SIZE (sizeof(size_t)) 54 #endif 55 #endif 56 57 /* Explicitly override malloc/free etc when using tcmalloc. */ 58 #if defined(USE_TCMALLOC) 59 #define malloc(size) tc_malloc(size) 60 #define calloc(count,size) tc_calloc(count,size) 61 #define realloc(ptr,size) tc_realloc(ptr,size) 62 #define free(ptr) tc_free(ptr) 63 #elif defined(USE_JEMALLOC) 64 #define malloc(size) je_malloc(size) 65 #define calloc(count,size) je_calloc(count,size) 66 #define realloc(ptr,size) je_realloc(ptr,size) 67 #define free(ptr) je_free(ptr) 68 #endif 69 70 #ifdef HAVE_ATOMIC 71 #define update_zmalloc_stat_add(__n) __sync_add_and_fetch(&used_memory, (__n)) 72 #define update_zmalloc_stat_sub(__n) __sync_sub_and_fetch(&used_memory, (__n)) 73 #else 74 #define update_zmalloc_stat_add(__n) do { \ 75 pthread_mutex_lock(&used_memory_mutex); \ 76 used_memory += (__n); \ 77 pthread_mutex_unlock(&used_memory_mutex); \ 78 } while(0) 79 80 #define update_zmalloc_stat_sub(__n) do { \ 81 pthread_mutex_lock(&used_memory_mutex); \ 82 used_memory -= (__n); \ 83 pthread_mutex_unlock(&used_memory_mutex); \ 84 } while(0) 85 86 #endif 87 88 #define update_zmalloc_stat_alloc(__n) do { \ 89 size_t _n = (__n); \ 90 if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ 91 if (zmalloc_thread_safe) { \ 92 update_zmalloc_stat_add(_n); \ 93 } else { \ 94 used_memory += _n; \ 95 } \ 96 } while(0) 97 98 #define update_zmalloc_stat_free(__n) do { \ 99 size_t _n = (__n); \ 100 if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ 101 if (zmalloc_thread_safe) { \ 102 update_zmalloc_stat_sub(_n); \ 103 } else { \ 104 used_memory -= _n; \ 105 } \ 106 } while(0) 107 108 static size_t used_memory = 0; 109 static int zmalloc_thread_safe = 0; 110 pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER; 111 112 static void zmalloc_default_oom(size_t size) { 113 fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n", 114 size); 115 fflush(stderr); 116 abort(); 117 } 118 119 static void (*zmalloc_oom_handler)(size_t) = zmalloc_default_oom; 120 121 void *zmalloc(size_t size) { 122 void *ptr = malloc(size+PREFIX_SIZE); 123 124 if (!ptr) zmalloc_oom_handler(size); 125 #ifdef HAVE_MALLOC_SIZE 126 update_zmalloc_stat_alloc(zmalloc_size(ptr)); 127 return ptr; 128 #else 129 *((size_t*)ptr) = size; 130 update_zmalloc_stat_alloc(size+PREFIX_SIZE); 131 return (char*)ptr+PREFIX_SIZE; 132 #endif 133 } 134 135 void *zcalloc(size_t size) { 136 void *ptr = calloc(1, size+PREFIX_SIZE); 137 138 if (!ptr) zmalloc_oom_handler(size); 139 #ifdef HAVE_MALLOC_SIZE 140 update_zmalloc_stat_alloc(zmalloc_size(ptr)); 141 return ptr; 142 #else 143 *((size_t*)ptr) = size; 144 update_zmalloc_stat_alloc(size+PREFIX_SIZE); 145 return (char*)ptr+PREFIX_SIZE; 146 #endif 147 } 148 149 void *zrealloc(void *ptr, size_t size) { 150 #ifndef HAVE_MALLOC_SIZE 151 void *realptr; 152 #endif 153 size_t oldsize; 154 void *newptr; 155 156 if (ptr == NULL) return zmalloc(size); 157 #ifdef HAVE_MALLOC_SIZE 158 oldsize = zmalloc_size(ptr); 159 newptr = realloc(ptr,size); 160 if (!newptr) zmalloc_oom_handler(size); 161 162 update_zmalloc_stat_free(oldsize); 163 update_zmalloc_stat_alloc(zmalloc_size(newptr)); 164 return newptr; 165 #else 166 realptr = (char*)ptr-PREFIX_SIZE; 167 oldsize = *((size_t*)realptr); 168 newptr = realloc(realptr,size+PREFIX_SIZE); 169 if (!newptr) zmalloc_oom_handler(size); 170 171 *((size_t*)newptr) = size; 172 update_zmalloc_stat_free(oldsize); 173 update_zmalloc_stat_alloc(size); 174 return (char*)newptr+PREFIX_SIZE; 175 #endif 176 } 177 178 /* Provide zmalloc_size() for systems where this function is not provided by 179 * malloc itself, given that in that case we store an header with this 180 * information as the first bytes of every allocation. */ 181 #ifndef HAVE_MALLOC_SIZE 182 size_t zmalloc_size(void *ptr) { 183 void *realptr = (char*)ptr-PREFIX_SIZE; 184 size_t size = *((size_t*)realptr); 185 /* Assume at least that all the allocations are padded at sizeof(long) by 186 * the underlying allocator. */ 187 if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1)); 188 return size+PREFIX_SIZE; 189 } 190 #endif 191 192 void zfree(void *ptr) { 193 #ifndef HAVE_MALLOC_SIZE 194 void *realptr; 195 size_t oldsize; 196 #endif 197 198 if (ptr == NULL) return; 199 #ifdef HAVE_MALLOC_SIZE 200 update_zmalloc_stat_free(zmalloc_size(ptr)); 201 free(ptr); 202 #else 203 realptr = (char*)ptr-PREFIX_SIZE; 204 oldsize = *((size_t*)realptr); 205 update_zmalloc_stat_free(oldsize+PREFIX_SIZE); 206 free(realptr); 207 #endif 208 } 209 210 char *zstrdup(const char *s) { 211 size_t l = strlen(s)+1; 212 char *p = zmalloc(l); 213 214 memcpy(p,s,l); 215 return p; 216 } 217 218 size_t zmalloc_used_memory(void) { 219 size_t um; 220 221 if (zmalloc_thread_safe) { 222 #ifdef HAVE_ATOMIC 223 um = __sync_add_and_fetch(&used_memory, 0); 224 #else 225 pthread_mutex_lock(&used_memory_mutex); 226 um = used_memory; 227 pthread_mutex_unlock(&used_memory_mutex); 228 #endif 229 } 230 else { 231 um = used_memory; 232 } 233 234 return um; 235 } 236 237 void zmalloc_enable_thread_safeness(void) { 238 zmalloc_thread_safe = 1; 239 } 240 241 void zmalloc_set_oom_handler(void (*oom_handler)(size_t)) { 242 zmalloc_oom_handler = oom_handler; 243 } 244 245 /* Get the RSS information in an OS-specific way. 246 * 247 * WARNING: the function zmalloc_get_rss() is not designed to be fast 248 * and may not be called in the busy loops where Redis tries to release 249 * memory expiring or swapping out objects. 250 * 251 * For this kind of "fast RSS reporting" usages use instead the 252 * function RedisEstimateRSS() that is a much faster (and less precise) 253 * version of the function. */ 254 255 #if defined(HAVE_PROC_STAT) 256 #include <unistd.h> 257 #include <sys/types.h> 258 #include <sys/stat.h> 259 #include <fcntl.h> 260 261 size_t zmalloc_get_rss(void) { 262 int page = sysconf(_SC_PAGESIZE); 263 size_t rss; 264 char buf[4096]; 265 char filename[256]; 266 int fd, count; 267 char *p, *x; 268 269 snprintf(filename,256,"/proc/%d/stat",getpid()); 270 if ((fd = open(filename,O_RDONLY)) == -1) return 0; 271 if (read(fd,buf,4096) <= 0) { 272 close(fd); 273 return 0; 274 } 275 close(fd); 276 277 p = buf; 278 count = 23; /* RSS is the 24th field in /proc/<pid>/stat */ 279 while(p && count--) { 280 p = strchr(p,' '); 281 if (p) p++; 282 } 283 if (!p) return 0; 284 x = strchr(p,' '); 285 if (!x) return 0; 286 *x = '\0'; 287 288 rss = strtoll(p,NULL,10); 289 rss *= page; 290 return rss; 291 } 292 #elif defined(HAVE_TASKINFO) 293 #include <unistd.h> 294 #include <stdio.h> 295 #include <stdlib.h> 296 #include <sys/types.h> 297 #include <sys/sysctl.h> 298 #include <mach/task.h> 299 #include <mach/mach_init.h> 300 301 size_t zmalloc_get_rss(void) { 302 task_t task = MACH_PORT_NULL; 303 struct task_basic_info t_info; 304 mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT; 305 306 if (task_for_pid(current_task(), getpid(), &task) != KERN_SUCCESS) 307 return 0; 308 task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count); 309 310 return t_info.resident_size; 311 } 312 #else 313 size_t zmalloc_get_rss(void) { 314 /* If we can't get the RSS in an OS-specific way for this system just 315 * return the memory usage we estimated in zmalloc().. 316 * 317 * Fragmentation will appear to be always 1 (no fragmentation) 318 * of course... */ 319 return zmalloc_used_memory(); 320 } 321 #endif 322 323 /* Fragmentation = RSS / allocated-bytes */ 324 float zmalloc_get_fragmentation_ratio(void) { 325 return (float)zmalloc_get_rss()/zmalloc_used_memory(); 326 } 327 328 #if defined(HAVE_PROC_SMAPS) 329 size_t zmalloc_get_private_dirty(void) { 330 char line[1024]; 331 size_t pd = 0; 332 FILE *fp = fopen("/proc/self/smaps","r"); 333 334 if (!fp) return 0; 335 while(fgets(line,sizeof(line),fp) != NULL) { 336 if (strncmp(line,"Private_Dirty:",14) == 0) { 337 char *p = strchr(line,'k'); 338 if (p) { 339 *p = '\0'; 340 pd += strtol(line+14,NULL,10) * 1024; 341 } 342 } 343 } 344 fclose(fp); 345 return pd; 346 } 347 #else 348 size_t zmalloc_get_private_dirty(void) { 349 return 0; 350 } 351 #endif 352