From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp48.i.mail.ru (smtp48.i.mail.ru [94.100.177.108]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dev.tarantool.org (Postfix) with ESMTPS id D091D469719 for ; Tue, 13 Oct 2020 02:23:07 +0300 (MSK) From: Alexander Turenko Date: Tue, 13 Oct 2020 02:23:09 +0300 Message-Id: <3bcd42aa108daa198825597b97e54d4c09c0c1b0.1602541394.git.alexander.turenko@tarantool.org> In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [Tarantool-patches] [PATCH v3 02/16] module api: expose box region List-Id: Tarantool development patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Vladislav Shpilevoy Cc: tarantool-patches@dev.tarantool.org, Alexander Turenko It is the better alternative to linking the small library directly to a module. Why not just use the small library in a module? Functions from an executable are preferred over ones that are shipped in a dynamic library (on Linux, Mac OS differs), while a module may use the small library directly. It may cause a problem when some functions from the library are inlined, but some are not, and those different versions of the library offer structures with different layouts. Small library symbols may be exported by the tarantool executable after the change of default symbols visibility (see [1]). See more details and examples in [2]. So it is better to expose so called box region and get rid of all those compatibility problems. [1]: 2.5.0-42-g03790ac55 ('cmake: remove dynamic-list linker option') [2]: https://lists.tarantool.org/pipermail/tarantool-discussions/2020-September/000095.html Part of #5273 --- src/exports.h | 4 ++ src/lib/core/fiber.c | 24 +++++++++ src/lib/core/fiber.h | 76 +++++++++++++++++++++++++++++ test/app-tap/module_api.c | 84 ++++++++++++++++++++++++++++++++ test/app-tap/module_api.test.lua | 2 +- 5 files changed, 189 insertions(+), 1 deletion(-) diff --git a/src/exports.h b/src/exports.h index 6d8303180..7861bb529 100644 --- a/src/exports.h +++ b/src/exports.h @@ -218,6 +218,10 @@ EXPORT(fiber_is_cancelled) EXPORT(fiber_join) EXPORT(fiber_new) EXPORT(fiber_new_ex) +EXPORT(box_region_aligned_alloc) +EXPORT(box_region_alloc) +EXPORT(box_region_truncate) +EXPORT(box_region_used) EXPORT(fiber_reschedule) EXPORT(fiber_self) EXPORT(fiber_set_cancellable) diff --git a/src/lib/core/fiber.c b/src/lib/core/fiber.c index 223c841df..33ec47c66 100644 --- a/src/lib/core/fiber.c +++ b/src/lib/core/fiber.c @@ -1368,6 +1368,30 @@ fiber_top_disable(void) } #endif /* ENABLE_FIBER_TOP */ +size_t +box_region_used(void) +{ + return region_used(&fiber()->gc); +} + +void * +box_region_alloc(size_t size) +{ + return region_alloc(&fiber()->gc, size); +} + +void * +box_region_aligned_alloc(size_t size, size_t alignment) +{ + return region_aligned_alloc(&fiber()->gc, size, alignment); +} + +void +box_region_truncate(size_t size) +{ + return region_truncate(&fiber()->gc, size); +} + void cord_create(struct cord *cord, const char *name) { diff --git a/src/lib/core/fiber.h b/src/lib/core/fiber.h index 16ee9f414..a3014cc0a 100644 --- a/src/lib/core/fiber.h +++ b/src/lib/core/fiber.h @@ -386,6 +386,82 @@ struct slab_cache; API_EXPORT struct slab_cache * cord_slab_cache(void); +/** + * box region allocator + * + * It is the region allocator from the small library. It is useful + * for allocating tons of small objects and free them at once. + * + * Typical usage is illustrated in the sketch below. + * + * | size_t region_svp = box_region_used(); + * | while (<...>) { + * | char *buf = box_region_alloc(<...>); + * | <...> + * | } + * | box_region_truncate(region_svp); + * + * There are module API functions that return a result on + * this region. In this case a module is responsible to free the + * result: + * + * | size_t region_svp = box_region_used(); + * | char *buf = box_<...>(<...>); + * | <...> + * | box_region_truncate(region_svp); + * + * This API provides better compatibility guarantees over using + * the small library directly in a module. A binary layout of + * internal structures may be changed in a future, but + * () functions will remain API and ABI compatible. + * + * Data allocated on the region are guaranteed to be valid until + * a fiber yield or a call of a function from the certain set: + * + * - Related to transactions. + * - Ones that may cause box initialization (box.cfg()). + * - Ones that may involve SQL execution. + * + * FIXME: Provide more strict list of functions, which may + * invalidate the data: ones that may lead to calling of + * fiber_gc(). + * + * It is safe to call simple box APIs around tuples, key_defs and + * so on -- they don't invalidate the allocated data. + * + * Don't assume this region as fiber local. This is an + * implementation detail and may be changed in a future. + */ + +/** How much memory is used by the box region. */ +API_EXPORT size_t +box_region_used(void); + +/** + * Allocate size bytes from the box region. + * + * Don't use this function to allocate a memory block for a value + * or array of values of a type with alignment requirements. A + * violation of alignment requirements leads to undefined + * behaviour. + */ +API_EXPORT void * +box_region_alloc(size_t size); + +/** + * Allocate size bytes from the box region with given alignment. + * + * Alignment must be a power of 2. + */ +API_EXPORT void * +box_region_aligned_alloc(size_t size, size_t alignment); + +/** + * Truncate the box region to the given size. + */ +void +box_region_truncate(size_t size); + /** \endcond public */ /** diff --git a/test/app-tap/module_api.c b/test/app-tap/module_api.c index a79fbed0d..12d20e886 100644 --- a/test/app-tap/module_api.c +++ b/test/app-tap/module_api.c @@ -15,6 +15,10 @@ #define STR2(x) #x #define STR(x) STR2(x) +#ifndef lengthof +#define lengthof(array) (sizeof(array) / sizeof((array)[0])) +#endif + /* Test for constants */ static const char *consts[] = { PACKAGE_VERSION, @@ -451,6 +455,85 @@ test_iscallable(lua_State *L) return 1; } +/* {{{ test_box_region */ + +/** + * Verify basic usage of box region. + */ +static int +test_box_region(struct lua_State *L) +{ + size_t region_svp_0 = box_region_used(); + + /* Verify allocation and box_region_used(). */ + size_t size_arr[] = {1, 7, 19, 10 * 1024 * 1024, 1, 18, 1024}; + size_t region_svp_arr[lengthof(size_arr)]; + char *ptr_arr[lengthof(size_arr)]; + for (size_t i = 0; i < lengthof(size_arr); ++i) { + size_t size = size_arr[i]; + size_t region_svp = box_region_used(); + char *ptr = box_region_alloc(size); + + /* Verify box_region_used() after allocation. */ + assert(box_region_used() - region_svp == size); + + /* Verify that data is accessible. */ + for (char *p = ptr; p < ptr + size; ++p) + *p = 'x'; + + /* + * Save data pointer and savepoint to verify + * truncation later. + */ + ptr_arr[i] = ptr; + region_svp_arr[i] = region_svp; + } + + /* Verify truncation. */ + for (ssize_t i = lengthof(region_svp_arr) - 1; i >= 0; --i) { + box_region_truncate(region_svp_arr[i]); + assert(box_region_used() == region_svp_arr[i]); + + /* + * Verify that all data before this savepoint + * still accessible. + */ + for (ssize_t j = 0; j < i; ++j) { + size_t size = size_arr[j]; + char *ptr = ptr_arr[j]; + for (char *p = ptr; p < ptr + size; ++p) { + assert(*p == 'x' || *p == 'y'); + *p = 'y'; + } + } + } + assert(box_region_used() == region_svp_0); + + /* Verify aligned allocation. */ + size_t a_size_arr[] = {1, 3, 5, 7, 11, 13, 17, 19}; + size_t alignment_arr[] = {1, 2, 4, 8, 16, 32, 64}; + for (size_t s = 0; s < lengthof(a_size_arr); ++s) { + for (size_t a = 0; a < lengthof(alignment_arr); ++a) { + size_t size = a_size_arr[s]; + size_t alignment = alignment_arr[a]; + char *ptr = box_region_aligned_alloc(size, alignment); + assert((uintptr_t) ptr % alignment == 0); + + /* Data is accessible. */ + for (char *p = ptr; p < ptr + size; ++p) + *p = 'x'; + } + } + + /* Clean up. */ + box_region_truncate(region_svp_0); + + lua_pushboolean(L, true); + return 1; +} + +/* }}} test_box_region */ + LUA_API int luaopen_module_api(lua_State *L) { @@ -479,6 +562,7 @@ luaopen_module_api(lua_State *L) {"test_state", test_state}, {"test_tostring", test_tostring}, {"iscallable", test_iscallable}, + {"test_box_region", test_box_region}, {NULL, NULL} }; luaL_register(L, "module_api", lib); diff --git a/test/app-tap/module_api.test.lua b/test/app-tap/module_api.test.lua index a6658cc61..08e8add35 100755 --- a/test/app-tap/module_api.test.lua +++ b/test/app-tap/module_api.test.lua @@ -117,7 +117,7 @@ local function test_iscallable(test, module) end local test = require('tap').test("module_api", function(test) - test:plan(24) + test:plan(25) local status, module = pcall(require, 'module_api') test:is(status, true, "module") test:ok(status, "module is loaded") -- 2.25.0