Merge pull request zephyrproject-rtos#34 from grgustaf/create-buffer

Improvements to Buffer support

Author: Jimmy Huang

samples/tests/BufferMemory.js

@@ -0,0 +1,13 @@
+// Copyright (c) 2016, Intel Corporation.
+
+// Stress test for buffer code
+print("Buffer stress test...");
+
+// This was useful for catching memory leaks in the original Buffer code
+for (var i = 1; i <= 1000; i++) {
+    print("Allocating buffer", i);
+
+    var mybuf = new Buffer(8);
+    for (var j = 0; j < 8; j++)
+        mybuf.writeUInt8(j * 4, j);
+}

src/zjs_buffer.c

@@ -14,7 +14,9 @@
 
 static struct zjs_buffer_t *zjs_buffers = NULL;
 
-struct zjs_buffer_t *zjs_find_buffer(const jerry_object_t *obj)
+// TODO: this could probably be replaced more efficiently now that there is a
+//   get_native_handle API
+struct zjs_buffer_t *zjs_buffer_find(const jerry_object_t *obj)
 {
     // requires: obj should be the JS object associated with a buffer, created
     //             in zjs_buffer
@@ -26,13 +28,51 @@ struct zjs_buffer_t *zjs_find_buffer(const jerry_object_t *obj)
     return NULL;
 }
 
