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 #include "config.h" 36 #include "zmalloc.h" 37 38 #ifdef HAVE_MALLOC_SIZE 39 #define PREFIX_SIZE (0) 40 #else 41 #if defined(__sun) 42 #define PREFIX_SIZE (sizeof(long long)) 43 #else 44 #define PREFIX_SIZE (sizeof(size_t)) 45 #endif 46 #endif 47 48 /* Explicitly override malloc/free etc when using tcmalloc. */ 49 #if defined(USE_TCMALLOC) 50 #define malloc(size) tc_malloc(size) 51 #define calloc(count,size) tc_calloc(count,size) 52 #define realloc(ptr,size) tc_realloc(ptr,size) 53 #define free(ptr) tc_free(ptr) 54 #elif defined(USE_JEMALLOC) 55 #define malloc(size) je_malloc(size) 56 #define calloc(count,size) je_calloc(count,size) 57 #define realloc(ptr,size) je_realloc(ptr,size) 58 #define free(ptr) je_free(ptr) 59 #endif 60 61 #define update_zmalloc_stat_alloc(__n,__size) do { \ 62 size_t _n = (__n); \ 63 size_t _stat_slot = (__size < ZMALLOC_MAX_ALLOC_STAT) ? __size : ZMALLOC_MAX_ALLOC_STAT; \ 64 if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ 65 if (zmalloc_thread_safe) { \ 66 pthread_mutex_lock(&used_memory_mutex); \ 67 used_memory += _n; \ 68 zmalloc_allocations[_stat_slot]++; \ 69 pthread_mutex_unlock(&used_memory_mutex); \ 70 } else { \ 71 used_memory += _n; \ 72 zmalloc_allocations[_stat_slot]++; \ 73 } \ 74 } while(0) 75 76 #define update_zmalloc_stat_free(__n) do { \ 77 size_t _n = (__n); \ 78 if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ 79 if (zmalloc_thread_safe) { \ 80 pthread_mutex_lock(&used_memory_mutex); \ 81 used_memory -= _n; \ 82 pthread_mutex_unlock(&used_memory_mutex); \ 83 } else { \ 84 used_memory -= _n; \ 85 } \ 86 } while(0) 87 88 static size_t used_memory = 0; 89 static int zmalloc_thread_safe = 0; 90 pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER; 91 /* Note that malloc_allocations elements are initialized to zero by C */ 92 size_t zmalloc_allocations[ZMALLOC_MAX_ALLOC_STAT+1]; 93 94 static void zmalloc_oom(size_t size) { 95 fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n", 96 size); 97 fflush(stderr); 98 abort(); 99 } 100 101 void *zmalloc(size_t size) { 102 void *ptr = malloc(size+PREFIX_SIZE); 103 104 if (!ptr) zmalloc_oom(size); 105 #ifdef HAVE_MALLOC_SIZE 106 update_zmalloc_stat_alloc(zmalloc_size(ptr),size); 107 return ptr; 108 #else 109 *((size_t*)ptr) = size; 110 update_zmalloc_stat_alloc(size+PREFIX_SIZE,size); 111 return (char*)ptr+PREFIX_SIZE; 112 #endif 113 } 114 115 void *zcalloc(size_t size) { 116 void *ptr = calloc(1, size+PREFIX_SIZE); 117 118 if (!ptr) zmalloc_oom(size); 119 #ifdef HAVE_MALLOC_SIZE 120 update_zmalloc_stat_alloc(zmalloc_size(ptr),size); 121 return ptr; 122 #else 123 *((size_t*)ptr) = size; 124 update_zmalloc_stat_alloc(size+PREFIX_SIZE,size); 125 return (char*)ptr+PREFIX_SIZE; 126 #endif 127 } 128 129 void *zrealloc(void *ptr, size_t size) { 130 #ifndef HAVE_MALLOC_SIZE 131 void *realptr; 132 #endif 133 size_t oldsize; 134 void *newptr; 135 136 if (ptr == NULL) return zmalloc(size); 137 #ifdef HAVE_MALLOC_SIZE 138 oldsize = zmalloc_size(ptr); 139 newptr = realloc(ptr,size); 140 if (!newptr) zmalloc_oom(size); 141 142 update_zmalloc_stat_free(oldsize); 143 update_zmalloc_stat_alloc(zmalloc_size(newptr),size); 144 return newptr; 145 #else 146 realptr = (char*)ptr-PREFIX_SIZE; 147 oldsize = *((size_t*)realptr); 148 newptr = realloc(realptr,size+PREFIX_SIZE); 149 if (!newptr) zmalloc_oom(size); 150 151 *((size_t*)newptr) = size; 152 update_zmalloc_stat_free(oldsize); 153 update_zmalloc_stat_alloc(size,size); 154 return (char*)newptr+PREFIX_SIZE; 155 #endif 156 } 157 158 void zfree(void *ptr) { 159 #ifndef HAVE_MALLOC_SIZE 160 void *realptr; 161 size_t oldsize; 162 #endif 163 164 if (ptr == NULL) return; 165 #ifdef HAVE_MALLOC_SIZE 166 update_zmalloc_stat_free(zmalloc_size(ptr)); 167 free(ptr); 168 #else 169 realptr = (char*)ptr-PREFIX_SIZE; 170 oldsize = *((size_t*)realptr); 171 update_zmalloc_stat_free(oldsize+PREFIX_SIZE); 172 free(realptr); 173 #endif 174 } 175 176 char *zstrdup(const char *s) { 177 size_t l = strlen(s)+1; 178 char *p = zmalloc(l); 179 180 memcpy(p,s,l); 181 return p; 182 } 183 184 size_t zmalloc_used_memory(void) { 185 size_t um; 186 187 if (zmalloc_thread_safe) pthread_mutex_lock(&used_memory_mutex); 188 um = used_memory; 189 if (zmalloc_thread_safe) pthread_mutex_unlock(&used_memory_mutex); 190 return um; 191 } 192 193 size_t zmalloc_allocations_for_size(size_t size) { 194 if (size > ZMALLOC_MAX_ALLOC_STAT) return 0; 195 return zmalloc_allocations[size]; 196 } 197 198 void zmalloc_enable_thread_safeness(void) { 199 zmalloc_thread_safe = 1; 200 } 201 202 /* Get the RSS information in an OS-specific way. 203 * 204 * WARNING: the function zmalloc_get_rss() is not designed to be fast 205 * and may not be called in the busy loops where Redis tries to release 206 * memory expiring or swapping out objects. 207 * 208 * For this kind of "fast RSS reporting" usages use instead the 209 * function RedisEstimateRSS() that is a much faster (and less precise) 210 * version of the funciton. */ 211 212 #if defined(HAVE_PROCFS) 213 #include <unistd.h> 214 #include <sys/types.h> 215 #include <sys/stat.h> 216 #include <fcntl.h> 217 218 size_t zmalloc_get_rss(void) { 219 int page = sysconf(_SC_PAGESIZE); 220 size_t rss; 221 char buf[4096]; 222 char filename[256]; 223 int fd, count; 224 char *p, *x; 225 226 snprintf(filename,256,"/proc/%d/stat",getpid()); 227 if ((fd = open(filename,O_RDONLY)) == -1) return 0; 228 if (read(fd,buf,4096) <= 0) { 229 close(fd); 230 return 0; 231 } 232 close(fd); 233 234 p = buf; 235 count = 23; /* RSS is the 24th field in /proc/<pid>/stat */ 236 while(p && count--) { 237 p = strchr(p,' '); 238 if (p) p++; 239 } 240 if (!p) return 0; 241 x = strchr(p,' '); 242 if (!x) return 0; 243 *x = '\0'; 244 245 rss = strtoll(p,NULL,10); 246 rss *= page; 247 return rss; 248 } 249 #elif defined(HAVE_TASKINFO) 250 #include <unistd.h> 251 #include <stdio.h> 252 #include <stdlib.h> 253 #include <sys/types.h> 254 #include <sys/sysctl.h> 255 #include <mach/task.h> 256 #include <mach/mach_init.h> 257 258 size_t zmalloc_get_rss(void) { 259 task_t task = MACH_PORT_NULL; 260 struct task_basic_info t_info; 261 mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT; 262 263 if (task_for_pid(current_task(), getpid(), &task) != KERN_SUCCESS) 264 return 0; 265 task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count); 266 267 return t_info.resident_size; 268 } 269 #else 270 size_t zmalloc_get_rss(void) { 271 /* If we can't get the RSS in an OS-specific way for this system just 272 * return the memory usage we estimated in zmalloc().. 273 * 274 * Fragmentation will appear to be always 1 (no fragmentation) 275 * of course... */ 276 return zmalloc_used_memory(); 277 } 278 #endif 279 280 /* Fragmentation = RSS / allocated-bytes */ 281 float zmalloc_get_fragmentation_ratio(void) { 282 return (float)zmalloc_get_rss()/zmalloc_used_memory(); 283 } 284