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