+static bool zjs_buffer_read_uint8(const jerry_object_t *function_obj_p,
+                                  const jerry_value_t this_val,
+                                  const jerry_value_t args_p[],
+                                  const jerry_length_t args_cnt,
+                                  jerry_value_t *ret_val_p)
+{
+    // requires: this_val is a JS buffer object created with zjs_buffer_create,
+    //             expects argument of an offset into the buffer, but will
+    //             treat offset as 0 if not given, as node.js seems to
+    //  effects: reads single byte value from  the buffer associated with the
+    //             this_p JS object, if found, at the given offset, if within
+    //             the bounds of the buffer; otherwise returns an error
+    if (args_cnt >= 1 && !jerry_value_is_number(args_p[0])) {
+        PRINT("Unsupported argument to readUInt8\n");
+        return false;
+    }
+
+    uint32_t offset = 0;
+    if (args_cnt > 1)
+        offset = (uint32_t)jerry_get_number_value(args_p[0]);
+
+    jerry_object_t *obj = jerry_get_object_value(this_val);
+    struct zjs_buffer_t *buf = zjs_buffer_find(obj);
+    if (buf) {
+        if (offset >= buf->bufsize) {
+            PRINT("Tried to read beyond end of buffer\n");
+            return false;
+        }
+        uint8_t value = buf->buffer[offset];
+
+        *ret_val_p = jerry_create_number_value(value);
+        return true;
+    }
+
+    PRINT("Read called on a buffer not in list");  // Fatal
+    return false;
+}
+
 static bool zjs_buffer_write_uint8(const jerry_object_t *function_obj_p,
                                    const jerry_value_t this_val,
                                    const jerry_value_t args_p[],
                                    const jerry_length_t args_cnt,
                                    jerry_value_t *ret_val_p)
 {
-    // requires: this_val is a JS buffer object created with zjs_buffer,
+    // requires: this_val is a JS buffer object created with zjs_buffer_create,
     //             expects arguments of the value to write and an offset
     //             into the buffer, but will treat offset as 0 if not given,
     //             as node.js seems to
@@ -52,17 +92,19 @@ static bool zjs_buffer_write_uint8(const jerry_object_t *function_obj_p,
         offset = (uint32_t)jerry_get_number_value(args_p[1]);
 
     jerry_object_t *obj = jerry_get_object_value(this_val);
-    struct zjs_buffer_t *buf = zjs_find_buffer(obj);
+    struct zjs_buffer_t *buf = zjs_buffer_find(obj);
     if (buf) {
         if (offset >= buf->bufsize) {
             PRINT("Tried to write beyond end of buffer\n");
             return false;
         }
-        ((char *)buf->buffer)[offset] = value;
+        buf->buffer[offset] = value;
 
         *ret_val_p = jerry_create_number_value(offset + 1);
         return true;
     }
+
+    PRINT("Write called on a buffer not in list");  // Fatal
     return false;
 }
 
@@ -91,7 +133,7 @@ static bool zjs_buffer_to_string(const jerry_object_t *function_obj_p,
     }
 
     jerry_object_t *obj = jerry_get_object_value(this_val);
-    struct zjs_buffer_t *buf = zjs_find_buffer(obj);
+    struct zjs_buffer_t *buf = zjs_buffer_find(obj);
     if (buf && args_cnt == 0) {
         *ret_val_p = jerry_create_string_value(jerry_create_string(
                                                (jerry_char_t *)"[Buffer Object]"));
@@ -127,25 +169,28 @@ static bool zjs_buffer_to_string(const jerry_object_t *function_obj_p,
     return false;
 }
 
-// Buffer constructor
-static bool zjs_buffer(const jerry_object_t *function_obj_p,
-                       const jerry_value_t this_val,
-                       const jerry_value_t args_p[],
-                       const jerry_length_t args_cnt,
-                       jerry_value_t *ret_val_p)
+static void zjs_buffer_callback_free(uintptr_t handle)
 {
-    // requires: single argument is a numeric size in bytes; soon will also
-    //             support an array argument to initialize the buffer
-    //  effects: constructs a new JS Buffer object, and an associated buffer
-    //             tied to it through a zjs_buffer_t struct stored in a global
-    //             list
-    if (args_cnt != 1 || !jerry_value_is_number(args_p[0])) {
-        PRINT("Unsupported arguments to Buffer constructor\n");
-        return false;
+    // requires: handle is the native pointer we registered with
+    //             jerry_set_object_native_handle
+    //  effects: frees the callback list item for the given pin object
+    struct zjs_buffer_t **pItem = &zjs_buffers;
+    while (*pItem) {
+        if ((uintptr_t)*pItem == handle) {
+            task_free((*pItem)->buffer);
+            *pItem = (*pItem)->next;
+            task_free((void *)handle);
+        }
+        pItem = &(*pItem)->next;
     }
+}
 
-    uint32_t size = (uint32_t)jerry_get_number_value(args_p[0]);
-
+jerry_object_t *zjs_buffer_create(uint32_t size)
+{
+    // requires: size is size of desired buffer, in bytes
+    //  effects: allocates a JS Buffer object, an underlying C buffer, and a
+    //             list item to track it; if any of these fail, free them all
+    //             and return NULL, otherwise return the JS object
     jerry_object_t *buf_obj = jerry_create_object();
     void *buf = task_malloc(size);
     struct zjs_buffer_t *buf_item =
@@ -156,7 +201,7 @@ static bool zjs_buffer(const jerry_object_t *function_obj_p,
         jerry_release_object(buf_obj);
         task_free(buf);
         task_free(buf_item);
-        return false;
+        return NULL;
     }
 
     buf_item->obj = buf_obj;
@@ -165,13 +210,46 @@ static bool zjs_buffer(const jerry_object_t *function_obj_p,
     buf_item->next = zjs_buffers;
     zjs_buffers = buf_item;
 
+    zjs_obj_add_uint32(buf_obj, size, "length");
+    zjs_obj_add_function(buf_obj, zjs_buffer_read_uint8, "readUInt8");
     zjs_obj_add_function(buf_obj, zjs_buffer_write_uint8, "writeUInt8");
     zjs_obj_add_function(buf_obj, zjs_buffer_to_string, "toString");
 
-    zjs_init_value_object(ret_val_p, buf_obj);
-
     // TODO: sign up to get callback when the object is freed, then free the
     //   buffer and remove it from the list
+
+    // watch for the object getting garbage collected, and clean up
+    jerry_set_object_native_handle(buf_obj, (uintptr_t)buf_item,
+                                   zjs_buffer_callback_free);
+
+    return buf_obj;
+}
+
+// Buffer constructor
+static bool zjs_buffer(const jerry_object_t *function_obj_p,
+                       const jerry_value_t this_val,
+                       const jerry_value_t args_p[],
+                       const jerry_length_t args_cnt,
+                       jerry_value_t *ret_val_p)
+{
+    // requires: single argument is a numeric size in bytes; soon will also
+    //             support an array argument to initialize the buffer
+    //  effects: constructs a new JS Buffer object, and an associated buffer
+    //             tied to it through a zjs_buffer_t struct stored in a global
+    //             list
+    if (args_cnt != 1 || !jerry_value_is_number(args_p[0])) {
+        PRINT("Unsupported arguments to Buffer constructor\n");
+        return false;
+    }
+
+    uint32_t size = (uint32_t)jerry_get_number_value(args_p[0]);
+
+    jerry_object_t *buf_obj = zjs_buffer_create(size);
+    if (!buf_obj)
+        return false;
+
+    *ret_val_p = jerry_create_object_value(buf_obj);
+
     return true;
 }
 

src/zjs_buffer.h

@@ -4,9 +4,10 @@ void zjs_buffer_init();
 
 struct zjs_buffer_t {
     jerry_object_t *obj;
-    char *buffer;
+    uint8_t *buffer;
     uint32_t bufsize;
     struct zjs_buffer_t *next;
 };
 
-struct zjs_buffer_t *zjs_find_buffer(const jerry_object_t *obj);
+struct zjs_buffer_t *zjs_buffer_find(const jerry_object_t *obj);
+jerry_object_t *zjs_buffer_create(uint32_t size);