nginx: src/core/ngx_slab.c comparison

comparison src/core/ngx_slab.c @ 6828:99770a5ea14f

Slab: slots statistics. For each slot, the number of total and used entries, as well as the number of allocation requests and failures, are tracked.

author	Ruslan Ermilov <ru@nginx.com>
date	Wed, 07 Dec 2016 22:25:37 +0300
parents	0e61510c56c4
children	6e757036e588

comparison

equal deleted inserted replaced

-:0e61510c56c4
+:99770a5ea14f
 slots[i].next = &slots[i];
 slots[i].prev = 0;
 }
 p += n * sizeof(ngx_slab_page_t);
-size -= n * sizeof(ngx_slab_page_t);
+pool->stats = (ngx_slab_stat_t *) p;
+ngx_memzero(pool->stats, n * sizeof(ngx_slab_stat_t));
+p += n * sizeof(ngx_slab_stat_t);
+size -= n * (sizeof(ngx_slab_page_t) + sizeof(ngx_slab_stat_t));
 pages = (ngx_uint_t) (size / (ngx_pagesize + sizeof(ngx_slab_page_t)));
 pool->pages = (ngx_slab_page_t *) p;
 ngx_memzero(pool->pages, pages * sizeof(ngx_slab_page_t));
 } else {
 shift = pool->min_shift;
 slot = 0;
 }
+pool->stats[slot].reqs++;
 ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
 "slab alloc: %uz slot: %ui", size, slot);
 slots = ngx_slab_slots(pool);
 page = slots[slot].next;
 bitmap[n] |= m;
 i = (n * sizeof(uintptr_t) * 8 + i) << shift;
+p = (uintptr_t) bitmap + i;
+pool->stats[slot].used++;
 if (bitmap[n] == NGX_SLAB_BUSY) {
 for (n = n + 1; n < map; n++) {
 if (bitmap[n] != NGX_SLAB_BUSY) {
-p = (uintptr_t) bitmap + i;
 goto done;
 }
 }
 prev = ngx_slab_page_prev(page);
 page->next->prev = page->prev;
 page->next = NULL;
 page->prev = NGX_SLAB_SMALL;
 }
-p = (uintptr_t) bitmap + i;
 goto done;
 }
 }
 }
 page->next = NULL;
 page->prev = NGX_SLAB_EXACT;
 }
 p = ngx_slab_page_addr(pool, page) + (i << shift);
+pool->stats[slot].used++;
 goto done;
 }
 } else { /* shift > ngx_slab_exact_shift */
 page->prev = NGX_SLAB_BIG;
 }
 p = ngx_slab_page_addr(pool, page) + (i << shift);
+pool->stats[slot].used++;
 goto done;
 }
 }
 ngx_slab_error(pool, NGX_LOG_ALERT, "ngx_slab_alloc(): page is busy");
 page->next = &slots[slot];
 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_SMALL;
 slots[slot].next = page;
+pool->stats[slot].total += (ngx_pagesize >> shift) - n;
 p = ngx_slab_page_addr(pool, page) + (n << shift);
+pool->stats[slot].used++;
 goto done;
 } else if (shift == ngx_slab_exact_shift) {
 page->next = &slots[slot];
 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_EXACT;
 slots[slot].next = page;
+pool->stats[slot].total += sizeof(uintptr_t) * 8;
 p = ngx_slab_page_addr(pool, page);
+pool->stats[slot].used++;
 goto done;
 } else { /* shift > ngx_slab_exact_shift */
 page->next = &slots[slot];
 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_BIG;
 slots[slot].next = page;
+pool->stats[slot].total += ngx_pagesize >> shift;
 p = ngx_slab_page_addr(pool, page);
+pool->stats[slot].used++;
 goto done;
 }
 }
 p = 0;
+pool->stats[slot].fails++;
 done:
 ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
 "slab alloc: %p", (void *) p);
 void
 ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p)
 {
 size_t            size;
 uintptr_t         slab, m, *bitmap;
-ngx_uint_t        n, type, slot, shift, map;
+ngx_uint_t        i, n, type, slot, shift, map;
 ngx_slab_page_t  *slots, *page;
 ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0, "slab free: %p", p);
 if ((u_char *) p < pool->start || (u_char *) p > pool->end) {
 n /= sizeof(uintptr_t) * 8;
 bitmap = (uintptr_t *)
 ((uintptr_t) p & ~((uintptr_t) ngx_pagesize - 1));
 if (bitmap[n] & m) {
+slot = shift - pool->min_shift;
 if (page->next == NULL) {
 slots = ngx_slab_slots(pool);
-slot = shift - pool->min_shift;
 page->next = slots[slot].next;
 slots[slot].next = page;
 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_SMALL;
 goto done;
 }
 map = (ngx_pagesize >> shift) / (sizeof(uintptr_t) * 8);
-for (n = 1; n < map; n++) {
+for (i = 1; i < map; i++) {
-if (bitmap[n]) {
+if (bitmap[i]) {
 goto done;
 }
 }
 ngx_slab_free_pages(pool, page, 1);
+pool->stats[slot].total -= (ngx_pagesize >> shift) - n;
 goto done;
 }
 goto chunk_already_free;
 if ((uintptr_t) p & (size - 1)) {
 goto wrong_chunk;
 }
 if (slab & m) {
+slot = ngx_slab_exact_shift - pool->min_shift;
 if (slab == NGX_SLAB_BUSY) {
 slots = ngx_slab_slots(pool);
-slot = ngx_slab_exact_shift - pool->min_shift;
 page->next = slots[slot].next;
 slots[slot].next = page;
 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_EXACT;
 goto done;
 }
 ngx_slab_free_pages(pool, page, 1);
+pool->stats[slot].total -= sizeof(uintptr_t) * 8;
 goto done;
 }
 goto chunk_already_free;
 m = (uintptr_t) 1 << ((((uintptr_t) p & (ngx_pagesize - 1)) >> shift)
 + NGX_SLAB_MAP_SHIFT);
 if (slab & m) {
+slot = shift - pool->min_shift;
 if (page->next == NULL) {
 slots = ngx_slab_slots(pool);
-slot = shift - pool->min_shift;
 page->next = slots[slot].next;
 slots[slot].next = page;
 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_BIG;
 if (page->slab & NGX_SLAB_MAP_MASK) {
 goto done;
 }
 ngx_slab_free_pages(pool, page, 1);
+pool->stats[slot].total -= ngx_pagesize >> shift;
 goto done;
 }
 goto chunk_already_free;
 /* not reached */
 return;
 done:
+pool->stats[slot].used--;
 ngx_slab_junk(p, size);
 return;

Mercurial > hg > nginx

comparison src/core/ngx_slab.c @ 6828:99770a5ea14f