From 054717fd29ff6223eb13ffdda8ef66015444406b Mon Sep 17 00:00:00 2001 From: Akos Kiss Date: Tue, 4 Sep 2018 16:31:26 +0200 Subject: [PATCH] Promote dynamic memory management from debugger transport to core API (#2503) Under the cover of the debugger transport layer, allocation on the engine's heap has been made available to the public. As there are actually no restrictions on what the allocated memory can be used for, the memory management functions better fit in the core part of the API. Closes #1805 JerryScript-DCO-1.0-Signed-off-by: Akos Kiss akiss@inf.u-szeged.hu --- docs/02.API-REFERENCE.md | 46 +++++++++++++++++++ docs/13.DEBUGGER-TRANSPORT.md | 33 +------------ jerry-core/api/jerry-debugger-transport.c | 22 --------- jerry-core/api/jerry.c | 31 +++++++++++++ jerry-core/include/jerryscript-core.h | 6 +++ .../include/jerryscript-debugger-transport.h | 2 - jerry-ext/debugger/debugger-tcp.c | 4 +- jerry-ext/debugger/debugger-ws.c | 8 ++-- 8 files changed, 90 insertions(+), 62 deletions(-) diff --git a/docs/02.API-REFERENCE.md b/docs/02.API-REFERENCE.md index d4256747c..14c35593b 100644 --- a/docs/02.API-REFERENCE.md +++ b/docs/02.API-REFERENCE.md @@ -4875,6 +4875,52 @@ main (void) - [jerry_substring_to_char_buffer](#jerry_substring_to_char_buffer) +# Dynamic memory management functions + +## jerry_heap_alloc + +**Summary** + +Allocate memory on the engine's heap. + +*Note*: This function may take away memory from the executed JavaScript code. +If any other dynamic memory allocation API is available (e.g., libc malloc), it +should be used instead. + +**Prototype** + +```c +void *jerry_heap_alloc (size_t size); +``` + +- `size`: size of the memory block. +- return value: non-NULL pointer, if the memory is successfully allocated, + NULL otherwise. + +**See also** + +- [jerry_heap_free](#jerry_heap_free) + +## jerry_heap_free + +**Summary** + +Free memory allocated on the engine's heap. + +**Prototype** + +```c +void jerry_heap_free (void *mem_p, size_t size); +``` + +- `mem_p`: value returned by `jerry_heap_alloc`. +- `size`: same size as passed to `jerry_heap_alloc`. + +**See also** + +- [jerry_heap_alloc](#jerry_heap_alloc) + + # External context functions ## jerry_create_context diff --git a/docs/13.DEBUGGER-TRANSPORT.md b/docs/13.DEBUGGER-TRANSPORT.md index 49f3e6bf6..de483067c 100644 --- a/docs/13.DEBUGGER-TRANSPORT.md +++ b/docs/13.DEBUGGER-TRANSPORT.md @@ -96,37 +96,6 @@ typedef bool (*jerry_debugger_transport_receive_t) (struct jerry_debugger_transp # Transport interface API functions -## jerry_debugger_transport_malloc - -**Summary** - -Allocates memory for the transport interface. - -**Prototype** - -```c -void * jerry_debugger_transport_malloc (size_t size); -``` - -- `size`: size of the memory block. -- return value: non-NULL pointer, if the memory is successfully allocated, - NULL otherwise. - -## jerry_debugger_transport_free - -**Summary** - -Free memory allocated by [jerry_debugger_transport_malloc](#jerry_debugger_transport_malloc) - -**Prototype** - -```c -void jerry_debugger_transport_free (void *mem_p, size_t size); -``` - -- `header_p`: header of a transporation interface. -- `size`: total size of the transportation interface. - ## jerry_debugger_transport_add **Summary** @@ -180,7 +149,7 @@ bool jerry_debugger_transport_is_connected (void); **Summary** Disconnect from the current debugger client. It does nothing if a client is -not connected, +not connected. **Prototype** diff --git a/jerry-core/api/jerry-debugger-transport.c b/jerry-core/api/jerry-debugger-transport.c index a8df778e6..3dbac49b3 100644 --- a/jerry-core/api/jerry-debugger-transport.c +++ b/jerry-core/api/jerry-debugger-transport.c @@ -29,28 +29,6 @@ */ #define JERRY_DEBUGGER_TRANSPORT_TIMEOUT 100 -/** - * Allocate memory for a connection. - * - * @return allocated memory on success - * NULL otherwise - */ -void * -jerry_debugger_transport_malloc (size_t size) /**< size of the memory block */ -{ - return jmem_heap_alloc_block_null_on_error (size); -} /* jerry_debugger_transport_malloc */ - -/** - * Free memory allocated for a connection. - */ -void -jerry_debugger_transport_free (void *mem_p, /**< value returned by jerry_debugger_transport_malloc() */ - size_t size) /**< same size passed to jerry_debugger_transport_malloc() */ -{ - jmem_heap_free_block (mem_p, size); -} /* jerry_debugger_transport_free */ - /** * Add a new transport layer. */ diff --git a/jerry-core/api/jerry.c b/jerry-core/api/jerry.c index 58f55ca08..7d6581b75 100644 --- a/jerry-core/api/jerry.c +++ b/jerry-core/api/jerry.c @@ -2621,6 +2621,37 @@ jerry_is_valid_cesu8_string (const jerry_char_t *cesu8_buf_p, /**< CESU-8 string (lit_utf8_size_t) buf_size); } /* jerry_is_valid_cesu8_string */ +/** + * Allocate memory on the engine's heap. + * + * Note: + * This function may take away memory from the executed JavaScript code. + * If any other dynamic memory allocation API is available (e.g., libc + * malloc), it should be used instead. + * + * @return allocated memory on success + * NULL otherwise + */ +void * +jerry_heap_alloc (size_t size) /**< size of the memory block */ +{ + jerry_assert_api_available (); + + return jmem_heap_alloc_block_null_on_error (size); +} /* jerry_heap_alloc */ + +/** + * Free memory allocated on the engine's heap. + */ +void +jerry_heap_free (void *mem_p, /**< value returned by jerry_heap_alloc */ + size_t size) /**< same size as passed to jerry_heap_alloc */ +{ + jerry_assert_api_available (); + + jmem_heap_free_block (mem_p, size); +} /* jerry_heap_free */ + /** * Create an external engine context. * diff --git a/jerry-core/include/jerryscript-core.h b/jerry-core/include/jerryscript-core.h index 2b17fb2fb..2a65ee8e1 100644 --- a/jerry-core/include/jerryscript-core.h +++ b/jerry-core/include/jerryscript-core.h @@ -514,6 +514,12 @@ jerry_value_t jerry_resolve_or_reject_promise (jerry_value_t promise, jerry_valu bool jerry_is_valid_utf8_string (const jerry_char_t *utf8_buf_p, jerry_size_t buf_size); bool jerry_is_valid_cesu8_string (const jerry_char_t *cesu8_buf_p, jerry_size_t buf_size); +/* + * Dynamic memory management functions. + */ +void *jerry_heap_alloc (size_t size); +void jerry_heap_free (void *mem_p, size_t size); + /* * External context functions. */ diff --git a/jerry-core/include/jerryscript-debugger-transport.h b/jerry-core/include/jerryscript-debugger-transport.h index d2cd115ce..f6f9acaaa 100644 --- a/jerry-core/include/jerryscript-debugger-transport.h +++ b/jerry-core/include/jerryscript-debugger-transport.h @@ -83,8 +83,6 @@ typedef struct jerry_debugger_transport_interface_t struct jerry_debugger_transport_interface_t *next_p; /**< next transport layer */ } jerry_debugger_transport_header_t; -void * jerry_debugger_transport_malloc (size_t size); -void jerry_debugger_transport_free (void *mem_p, size_t size); void jerry_debugger_transport_add (jerry_debugger_transport_header_t *header_p, size_t send_message_header_size, size_t max_send_message_size, size_t receive_message_header_size, size_t max_receive_message_size); diff --git a/jerry-ext/debugger/debugger-tcp.c b/jerry-ext/debugger/debugger-tcp.c index 42d89f396..92f26e490 100644 --- a/jerry-ext/debugger/debugger-tcp.c +++ b/jerry-ext/debugger/debugger-tcp.c @@ -56,7 +56,7 @@ jerryx_debugger_tcp_close (jerry_debugger_transport_header_t *header_p) /**< tcp close (tcp_p->tcp_socket); - jerry_debugger_transport_free ((void *) header_p, sizeof (jerryx_debugger_transport_tcp_t)); + jerry_heap_free ((void *) header_p, sizeof (jerryx_debugger_transport_tcp_t)); } /* jerryx_debugger_tcp_close */ /** @@ -223,7 +223,7 @@ jerryx_debugger_tcp_create (uint16_t port) /**< listening port */ size_t size = sizeof (jerryx_debugger_transport_tcp_t); jerry_debugger_transport_header_t *header_p; - header_p = (jerry_debugger_transport_header_t *) jerry_debugger_transport_malloc (size); + header_p = (jerry_debugger_transport_header_t *) jerry_heap_alloc (size); if (!header_p) { diff --git a/jerry-ext/debugger/debugger-ws.c b/jerry-ext/debugger/debugger-ws.c index ec32a9d85..c48b9f9d1 100644 --- a/jerry-ext/debugger/debugger-ws.c +++ b/jerry-ext/debugger/debugger-ws.c @@ -277,7 +277,7 @@ jerryx_debugger_ws_close (jerry_debugger_transport_header_t *header_p) /**< tcp { JERRYX_ASSERT (!jerry_debugger_transport_is_connected ()); - jerry_debugger_transport_free ((void *) header_p, sizeof (jerry_debugger_transport_header_t)); + jerry_heap_free ((void *) header_p, sizeof (jerry_debugger_transport_header_t)); } /* jerryx_debugger_ws_close */ /** @@ -411,7 +411,7 @@ jerryx_debugger_ws_create (void) bool is_handshake_ok = false; const size_t buffer_size = 1024; - uint8_t *request_buffer_p = (uint8_t *) jerry_debugger_transport_malloc (buffer_size); + uint8_t *request_buffer_p = (uint8_t *) jerry_heap_alloc (buffer_size); if (!request_buffer_p) { @@ -420,7 +420,7 @@ jerryx_debugger_ws_create (void) is_handshake_ok = jerryx_process_handshake (request_buffer_p); - jerry_debugger_transport_free ((void *) request_buffer_p, buffer_size); + jerry_heap_free ((void *) request_buffer_p, buffer_size); if (!is_handshake_ok && jerry_debugger_transport_is_connected ()) { @@ -429,7 +429,7 @@ jerryx_debugger_ws_create (void) const size_t interface_size = sizeof (jerry_debugger_transport_header_t); jerry_debugger_transport_header_t *header_p; - header_p = (jerry_debugger_transport_header_t *) jerry_debugger_transport_malloc (interface_size); + header_p = (jerry_debugger_transport_header_t *) jerry_heap_alloc (interface_size); if (!header_p) {