Reorganize the system-heap measurement. (#232)

Introduced a new jstest_memstat.c file that contains all the memory
monitoring functions (from the patch files). Added custom allocator
functions (jstest_malloc, jstest_realloc, ...) that can allocate
memory and monitor its usage.

In this case the content of the system-heap patches can be reduced,
because it's simply enough to use the jstest allocator functions
instead of the system allocator ones.

JSRemoteTest-DCO-1.0-Signed-off-by: Roland Takacs rtakacs.uszeged@partner.samsung.com

Author: rtakacs

jstest/builder/modules/iotjs.build.config

@@ -52,6 +52,12 @@
             "--cmake-param=-DENABLE_MODULE_MYMODULE1=ON",
             "--cmake-param=-DENABLE_MODULE_MYMODULE2=ON"
           ]
+        },
+        {
+          "condition": "%{test-build} and %{memstat}",
+          "args": [
+            "--compile-flag=-DJSTEST_MEMSTAT_ENABLED"
+          ]
         }
       ]
     },
@@ -114,6 +120,14 @@
             ]
           }
         },
+        {
+          "condition": "%{test-build} and %{memstat}",
+          "env": {
+            "IOTJS_BUILD_OPTION": [
+              "--compile-flag=-DJSTEST_MEMSTAT_ENABLED"
+            ]
+          }
+        },
         {
           "condition": "%{memstat}",
           "env": { "IOTJS_BUILD_OPTION": ["--jerry-memstat"] }

jstest/resources/memstat/jstest_memstat.c

@@ -0,0 +1,125 @@
+/* Copyright 2018-present Samsung Electronics Co., Ltd. and other contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Memory statistic for system allocator.
+ *
+ * When allocating a chunk of memory, the real size (required memory with padding) is
+ * located in a descriptor (mm_freenode_s) before the allocated memory area:
+ *
+ *    struct mm_freenode_s
+ *    {
+ *        mmsize_t size;        // Size of the chunk
+ *        mmsize_t preceding;   // Size of the preceding chunk
+ *        ...
+ *    };
+ *
+ * +---------------+--------------------------------------+
+ * | mm_freenode_s |        allocated memory chunk        |
+ * +---------------+--------------------------------------+
+ *                 ^
+ *                 pointer to the data
+ *
+ * Note: on NuttX and TizenRT, the `size` variable contains the size of the
+ * mm_freenode_s as well, but that is not calculated into the statistic.
+ */
+#if defined(JSTEST_MEMSTAT_ENABLED)
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(__NUTTX__)
+#include <nuttx/mm/mm.h>
+#elif defined(__TIZENRT__)
+#include <tinyara/mm/mm.h>
+#else
+#error "The current target is not supported to track the memory consumption."
+#endif
+
+static size_t allocated_bytes = 0;
+static size_t peak_allocated_bytes = 0;
+
+
+static size_t read_memsize(char* ptr) {
+  struct mm_freenode_s* node;
+
+  if (ptr == NULL) {
+    return 0;
+  }
+
+  node = (struct mm_freenode_s*)(ptr - SIZEOF_MM_ALLOCNODE);
+  // Note: the allocnode descriptor size is not calculated
+  // into the allocated memory.
+  return node->size - SIZEOF_MM_ALLOCNODE;
+}
+
+
+static void mem_stat_alloc(void* ptr)
+{
+  allocated_bytes += read_memsize(ptr);
+
+  if (allocated_bytes > peak_allocated_bytes) {
+    peak_allocated_bytes = allocated_bytes;
+  }
+}
+
+
+static void mem_stat_free(void* ptr)
+{
+  allocated_bytes -= read_memsize(ptr);
+}
+
+
+void* jstest_malloc(size_t size) {
+  void* mem = malloc(size);
+
+  mem_stat_alloc(mem);
+
+  return mem;
+}
+
+
+void* jstest_calloc(size_t n, size_t elem_size) {
+  void* mem = calloc(n, elem_size);
+
+  mem_stat_alloc(mem);
+
+  return mem;
+}
+
+
+void* jstest_realloc(void* oldmem, size_t size) {
+  mem_stat_free(oldmem);
+
+  void* newmem = realloc(oldmem, size);
+
+  mem_stat_alloc(newmem);
+
+  return newmem;
+}
+
+
+void jstest_free(void *mem) {
+  mem_stat_free(mem);
+
+  free(mem);
+}
+
+
+void print_mem_stat() {
+  printf("Heap stats:\n");
+  printf("  Malloc peak allocated: %u bytes\n", peak_allocated_bytes);
+}
+
+#endif /* JSTEST_MEMSTAT_ENABLED */

jstest/resources/patches/iotjs-system-heap.diff

@@ -1,8 +1,17 @@
 diff --git a/src/iotjs.c b/src/iotjs.c
-index 5a93eb7..4a5a8bd 100644
+index 2df7e0f..bd7b62f 100644
 --- a/src/iotjs.c
 +++ b/src/iotjs.c
-@@ -242,6 +242,9 @@ terminate:
+@@ -234,6 +234,8 @@ void iotjs_conf_console_out(int (*out)(int lv, const char* fmt, ...)) {
+   iotjs_set_console_out(out);
+ }
+ 
++void print_mem_stat();
++
+ int iotjs_entry(int argc, char** argv) {
+   int ret_code = 0;
+ 
+@@ -265,6 +267,9 @@ terminate:
    iotjs_terminate(env);
 
  exit:
@@ -13,130 +22,45 @@ index 5a93eb7..4a5a8bd 100644
        iotjs_environment_config(env)->debugger->context_reset) {
      iotjs_environment_release();
 diff --git a/src/iotjs_util.c b/src/iotjs_util.c
-index abd7a86..cc6b4e3 100644
+index abd7a86..5668015 100644
 --- a/src/iotjs_util.c
 +++ b/src/iotjs_util.c
-@@ -75,12 +75,76 @@ iotjs_string_t iotjs_file_read(const char* path) {
- }
+@@ -27,6 +27,11 @@
+ 
+ void force_terminate();
+ 
++void jstest_free(void*);
++void* jstest_malloc(size_t);
++void* jstest_calloc(size_t, size_t);
++void* jstest_realloc(void*, size_t);
++
+ iotjs_string_t iotjs_file_read(const char* path) {
+   FILE* file = fopen(path, "rb");
+   if (file == NULL) {
+@@ -76,7 +81,7 @@ iotjs_string_t iotjs_file_read(const char* path) {
 
 
-+/*
-+ * Memory statistic for system allocator.
-+ *
-+ *
-+ * When allocating a chunk of memory, the real size (with padding) is
-+ * located in a descriptor (mm_allocnode_s) before the allocated memory area:
-+ *
-+ *    struct mm_freenode_s
-+ *    {
-+ *        mmsize_t size;        // Size of the chunk
-+ *        ...
-+ *    };
-+ *
-+ * The SIZEOF_MM_ALLOCNODE defines the size of the mm_allocnode_s structure,
-+ * that helps to find the size variable.
-+ *
-+ * Note: on NuttX and TizenRT, the size variable contains the size of the
-+ * mm_freenode_s as well, but that is not calculated into the statistic.
-+ *
-+ * The SIZEOF_MM_ALLOCNODE is defined in:
-+ *
-+ *    NuttX:   include/nuttx/mm/mm.h
-+ *    TizenRT: os/include/tinyara/mm/mm.h
-+ */
-+
-+#if defined(__NUTTX__) || defined(__TIZENRT__)
-+#if !defined(NDEBUG) && defined(__TIZENRT__)
-+#define SIZEOF_MM_ALLOCNODE 16
-+#else
-+#define SIZEOF_MM_ALLOCNODE 8
-+#endif
-+#else
-+#error "Undefined memory allocation chunk size."
-+#endif
-+
-+size_t allocated_bytes = 0;
-+size_t peak_allocated_bytes = 0;
-+
-+void mem_stat_alloc(size_t size)
-+{
-+  allocated_bytes += size;
-+
-+  if (allocated_bytes > peak_allocated_bytes) {
-+    peak_allocated_bytes = allocated_bytes;
-+  }
-+}
-+
-+void mem_stat_free(size_t size)
-+{
-+  allocated_bytes -= size;
-+}
-+
-+void print_mem_stat()
-+{
-+  printf("Heap stats:\n");
-+  printf("  Malloc peak allocated: %u bytes\n", peak_allocated_bytes);
-+}
-+
  char* iotjs_buffer_allocate(size_t size) {
-   char* buffer = (char*)(calloc(size, sizeof(char)));
+-  char* buffer = (char*)(calloc(size, sizeof(char)));
++  char* buffer = (char*)(jstest_calloc(size, sizeof(char)));
    if (buffer == NULL) {
      DLOG("Out of memory");
      force_terminate();
-   }
-+
-+  // memstat
-+  size_t new_size;
-+  memcpy(&new_size, (buffer - SIZEOF_MM_ALLOCNODE), sizeof(size_t));
-+  mem_stat_alloc(new_size - SIZEOF_MM_ALLOCNODE);
-+
-   return buffer;
- }
- 
-@@ -99,17 +163,31 @@ char* iotjs_buffer_allocate_from_number_array(size_t size,
+@@ -99,7 +104,7 @@ char* iotjs_buffer_allocate_from_number_array(size_t size,
 
  char* iotjs_buffer_reallocate(char* buffer, size_t size) {
    IOTJS_ASSERT(buffer != NULL);
-+
-+  size_t old_size;
-+  memcpy(&old_size, (buffer - SIZEOF_MM_ALLOCNODE), sizeof(size_t));
-+  mem_stat_free(old_size - SIZEOF_MM_ALLOCNODE);
-+
-   char* newbuffer = (char*)(realloc(buffer, size));
+-  char* newbuffer = (char*)(realloc(buffer, size));
++  char* newbuffer = (char*)(jstest_realloc(buffer, size));
    if (newbuffer == NULL) {
      DLOG("Out of memmory");
      force_terminate();
-   }
-+
-+  size_t new_size;
-+  memcpy(&new_size, (newbuffer - SIZEOF_MM_ALLOCNODE), sizeof(size_t));
-+  mem_stat_alloc(new_size - SIZEOF_MM_ALLOCNODE);
-+
-   return newbuffer;
- }
- 
+@@ -110,7 +115,7 @@ char* iotjs_buffer_reallocate(char* buffer, size_t size) {
 
  void iotjs_buffer_release(char* buffer) {
    if (buffer) {
-+    size_t size;
-+    memcpy(&size, (buffer - SIZEOF_MM_ALLOCNODE), sizeof(size_t));
-+    mem_stat_free(size - SIZEOF_MM_ALLOCNODE);
-+
-     free(buffer);
+-    free(buffer);
++    jstest_free(buffer);
    }
  }
-diff --git a/src/iotjs_util.h b/src/iotjs_util.h
-index a891604..786830e 100644
---- a/src/iotjs_util.h
-+++ b/src/iotjs_util.h
-@@ -23,6 +23,10 @@
- // Return value should be released with iotjs_string_destroy()
- iotjs_string_t iotjs_file_read(const char* path);
 
-+void mem_stat_alloc(size_t size);
-+void mem_stat_free(size_t size);
-+void print_mem_stat();
-+
- char* iotjs_buffer_allocate(size_t size);
- char* iotjs_buffer_allocate_from_number_array(size_t size,
-                                               const jerry_value_t array);