diff --git a/src/gc/alloc_resources.c b/src/gc/alloc_resources.c
index cd96ffb..2740f34 100644
a
|
b
|
|
454 | 454 | if (mem_pools->gc_sweep_block_level) |
455 | 455 | return; |
456 | 456 | |
| 457 | ++mem_pools->gc_collect_runs; |
| 458 | |
| 459 | /* Snag a block big enough for everything */ |
| 460 | total_size = pad_pool_size(pool); |
| 461 | |
| 462 | if (total_size == 0) |
| 463 | return; |
| 464 | |
457 | 465 | ++mem_pools->gc_sweep_block_level; |
458 | 466 | |
459 | 467 | /* We're collecting */ |
460 | 468 | mem_pools->mem_allocs_since_last_collect = 0; |
461 | 469 | mem_pools->header_allocs_since_last_collect = 0; |
462 | | ++mem_pools->gc_collect_runs; |
463 | | |
464 | | /* Snag a block big enough for everything */ |
465 | | total_size = pad_pool_size(pool); |
466 | 470 | |
467 | 471 | alloc_new_block(mem_pools, total_size, pool, "inside compact"); |
468 | 472 | |
… |
… |
|
526 | 530 | size minus the reclaimable size. Add a minimum block to the current amount, so |
527 | 531 | we can avoid having to allocate it in the future. |
528 | 532 | |
| 533 | Returns 0 if all blocks below the top block are almost full. In this case |
| 534 | compacting is not needed. |
| 535 | |
529 | 536 | TODO - Big blocks |
530 | 537 | |
531 | 538 | Currently all available blocks are compacted into one new |
… |
… |
|
550 | 557 | pad_pool_size(ARGIN(const Variable_Size_Pool *pool)) |
551 | 558 | { |
552 | 559 | ASSERT_ARGS(pad_pool_size) |
553 | | Memory_Block *cur_block = pool->top_block; |
| 560 | Memory_Block *cur_block = pool->top_block->prev; |
554 | 561 | |
555 | 562 | UINTVAL total_size = 0; |
556 | 563 | #if RESOURCE_DEBUG |
557 | | size_t total_blocks = 0; |
| 564 | size_t total_blocks = 1; |
558 | 565 | #endif |
559 | 566 | |
560 | 567 | while (cur_block) { |
561 | | total_size += cur_block->size - cur_block->freed - cur_block->free; |
| 568 | if (!is_block_almost_full(cur_block)) |
| 569 | total_size += cur_block->size - cur_block->freed - cur_block->free; |
562 | 570 | cur_block = cur_block->prev; |
563 | 571 | #if RESOURCE_DEBUG |
564 | 572 | ++total_blocks; |
565 | 573 | #endif |
566 | 574 | } |
567 | 575 | |
| 576 | if (total_size == 0) |
| 577 | return 0; |
| 578 | |
| 579 | cur_block = pool->top_block; |
| 580 | if (!is_block_almost_full(cur_block)) |
| 581 | total_size += cur_block->size - cur_block->freed - cur_block->free; |
| 582 | |
568 | 583 | /* this makes for ever increasing allocations but fewer collect runs */ |
569 | 584 | #if WE_WANT_EVER_GROWING_ALLOCATIONS |
570 | 585 | total_size += pool->minimum_block_size; |
… |
… |
|
759 | 774 | is_block_almost_full(ARGIN(const Memory_Block *block)) |
760 | 775 | { |
761 | 776 | ASSERT_ARGS(is_block_almost_full) |
762 | | return (block->free + block->freed) < block->size * 0.2; |
| 777 | return 5 * (block->free + block->freed) < block->size; |
763 | 778 | } |
764 | 779 | |
765 | 780 | /* |