Ticket #1737: gc-timing.diff

src/gc/alloc_resources.c

@@ -321 +321 @@
          * TODO pass required allocation size to the GC system,
          *      so that collection can be skipped if needed
          */
+        size_t new_mem = mem_pools->memory_used -
+                         mem_pools->mem_used_last_collect;
         if (!mem_pools->gc_mark_block_level
-        &&   mem_pools->mem_allocs_since_last_collect) {
+            && new_mem > (mem_pools->mem_used_last_collect >> 1)
+            && new_mem > GC_SIZE_THRESHOLD) {
             Parrot_gc_mark_and_sweep(interp, GC_trace_stack_FLAG);
 
             if (interp->gc_sys->sys_type != INF) {
@@ -360 +363 @@
     return_val             = pool->top_block->top;
     pool->top_block->top  += size;
     pool->top_block->free -= size;
+    mem_pools->memory_used += size;
 
     return return_val;
 }
@@ -512 +516 @@
     /* How much is free. That's the total size minus the amount we used */
     new_block->free = new_block->size - (cur_spot - new_block->start);
     mem_pools->memory_collected +=      (cur_spot - new_block->start);
+    mem_pools->memory_used      +=      (cur_spot - new_block->start);
 
     free_old_mem_blocks(mem_pools, pool, new_block, total_size);
 
@@ -719 +724 @@
         else {
             /* Note that we don't have it any more */
             mem_pools->memory_allocated -= cur_block->size;
+            mem_pools->memory_used -=
+                cur_block->size - cur_block->free - cur_block->freed;
 
             /* We know the pool body and pool header are a single chunk, so
              * this is enough to get rid of 'em both */

src/gc/gc_ms.c

@@ -35 +35 @@
         __attribute__nonnull__(1);
 
 static void gc_ms_add_free_object(SHIM_INTERP,
-    SHIM(Memory_Pools *mem_pools),
+    ARGMOD(Memory_Pools *mem_pools),
     ARGMOD(Fixed_Size_Pool *pool),
     ARGIN(void *to_add))
+        __attribute__nonnull__(2)
         __attribute__nonnull__(3)
         __attribute__nonnull__(4)
+        FUNC_MODIFIES(*mem_pools)
         FUNC_MODIFIES(*pool);
 
 static void gc_ms_alloc_objects(PARROT_INTERP,
@@ -134 +136 @@
 PARROT_CANNOT_RETURN_NULL
 PARROT_WARN_UNUSED_RESULT
 static void * gc_ms_get_free_object(PARROT_INTERP,
-    ARGIN(Memory_Pools *mem_pools),
+    ARGMOD(Memory_Pools *mem_pools),
     ARGMOD(Fixed_Size_Pool *pool))
         __attribute__nonnull__(1)
         __attribute__nonnull__(2)
         __attribute__nonnull__(3)
+        FUNC_MODIFIES(*mem_pools)
         FUNC_MODIFIES(*pool);
 
 static size_t gc_ms_get_gc_info(PARROT_INTERP, Interpinfo_enum which)
@@ -253 +256 @@
 #define ASSERT_ARGS_gc_ms_active_sized_buffers __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
        PARROT_ASSERT_ARG(mem_pools))
 #define ASSERT_ARGS_gc_ms_add_free_object __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
-       PARROT_ASSERT_ARG(pool) \
+       PARROT_ASSERT_ARG(mem_pools) \
+    , PARROT_ASSERT_ARG(pool) \
     , PARROT_ASSERT_ARG(to_add))
 #define ASSERT_ARGS_gc_ms_alloc_objects __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
        PARROT_ASSERT_ARG(interp) \
@@ -560 +564 @@
     ++mem_pools->gc_mark_runs;
     --mem_pools->gc_mark_block_level;
     mem_pools->header_allocs_since_last_collect = 0;
+    mem_pools->mem_used_last_collect = mem_pools->memory_used;
 
     return;
 }
@@ -1127 +1132 @@
     &&  (pool->top_block->top  == (char *)Buffer_bufstart(buffer) + old_size)) {
         pool->top_block->free -= needed;
         pool->top_block->top  += needed;
+        interp->mem_pools->memory_used += needed;
         Buffer_buflen(buffer)  = newsize;
         return;
     }
@@ -1239 +1245 @@
     &&  pool->top_block->top  == (char *)Buffer_bufstart(str) + old_size) {
         pool->top_block->free -= needed;
         pool->top_block->top  += needed;
+        interp->mem_pools->memory_used += needed;
         Buffer_buflen(str) = new_size - sizeof (void *);
         return;
     }
@@ -1260 +1267 @@
 
     /* Decrease usage */
     PARROT_ASSERT(Buffer_pool(str));
-    Buffer_pool(str)->freed  += ALIGNED_STRING_SIZE(Buffer_buflen(str));
+    Buffer_pool(str)->freed += old_size;
+    interp->mem_pools->memory_used -= old_size;
 
     /* copy mem from strstart, *not* bufstart */
     oldmem             = str->strstart;
