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