More gc-friendly property hashmap allocation.

- New allocator is added that returns null on out of memory, property hasmap create uses this allocator for now.
- Property hashmaps of objects are removed durring a high severity gc.

Follow up patch is in progress.

JerryScript-DCO-1.0-Signed-off-by: István Kádár ikadar@inf.u-szeged.hu

Author: ktorpi

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

@@ -506,7 +506,7 @@ ecma_gc_sweep (ecma_object_t *object_p) /**< object to free */
  * Run garbage collection
  */
 void
-ecma_gc_run (void)
+ecma_gc_run (jmem_free_unused_memory_severity_t severity)
 {
   ecma_gc_new_objects_since_last_gc = 0;
 
@@ -577,6 +577,27 @@ ecma_gc_run (void)
     ecma_gc_sweep (obj_iter_p);
   }
 
+  if (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH)
+  {
+    /* Remove the property hasmap of BLACK objects */
+    for (ecma_object_t *obj_iter_p = ecma_gc_objects_lists[ECMA_GC_COLOR_BLACK], *obj_next_p;
+         obj_iter_p != NULL;
+         obj_iter_p = obj_next_p)
+    {
+      obj_next_p = ecma_gc_get_object_next (obj_iter_p);
+
+      JERRY_ASSERT (ecma_gc_is_object_visited (obj_iter_p));
+
+      ecma_property_header_t *prop_iter_p = ecma_get_property_list (obj_iter_p);
+      if (prop_iter_p != NULL
+          && ECMA_PROPERTY_GET_TYPE (prop_iter_p->types + 0) == ECMA_PROPERTY_TYPE_HASHMAP)
+      {
+        ecma_property_hashmap_free (obj_iter_p);
+      }
+
+    }
+  }
+
   /* Unmarking all objects */
   ecma_gc_objects_lists[ECMA_GC_COLOR_WHITE_GRAY] = ecma_gc_objects_lists[ECMA_GC_COLOR_BLACK];
   ecma_gc_objects_lists[ECMA_GC_COLOR_BLACK] = NULL;
@@ -603,15 +624,15 @@ ecma_free_unused_memory (jmem_free_unused_memory_severity_t severity) /**< sever
      */
     if (ecma_gc_new_objects_since_last_gc * CONFIG_ECMA_GC_NEW_OBJECTS_SHARE_TO_START_GC > ecma_gc_objects_number)
     {
-      ecma_gc_run ();
+      ecma_gc_run (severity);
     }
   }
   else
   {
     JERRY_ASSERT (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
 
     /* Freeing as much memory as we currently can */
-    ecma_gc_run ();
+    ecma_gc_run (severity);
   }
 } /* ecma_free_unused_memory */
 

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

@@ -30,7 +30,7 @@ extern void ecma_gc_init (void);
 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_gc_run (jmem_free_unused_memory_severity_t);
 extern void ecma_free_unused_memory (jmem_free_unused_memory_severity_t);
 
 /**

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

@@ -54,7 +54,7 @@ ecma_finalize (void)
 
   ecma_finalize_environment ();
   ecma_finalize_builtins ();
-  ecma_gc_run ();
+  ecma_gc_run (JMEM_FREE_UNUSED_MEMORY_SEVERITY_LOW);
   ecma_finalize_lit_storage ();
 } /* ecma_finalize */
 

jerry-core/ecma/base/ecma-property-hashmap.c

@@ -110,7 +110,12 @@ ecma_property_hashmap_create (ecma_object_t *object_p) /**< object */
 
   size_t total_size = ECMA_PROPERTY_HASHMAP_GET_TOTAL_SIZE (max_property_count);
 
-  ecma_property_hashmap_t *hashmap_p = (ecma_property_hashmap_t *) jmem_heap_alloc_block (total_size);
+  ecma_property_hashmap_t *hashmap_p = (ecma_property_hashmap_t *) jmem_heap_alloc_block_null_on_error (total_size);
+  if (hashmap_p == NULL)
+  {
+    return;
+  }
+
   memset (hashmap_p, 0, total_size);
 
   hashmap_p->header.types[0].type_and_flags = ECMA_PROPERTY_TYPE_HASHMAP;

