chunk.c

   1 /*
   2 Copyright (c) 2003-2006 by Juliusz Chroboczek
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy
   5 of this software and associated documentation files (the "Software"), to deal
   6 in the Software without restriction, including without limitation the rights
   7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8 copies of the Software, and to permit persons to whom the Software is
   9 furnished to do so, subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20 THE SOFTWARE.
  21 */
  22
  23 #include "polipo.h"
  24
  25 #define MB (1024 * 1024)
  26 int chunkLowMark = 0,
  27     chunkCriticalMark = 0,
  28     chunkHighMark = 0;
  29
  30 void
  31 preinitChunks()
  32 {
  33     CONFIG_VARIABLE(chunkLowMark, CONFIG_INT,
  34                     "Low mark for chunk memory (0 = auto).");
  35     CONFIG_VARIABLE(chunkCriticalMark, CONFIG_INT,
  36                     "Critical mark for chunk memory (0 = auto).");
  37     CONFIG_VARIABLE(chunkHighMark, CONFIG_INT,
  38                     "High mark for chunk memory.");
  39 }
  40
  41 static void
  42 initChunksCommon()
  43 {
  44 #define ROUND_CHUNKS(a) a = (((a) + CHUNK_SIZE - 1) / CHUNK_SIZE) * CHUNK_SIZE;
  45     int q;
  46
  47     if(CHUNK_SIZE != 1 << log2_ceil(CHUNK_SIZE)) {
  48         do_log(L_ERROR, "CHUNK SIZE %d is not a power of two.\n", CHUNK_SIZE);
  49         exit(1);
  50     }
  51
  52     ROUND_CHUNKS(chunkHighMark);
  53     ROUND_CHUNKS(chunkCriticalMark);
  54     ROUND_CHUNKS(chunkLowMark);
  55
  56     if(chunkHighMark < 8 * CHUNK_SIZE) {
  57         int mem = physicalMemory();
  58         if(mem > 0)
  59             chunkHighMark = mem / 4;
  60         else
  61             chunkHighMark = 24 * MB;
  62         chunkHighMark = MIN(chunkHighMark, 24 * MB);
  63         chunkHighMark = MAX(chunkHighMark, 8 * CHUNK_SIZE);
  64     }
  65
  66     if(chunkHighMark < MB / 2)
  67         fprintf(stderr,
  68                 "Warning: little chunk memory (%d bytes)\n", chunkHighMark);
  69
  70     q = 0;
  71     if(chunkLowMark <= 0) q = 1;
  72     if(chunkLowMark < 4 * CHUNK_SIZE ||
  73        chunkLowMark > chunkHighMark - 4 * CHUNK_SIZE) {
  74         chunkLowMark = MIN(chunkHighMark - 4 * CHUNK_SIZE,
  75                            chunkHighMark * 3 / 4);
  76         ROUND_CHUNKS(chunkLowMark);
  77         if(!q) do_log(L_WARN, "Inconsistent chunkLowMark -- setting to %d.\n",
  78                       chunkLowMark);
  79     }
  80
  81     q = 0;
  82     if(chunkCriticalMark <= 0) q = 1;
  83     if(chunkCriticalMark >= chunkHighMark - 2 * CHUNK_SIZE ||
  84        chunkCriticalMark <= chunkLowMark + 2 * CHUNK_SIZE) {
  85         chunkCriticalMark =
  86             MIN(chunkHighMark - 2 * CHUNK_SIZE,
  87                 chunkLowMark + (chunkHighMark - chunkLowMark) * 15 / 16);
  88         ROUND_CHUNKS(chunkCriticalMark);
  89         if(!q) do_log(L_WARN, "Inconsistent chunkCriticalMark -- "
  90                       "setting to %d.\n", chunkCriticalMark);
  91     }
  92 #undef ROUND_CHUNKS
  93 }
  94
  95
  96 int used_chunks = 0;
  97
  98 static void
  99 maybe_free_chunks(int arenas, int force)
 100 {
 101     if(force || used_chunks >= CHUNKS(chunkHighMark)) {
 102         discardObjects(force, force);
 103     }
 104
 105     if(arenas)
 106         free_chunk_arenas();
 107
 108     if(used_chunks >= CHUNKS(chunkLowMark) && !objectExpiryScheduled) {
 109         TimeEventHandlerPtr event;
 110         event = scheduleTimeEvent(1, discardObjectsHandler, 0, NULL);
 111         if(event)
 112             objectExpiryScheduled = 1;
 113     }
 114 }
 115
 116
 117
 118 #ifdef MALLOC_CHUNKS
 119
 120 void
 121 initChunks(void)
 122 {
 123     do_log(L_WARN, "Warning: using malloc(3) for chunk allocation.\n");
 124     used_chunks = 0;
 125     initChunksCommon();
 126 }
 127
 128 void
 129 free_chunk_arenas()
 130 {
 131     return;
 132 }
 133
 134 void *
 135 get_chunk()
 136 {
 137     void *chunk;
 138
 139     if(used_chunks > CHUNKS(chunkHighMark))
 140         maybe_free_chunks(0, 0);
 141     if(used_chunks > CHUNKS(chunkHighMark))
 142         return NULL;
 143     chunk = malloc(CHUNK_SIZE);
 144     if(!chunk) {
 145         maybe_free_chunks(1, 1);
 146         chunk = malloc(CHUNK_SIZE);
 147         if(!chunk)
 148             return NULL;
 149     }
 150     used_chunks++;
 151     return chunk;
 152 }
 153
 154 void *
 155 maybe_get_chunk()
 156 {
 157     void *chunk;
 158     if(used_chunks > CHUNKS(chunkHighMark))
 159         return NULL;
 160     chunk = malloc(CHUNK_SIZE);
 161     if(chunk)
 162         used_chunks++;
 163     return chunk;
 164 }
 165
 166 void
 167 dispose_chunk(void *chunk)
 168 {
 169     assert(chunk != NULL);
 170     free(chunk);
 171     used_chunks--;
 172 }
 173
 174 void
 175 free_chunks()
 176 {
 177     return;
 178 }
 179
 180 int
 181 totalChunkArenaSize()
 182 {
 183     return used_chunks * CHUNK_SIZE;
 184 }
 185 #else
 186
 187 #ifdef MINGW
 188 #define MAP_FAILED NULL
 189 #define getpagesize() (64 * 1024)
 190 static void *
 191 alloc_arena(size_t size)
 192 {
 193     return VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 194 }
 195 static int
 196 free_arena(void *addr, size_t size)
 197 {
 198     int rc;
 199     rc = VirtualFree(addr, size, MEM_RELEASE);
 200     if(!rc)
 201         rc = -1;
 202     return rc;
 203 }
 204 #else
 205 #ifndef MAP_FAILED
 206 #define MAP_FAILED ((void*)((long int)-1))
 207 #endif
 208 static void *
 209 alloc_arena(size_t size)
 210 {
 211     return mmap(NULL, size, PROT_READ | PROT_WRITE,
 212                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 213 }
 214 static int
 215 free_arena(void *addr, size_t size)
 216 {
 217     return munmap(addr, size);
 218 }
 219 #endif
 220
 221 /* Memory is organised into a number of chunks of ARENA_CHUNKS chunks
 222    each.  Every arena is pointed at by a struct _ChunkArena. */
 223 /* If currentArena is not NULL, it points at the last arena used,
 224    which gives very fast dispose/get sequences. */
 225
 226 #define DEFINE_FFS(type, ffs_name) \
 227 int \
 228 ffs_name(type i) \
 229 { \
 230     int n; \
 231     if(i == 0) return 0; \
 232     n = 1; \
 233     while((i & 1) == 0) { \
 234         i >>= 1; \
 235         n++; \
 236     } \
 237     return n; \
 238 }
 239
 240 #ifndef LONG_LONG_ARENA_BITMAPS
 241 #ifndef LONG_ARENA_BITMAPS
 242 #ifndef HAVE_FFS
 243 DEFINE_FFS(int, ffs)
 244 #endif
 245 typedef unsigned int ChunkBitmap;
 246 #define BITMAP_FFS(bitmap) (ffs(bitmap))
 247
 248 #else
 249
 250 #ifndef HAVE_FFSL
 251 DEFINE_FFS(long, ffsl)
 252 #endif
 253 typedef unsigned long ChunkBitmap;
 254 #define BITMAP_FFS(bitmap) (ffsl(bitmap))
 255 #endif
 256
 257 #else
 258
 259 #ifndef HAVE_FFSLL
 260 DEFINE_FFS(long long, ffsll)
 261 #endif
 262 typedef unsigned long long ChunkBitmap;
 263 #define BITMAP_FFS(bitmap) (ffsll(bitmap))
 264 #endif
 265
 266 #define ARENA_CHUNKS ((int)sizeof(ChunkBitmap) * 8)
 267 #define EMPTY_BITMAP (~(ChunkBitmap)0)
 268 #define BITMAP_BIT(i) (((ChunkBitmap)1) << (i))
 269
 270 static int pagesize;
 271 typedef struct _ChunkArena {
 272     ChunkBitmap bitmap;
 273     char *chunks;
 274 } ChunkArenaRec, *ChunkArenaPtr;
 275
 276 static ChunkArenaPtr chunkArenas, currentArena;
 277 static int numArenas;
 278 #define CHUNK_IN_ARENA(chunk, arena) \
 279   ((arena)->chunks && \
 280    (char*)(chunk) >= (arena)->chunks && \
 281    (char*)(chunk) < (arena)->chunks + (ARENA_CHUNKS * CHUNK_SIZE))
 282
 283 #define CHUNK_ARENA_INDEX(chunk, arena) \
 284   (((char*)(chunk) - (arena)->chunks) / CHUNK_SIZE)
 285
 286 void
 287 initChunks(void)
 288 {
 289     int i;
 290     used_chunks = 0;
 291     initChunksCommon();
 292     pagesize = getpagesize();
 293     if((CHUNK_SIZE * ARENA_CHUNKS) % pagesize != 0) {
 294         do_log(L_ERROR,
 295                "The arena size %d (%d x %d) "
 296                "is not a multiple of the page size %d.\n",
 297                 ARENA_CHUNKS * CHUNK_SIZE, ARENA_CHUNKS, CHUNK_SIZE, pagesize);
 298         abort();
 299     }
 300     numArenas =
 301         (CHUNKS(chunkHighMark) + (ARENA_CHUNKS - 1)) / ARENA_CHUNKS;
 302     chunkArenas = malloc(numArenas * sizeof(ChunkArenaRec));
 303     if(chunkArenas == NULL) {
 304         do_log(L_ERROR, "Couldn't allocate chunk arenas.\n");
 305         polipoExit();
 306     }
 307     for(i = 0; i < numArenas; i++) {
 308         chunkArenas[i].bitmap = EMPTY_BITMAP;
 309         chunkArenas[i].chunks = NULL;
 310     }
 311     currentArena = NULL;
 312 }
 313
 314 static ChunkArenaPtr
 315 findArena()
 316 {
 317     ChunkArenaPtr arena = NULL;
 318     int i;
 319
 320     for(i = 0; i < numArenas; i++) {
 321         arena = &(chunkArenas[i]);
 322         if(arena->bitmap != 0)
 323             break;
 324         else
 325             arena = NULL;
 326     }
 327
 328     assert(arena != NULL);
 329
 330     if(!arena->chunks) {
 331         void *p;
 332         p = alloc_arena(CHUNK_SIZE * ARENA_CHUNKS);
 333         if(p == MAP_FAILED) {
 334             do_log_error(L_ERROR, errno, "Couldn't allocate chunk");
 335             maybe_free_chunks(1, 1);
 336             return NULL;
 337         }
 338         arena->chunks = p;
 339     }
 340     return arena;
 341 }
 342
 343 void *
 344 get_chunk()
 345 {
 346     int i;
 347     ChunkArenaPtr arena = NULL;
 348
 349     if(currentArena && currentArena->bitmap != 0) {
 350         arena = currentArena;
 351     } else {
 352         if(used_chunks >= CHUNKS(chunkHighMark))
 353             maybe_free_chunks(0, 0);
 354
 355         if(used_chunks >= CHUNKS(chunkHighMark))
 356             return NULL;
 357
 358         arena = findArena();
 359         if(!arena)
 360             return NULL;
 361         currentArena = arena;
 362     }
 363     i = BITMAP_FFS(arena->bitmap) - 1;
 364     arena->bitmap &= ~BITMAP_BIT(i);
 365     used_chunks++;
 366     return arena->chunks + CHUNK_SIZE * i;
 367 }
 368
 369 void *
 370 maybe_get_chunk()
 371 {
 372     int i;
 373     ChunkArenaPtr arena = NULL;
 374
 375     if(currentArena && currentArena->bitmap != 0) {
 376         arena = currentArena;
 377     } else {
 378         if(used_chunks >= CHUNKS(chunkHighMark))
 379             return NULL;
 380
 381         arena = findArena();
 382         if(!arena)
 383             return NULL;
 384         currentArena = arena;
 385     }
 386     i = ffs(arena->bitmap) - 1;
 387     arena->bitmap &= ~BITMAP_BIT(i);
 388     used_chunks++;
 389     return arena->chunks + CHUNK_SIZE * i;
 390 }
 391
 392 void
 393 dispose_chunk(void *chunk)
 394 {
 395     ChunkArenaPtr arena = NULL;
 396     int i;
 397
 398     assert(chunk != NULL);
 399
 400     if(currentArena && CHUNK_IN_ARENA(chunk, currentArena)) {
 401         arena = currentArena;
 402     } else {
 403         for(i = 0; i < numArenas; i++) {
 404             arena = &(chunkArenas[i]);
 405             if(CHUNK_IN_ARENA(chunk, arena))
 406                 break;
 407         }
 408         assert(arena != NULL);
 409         currentArena = arena;
 410     }
 411
 412     i = CHUNK_ARENA_INDEX(chunk, arena);
 413     arena->bitmap |= BITMAP_BIT(i);
 414     used_chunks--;
 415 }
 416
 417 void
 418 free_chunk_arenas()
 419 {
 420     ChunkArenaPtr arena;
 421     int i, rc;
 422
 423     for(i = 0; i < numArenas; i++) {
 424         arena = &(chunkArenas[i]);
 425         if(arena->bitmap == EMPTY_BITMAP && arena->chunks) {
 426             rc = free_arena(arena->chunks, CHUNK_SIZE * ARENA_CHUNKS);
 427             if(rc < 0) {
 428                 do_log_error(L_ERROR, errno, "Couldn't unmap memory");
 429                 continue;
 430             }
 431             arena->chunks = NULL;
 432         }
 433     }
 434     if(currentArena && currentArena->chunks == NULL)
 435         currentArena = NULL;
 436 }
 437
 438 int
 439 totalChunkArenaSize()
 440 {
 441     ChunkArenaPtr arena;
 442     int i, size = 0;
 443
 444     for(i = 0; i < numArenas; i++) {
 445         arena = &(chunkArenas[i]);
 446         if(arena->chunks)
 447             size += (CHUNK_SIZE * ARENA_CHUNKS);
 448     }
 449     return size;
 450 }
 451 #endif