Rename try_give_memory_back to a better free_unused_memory.

jerry-core/ecma/base/ecma-gc.c

@@ -564,10 +564,9 @@ ecma_gc_run (void)
  * Try to free some memory (depending on severity).
  */
 void
-ecma_try_to_give_back_some_memory (jmem_try_give_memory_back_severity_t severity) /**< severity of
-                                                                                  *    the request */
+ecma_free_unused_memory (jmem_free_unused_memory_severity_t severity) /**< severity of the request */
 {
-  if (severity == JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_LOW)
+  if (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_LOW)
   {
     /*
      * If there is enough newly allocated objects since last GC, probably it is worthwhile to start GC now.
@@ -580,12 +579,12 @@ ecma_try_to_give_back_some_memory (jmem_try_give_memory_back_severity_t severity
   }
   else
   {
-    JERRY_ASSERT (severity == JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_HIGH);
+    JERRY_ASSERT (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
 
     /* Freeing as much memory as we currently can */
     ecma_gc_run ();
   }
-} /* ecma_try_to_give_back_some_memory */
+} /* ecma_free_unused_memory */
 
 /**
  * @}

jerry-core/ecma/base/ecma-gc.h

@@ -31,7 +31,7 @@ extern void ecma_init_gc_info (ecma_object_t *);
 extern void ecma_ref_object (ecma_object_t *);
 extern void ecma_deref_object (ecma_object_t *);
 extern void ecma_gc_run (void);
-extern void ecma_try_to_give_back_some_memory (jmem_try_give_memory_back_severity_t);
+extern void ecma_free_unused_memory (jmem_free_unused_memory_severity_t);
 
 /**
  * @}

jerry-core/ecma/base/ecma-init-finalize.c

@@ -39,7 +39,7 @@ ecma_init (void)
   ecma_lcache_init ();
   ecma_init_environment ();
 
-  jmem_register_a_try_give_memory_back_callback (ecma_try_to_give_back_some_memory);
+  jmem_register_free_unused_memory_callback (ecma_free_unused_memory);
 } /* ecma_init */
 
 /**
@@ -48,7 +48,7 @@ ecma_init (void)
 void
 ecma_finalize (void)
 {
-  jmem_unregister_a_try_give_memory_back_callback (ecma_try_to_give_back_some_memory);
+  jmem_unregister_free_unused_memory_callback (ecma_free_unused_memory);
 
   ecma_finalize_environment ();
   ecma_finalize_builtins ();

jerry-core/jmem/jmem-allocator-internal.h

@@ -24,7 +24,7 @@
  * @{
  */
 
-extern void jmem_run_try_to_give_memory_back_callbacks (jmem_try_give_memory_back_severity_t);
+extern void jmem_run_free_unused_memory_callbacks (jmem_free_unused_memory_severity_t);
 
 /**
  * @}

jerry-core/jmem/jmem-allocator.c

@@ -30,7 +30,7 @@
 /**
  * The 'try to give memory back' callback
  */
-static jmem_try_give_memory_back_callback_t jmem_try_give_memory_back_callback = NULL;
+static jmem_free_unused_memory_callback_t jmem_free_unused_memory_callback = NULL;
 
 /**
  * Initialize memory allocators.
@@ -91,40 +91,39 @@ jmem_decompress_pointer (uintptr_t compressed_pointer) /**< pointer to decompres
  * Register specified 'try to give memory back' callback routine
  */
 void
-jmem_register_a_try_give_memory_back_callback (jmem_try_give_memory_back_callback_t callback) /**< callback routine */
+jmem_register_free_unused_memory_callback (jmem_free_unused_memory_callback_t callback) /**< callback routine */
 {
   /* Currently only one callback is supported */
-  JERRY_ASSERT (jmem_try_give_memory_back_callback == NULL);
+  JERRY_ASSERT (jmem_free_unused_memory_callback == NULL);
 
-  jmem_try_give_memory_back_callback = callback;
-} /* jmem_register_a_try_give_memory_back_callback */
+  jmem_free_unused_memory_callback = callback;
+} /* jmem_register_free_unused_memory_callback */
 
 /**
  * Unregister specified 'try to give memory back' callback routine
  */
 void
-jmem_unregister_a_try_give_memory_back_callback (jmem_try_give_memory_back_callback_t callback) /**< callback routine */
+jmem_unregister_free_unused_memory_callback (jmem_free_unused_memory_callback_t callback) /**< callback routine */
 {
   /* Currently only one callback is supported */
-  JERRY_ASSERT (jmem_try_give_memory_back_callback == callback);
+  JERRY_ASSERT (jmem_free_unused_memory_callback == callback);
 
-  jmem_try_give_memory_back_callback = NULL;
-} /* jmem_unregister_a_try_give_memory_back_callback */
+  jmem_free_unused_memory_callback = NULL;
+} /* jmem_unregister_free_unused_memory_callback */
 
 /**
  * Run 'try to give memory back' callbacks with specified severity
  */
 void