jerry-core/jerry.c

@@ -229,7 +229,7 @@ jerry_gc (void)
 {
   jerry_assert_api_available ();
 
-  ecma_gc_run ();
+  ecma_gc_run (JMEM_FREE_UNUSED_MEMORY_SEVERITY_LOW);
 } /* jerry_gc */
 
 /**
@@ -1506,7 +1506,6 @@ jerry_construct_object (const jerry_value_t func_obj_val, /**< function object t
                         jerry_size_t args_count) /**< number of the arguments */
 {
   jerry_assert_api_available ();
-
   if (jerry_value_is_constructor (func_obj_val))
   {
     ecma_value_t this_val = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);

jerry-core/jmem/jmem-heap.c

@@ -364,18 +364,13 @@ void *jmem_heap_alloc_block_internal (const size_t size)
  * Allocation of memory block, running 'try to give memory back' callbacks, if there is not enough memory.
  *
  * Note:
- *      if after running the callbacks, there is still not enough memory, engine is terminated with ERR_OUT_OF_MEMORY.
+ *      if after running the callbacks, there is still not enough memory, NULL value will be returned
  *
- * @return pointer to allocated memory block
+ * @return pointer to allocated memory block or NULL in case of unsuccessful allocation
  */
-void * __attribute__((hot))
-jmem_heap_alloc_block (const size_t size)
+static void *
+jmem_heap_gc_and_alloc_block (const size_t size) /**< required memory size */
 {
-  if (unlikely (size == 0))
-  {
-    return NULL;
-  }
-
   VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST;
 
 #ifdef JMEM_GC_BEFORE_EACH_ALLOC
@@ -411,10 +406,59 @@ jmem_heap_alloc_block (const size_t size)
   }
 
   JERRY_ASSERT (data_space_p == NULL);
+  return data_space_p;
+} /* jmem_heap_gc_and_alloc_block */
+
+
+/**
+ * Allocation of memory block, running 'try to give memory back' callbacks, if there is not enough memory.
+ *
+ * Note:
+ *      if after running the callbacks, there is still not enough memory, engine is terminated with ERR_OUT_OF_MEMORY.
+ *
+ * @return NULL, if the required memory is 0
+ *         pointer to allocated memory block, otherwise
+ */
+void * __attribute__((hot))
+jmem_heap_alloc_block (const size_t size)  /**< required memory size */
+{
+  if (unlikely (size == 0))
+  {
+    return NULL;
+  }
+
+  void *data_space_p = jmem_heap_gc_and_alloc_block (size);
+
+  if (likely (data_space_p != NULL))
+  {
+    return data_space_p;
+  }
 
   jerry_fatal (ERR_OUT_OF_MEMORY);
 } /* jmem_heap_alloc_block */
 
+/**
+ * Allocation of memory block, running 'try to give memory back' callbacks, if there is not enough memory.
+ *
+ * Note:
+ *      if after running the callbacks, there is still not enough memory, NULL will be returned
+ *
+ * @return NULL, if the required memory size is 0
+ *         also NULL, if the allocation has failed
+ *         pointer to allocated memory block, otherwise
+ */
+void * __attribute__((hot))
+jmem_heap_alloc_block_null_on_error (const size_t size) /**< required memory size */
+{
+  if (unlikely (size == 0))
+  {
+    return NULL;
+  }
+
+  return jmem_heap_gc_and_alloc_block (size);
+} /* jmem_heap_alloc_block_null_on_error */
+
+
 /**
  *  Allocate block and store block size.
  *

jerry-core/jmem/jmem-heap.h

@@ -32,6 +32,7 @@
 extern void jmem_heap_init (void);
 extern void jmem_heap_finalize (void);
 extern void *jmem_heap_alloc_block (const size_t);
+extern void *jmem_heap_alloc_block_null_on_error (const size_t);
 extern void jmem_heap_free_block (void *, const size_t);
 extern void *jmem_heap_alloc_block_store_size (size_t);
 extern void jmem_heap_free_block_size_stored (void *);