@@ -1523 +1531 @@
         ARGMOD(Fixed_Size_Pool *pool))
 {
     ASSERT_ARGS(gc_ms_more_traceable_objects)
+    size_t new_mem = mem_pools->memory_used -
+                     mem_pools->mem_used_last_collect;
 
-    if (pool->skip == GC_ONE_SKIP)
-        pool->skip = GC_NO_SKIP;
-    else if (pool->skip == GC_NEVER_SKIP
-         || (pool->skip == GC_NO_SKIP
-         &&  mem_pools->header_allocs_since_last_collect >= GC_SIZE_THRESHOLD))
-            Parrot_gc_mark_and_sweep(interp, GC_trace_stack_FLAG);
+    if (new_mem > (mem_pools->mem_used_last_collect >> 1)
+        && new_mem > GC_SIZE_THRESHOLD) {
+        Parrot_gc_mark_and_sweep(interp, GC_trace_stack_FLAG);
+    }
 
     /* requires that num_free_objects be updated in Parrot_gc_mark_and_sweep.
        If gc is disabled, then we must check the free list directly. */
@@ -1557 +1565 @@
 
 static void
 gc_ms_add_free_object(SHIM_INTERP,
-        SHIM(Memory_Pools *mem_pools),
+        ARGMOD(Memory_Pools *mem_pools),
         ARGMOD(Fixed_Size_Pool *pool),
         ARGIN(void *to_add))
 {
@@ -1568 +1576 @@
 
     object->next_ptr = pool->free_list;
     pool->free_list  = object;
+    mem_pools->memory_used -= pool->object_size;
 }
 
 /*
@@ -1588 +1597 @@
 PARROT_WARN_UNUSED_RESULT
 static void *
 gc_ms_get_free_object(PARROT_INTERP,
-        ARGIN(Memory_Pools *mem_pools),
+        ARGMOD(Memory_Pools *mem_pools),
         ARGMOD(Fixed_Size_Pool *pool))
 {
     ASSERT_ARGS(gc_ms_get_free_object)
@@ -1630 +1639 @@
 #endif
 
     --pool->num_free_objects;
+    mem_pools->memory_used += pool->object_size;
 
     return ptr;
 }
@@ -1682 +1692 @@
 
     if (alloc_size > POOL_MAX_BYTES)
         pool->objects_per_alloc = POOL_MAX_BYTES / pool->object_size;
-
-    if (alloc_size > GC_SIZE_THRESHOLD)
-        pool->skip = GC_NEVER_SKIP;
 }
 
 

src/gc/gc_private.h

@@ -88 +88 @@
     INF  /*infinite memory core*/
 } gc_sys_type_enum;
 
-/* how often to skip a full GC when this pool has nothing free */
-typedef enum _gc_skip_type_enum {
-    GC_NO_SKIP = 0,
-    GC_ONE_SKIP,
-    GC_ALWAYS_SKIP,
-    GC_NEVER_SKIP
-} gc_skip_type_enum;
-
 typedef struct GC_Subsystem {
     /* Which GC subsystem are we using? See PARROT_GC_DEFAULT_TYPE in
      * include/parrot/settings.h for possible values */
@@ -237 +229 @@
 
     size_t objects_per_alloc;
 
-    int skip;
     size_t replenish_level;
 
     add_free_object_fn_type     add_free_object; /* adds a free object to
@@ -294 +285 @@
                                    * memory for headers or
                                    * internal structures or
                                    * anything */
+    size_t  memory_used;              /* The total amount of
+                                       * memory used for
+                                       * buffers and headers */
+    size_t  mem_used_last_collect;    /* The total amount of
+                                       * memory used after
+                                       * the last GC run */
     UINTVAL memory_collected;     /* Total amount of memory copied
                                      during collection */
     UINTVAL num_early_gc_PMCs;    /* how many PMCs want immediate destruction */

src/gc/mark_sweep.c

@@ -32 +32 @@
 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 
 static void free_buffer(SHIM_INTERP,
-    SHIM(Memory_Pools *mem_pools),
+    ARGMOD(Memory_Pools *mem_pools),
     ARGMOD(Fixed_Size_Pool *pool),
     ARGMOD(Buffer *b))
+        __attribute__nonnull__(2)
         __attribute__nonnull__(3)
         __attribute__nonnull__(4)
+        FUNC_MODIFIES(*mem_pools)
         FUNC_MODIFIES(*pool)
         FUNC_MODIFIES(*b);
 
@@ -78 +80 @@
         FUNC_MODIFIES(*mem_pools);
 
 #define ASSERT_ARGS_free_buffer __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
-       PARROT_ASSERT_ARG(pool) \
+       PARROT_ASSERT_ARG(mem_pools) \
+    , PARROT_ASSERT_ARG(pool) \
     , PARROT_ASSERT_ARG(b))
 #define ASSERT_ARGS_free_pmc_in_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
        PARROT_ASSERT_ARG(interp) \
@@ -665 +668 @@
 
 static void
 free_buffer(SHIM_INTERP,
-        SHIM(Memory_Pools *mem_pools),
+        ARGMOD(Memory_Pools *mem_pools),
         ARGMOD(Fixed_Size_Pool *pool),
         ARGMOD(Buffer *b))
 {
@@ -690 +693 @@
 
             /* We can have shared buffers. Don't count them (yet) */
             if (!(*buffer_flags & Buffer_shared_FLAG)) {
-                block->freed  += ALIGNED_STRING_SIZE(Buffer_buflen(b));
+                size_t size = ALIGNED_STRING_SIZE(Buffer_buflen(b));
+                block->freed += size;
+                mem_pools->memory_used -= size;
             }
 
         }
@@ -770 +775 @@
     /* Init the constant string header pool */
     mem_pools->constant_string_header_pool       = new_string_pool(interp, mem_pools, 1);
     mem_pools->constant_string_header_pool->name = "constant_string_header";
-    mem_pools->constant_string_header_pool->skip = GC_ALWAYS_SKIP;
 
     /* Init the buffer header pool
      *
@@ -789 +793 @@
     /* constant PMCs */
     mem_pools->constant_pmc_pool                    = new_pmc_pool(interp);
     mem_pools->constant_pmc_pool->name              = "constant_pmc";
-    mem_pools->constant_pmc_pool->skip              = GC_ALWAYS_SKIP;
     mem_pools->constant_pmc_pool->objects_per_alloc =
         CONSTANT_PMC_HEADERS_PER_ALLOC;
 }