-jmem_run_try_to_give_memory_back_callbacks (jmem_try_give_memory_back_severity_t severity) /**< severity of
-                                                                                               the request */
+jmem_run_free_unused_memory_callbacks (jmem_free_unused_memory_severity_t severity) /**< severity of the request */
 {
-  if (jmem_try_give_memory_back_callback != NULL)
+  if (jmem_free_unused_memory_callback != NULL)
   {
-    jmem_try_give_memory_back_callback (severity);
+    jmem_free_unused_memory_callback (severity);
   }
 
   jmem_pools_collect_empty ();
-} /* jmem_run_try_to_give_memory_back_callbacks */
+} /* jmem_run_free_unused_memory_callbacks */
 
 #ifdef JMEM_STATS
 /**

jerry-core/jmem/jmem-allocator.h

@@ -64,14 +64,14 @@ typedef uint16_t jmem_cpointer_t;
  */
 typedef enum
 {
-  JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_LOW, /* 'low' severity */
-  JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_HIGH, /* 'high' severity */
-} jmem_try_give_memory_back_severity_t;
+  JMEM_FREE_UNUSED_MEMORY_SEVERITY_LOW, /* 'low' severity */
+  JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH, /* 'high' severity */
+} jmem_free_unused_memory_severity_t;
 
 /**
  * A 'try give memory back' callback routine type.
  */
-typedef void (*jmem_try_give_memory_back_callback_t) (jmem_try_give_memory_back_severity_t);
+typedef void (*jmem_free_unused_memory_callback_t) (jmem_free_unused_memory_severity_t);
 
 /**
  * Get value of pointer from specified non-null compressed pointer value
@@ -117,8 +117,8 @@ extern void jmem_finalize (bool);
 extern uintptr_t jmem_compress_pointer (const void *);
 extern void *jmem_decompress_pointer (uintptr_t);
 
-extern void jmem_register_a_try_give_memory_back_callback (jmem_try_give_memory_back_callback_t);
-extern void jmem_unregister_a_try_give_memory_back_callback (jmem_try_give_memory_back_callback_t);
+extern void jmem_register_free_unused_memory_callback (jmem_free_unused_memory_callback_t);
+extern void jmem_unregister_free_unused_memory_callback (jmem_free_unused_memory_callback_t);
 
 #ifdef JMEM_STATS
 extern void jmem_stats_reset_peak (void);

jerry-core/jmem/jmem-heap.c

@@ -380,12 +380,12 @@ jmem_heap_alloc_block (const size_t size)
   VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST;
 
 #ifdef JMEM_GC_BEFORE_EACH_ALLOC
-  jmem_run_try_to_give_memory_back_callbacks (JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_HIGH);
+  jmem_run_free_unused_memory_callbacks (JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
 #endif /* JMEM_GC_BEFORE_EACH_ALLOC */
 
   if (jmem_heap_allocated_size + size >= jmem_heap_limit)
   {
-    jmem_run_try_to_give_memory_back_callbacks (JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_LOW);
+    jmem_run_free_unused_memory_callbacks (JMEM_FREE_UNUSED_MEMORY_SEVERITY_LOW);
   }
 
   void *data_space_p = jmem_heap_alloc_block_internal (size);
@@ -396,11 +396,11 @@ jmem_heap_alloc_block (const size_t size)
     return data_space_p;
   }
 
-  for (jmem_try_give_memory_back_severity_t severity = JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_LOW;
-       severity <= JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_HIGH;
-       severity = (jmem_try_give_memory_back_severity_t) (severity + 1))
+  for (jmem_free_unused_memory_severity_t severity = JMEM_FREE_UNUSED_MEMORY_SEVERITY_LOW;
+       severity <= JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH;
+       severity = (jmem_free_unused_memory_severity_t) (severity + 1))
   {
-    jmem_run_try_to_give_memory_back_callbacks (severity);
+    jmem_run_free_unused_memory_callbacks (severity);
 
     data_space_p = jmem_heap_alloc_block_internal (size);
 

jerry-core/jmem/jmem-poolman.c

@@ -133,7 +133,7 @@ inline void * __attribute__((hot)) __attr_always_inline___
 jmem_pools_alloc (void)
 {
 #ifdef JMEM_GC_BEFORE_EACH_ALLOC
-  jmem_run_try_to_give_memory_back_callbacks (JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_HIGH);
+  jmem_run_free_unused_memory_callbacks (JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
 #endif /* JMEM_GC_BEFORE_EACH_ALLOC */
 
   if (jmem_free_chunk_p != NULL)

tests/unit/test-heap.c

@@ -35,17 +35,17 @@ size_t sizes[test_sub_iters];
 bool is_one_chunked[test_sub_iters];
 
 static void
-test_heap_give_some_memory_back (jmem_try_give_memory_back_severity_t severity)
+test_heap_give_some_memory_back (jmem_free_unused_memory_severity_t severity)
 {
   int p;
 
-  if (severity == JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_LOW)
+  if (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_LOW)
   {
     p = 8;
   }
   else
   {
-    JERRY_ASSERT (severity == JMEM_TRY_GIVE_MEMORY_BACK_SEVERITY_HIGH);
+    JERRY_ASSERT (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
 
     p = 1;
   }
@@ -76,7 +76,7 @@ main (int __attr_unused___ argc,
 
   jmem_heap_init ();
 
-  jmem_register_a_try_give_memory_back_callback (test_heap_give_some_memory_back);
+  jmem_register_free_unused_memory_callback (test_heap_give_some_memory_back);
 
 #ifdef JMEM_STATS
   jmem_heap_stats_print ();