# HG changeset patch # User Mike Becker # Date 1612696807 -3600 # Node ID f094a53c1178a1d93f7c95e9204a17f70c4fe24a # Parent d345541018fae434c5fd28098f353d4fc510f895 adds allocator interface and default implementation diff -r d345541018fa -r f094a53c1178 src/CMakeLists.txt --- a/src/CMakeLists.txt Sat Feb 06 19:11:44 2021 +0100 +++ b/src/CMakeLists.txt Sun Feb 07 12:20:07 2021 +0100 @@ -1,7 +1,9 @@ set(sources + allocator.c list.c ) set(headers + cx/allocator.h cx/list.h ) diff -r d345541018fa -r f094a53c1178 src/allocator.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/allocator.c Sun Feb 07 12:20:07 2021 +0100 @@ -0,0 +1,56 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "cx/allocator.h" + +#include + +struct cx_allocator_s cx_default_allocator = { + cx_malloc_stdlib, + cx_realloc_stdlib, + cx_calloc_stdlib, + cx_free_stdlib, + NULL +}; +CxAllocator cxDefaultAllocator = &cx_default_allocator; + +void* cx_malloc_stdlib(cx_allocator a, size_t n) { + return malloc(n); +} + +void* cx_realloc_stdlib(cx_allocator a, void* mem, size_t n) { + return realloc(mem, n); +} + +void* cx_calloc_stdlib(cx_allocator a, size_t nelem, size_t n) { + return calloc(nelem, n); +} + +void cx_free_stdlib(cx_allocator a, void* mem) { + free(mem); +} diff -r d345541018fa -r f094a53c1178 src/cx/allocator.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cx/allocator.h Sun Feb 07 12:20:07 2021 +0100 @@ -0,0 +1,61 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef UCX_ALLOCATOR_H +#define UCX_ALLOCATOR_H + +#include + +typedef void* cx_allocator; +typedef void*(*cx_malloc_func)(cx_allocator a, size_t n); +typedef void*(*cx_realloc_func)(cx_allocator a, void* mem, size_t n); +typedef void*(*cx_calloc_func)(cx_allocator a, size_t nelem, size_t n); +typedef void(*cx_free_func)(cx_allocator a, void* mem); + +void* cx_malloc_stdlib(cx_allocator a, size_t n); +void* cx_realloc_stdlib(cx_allocator a, void* mem, size_t n); +void* cx_calloc_stdlib(cx_allocator a, size_t nelem, size_t n); +void cx_free_stdlib(cx_allocator a, void* mem); + +struct cx_allocator_s { + cx_malloc_func malloc; + cx_realloc_func realloc; + cx_calloc_func calloc; + cx_free_func free; + void* data; +}; +typedef struct cx_allocator_s* CxAllocator; + +extern CxAllocator cxDefaultAllocator; + +#define cxMalloc(a, n) (a)->malloc((a), n) +#define cxRealloc(a, mem, n) (a)->realloc((a), mem, n) +#define cxCalloc(a, nelem, n) (a)->calloc((a), nelem, n) +#define cxFree(a, mem) (a)->free((a), mem) + +#endif //UCX_ALLOCATOR_H diff -r d345541018fa -r f094a53c1178 test/CMakeLists.txt --- a/test/CMakeLists.txt Sat Feb 06 19:11:44 2021 +0100 +++ b/test/CMakeLists.txt Sun Feb 07 12:20:07 2021 +0100 @@ -1,6 +1,22 @@ +message(CHECK_START "Searching for CUnit test framework") -add_executable(test_list - test_list.c -) -target_link_libraries(test_list PRIVATE ucx_static) -add_test(NAME list COMMAND test_list WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") +find_path(CUNIT_INCLUDE_DIR NAMES CUnit/CUnit.h) +find_library(CUNIT_LIBRARY NAMES cunit libcunit cunitlib) +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(CUnit DEFAULT_MSG CUNIT_LIBRARY CUNIT_INCLUDE_DIR) + +if(CUNIT_FOUND) + message(CHECK_PASS "found: compiling tests.") + set(TESTS + test_allocator + test_list + ) + + foreach(test ${TESTS}) + add_executable(${test} ${test}.c) + target_link_libraries(${test} PRIVATE ucx_static ${CUNIT_LIBRARY}) + add_test(NAME ${test} COMMAND ${test} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") + endforeach() +else() + message(CHECK_FAIL "not found: unit tests will not be available.") +endif() diff -r d345541018fa -r f094a53c1178 test/test_allocator.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/test_allocator.c Sun Feb 07 12:20:07 2021 +0100 @@ -0,0 +1,94 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "cx/allocator.h" + +#include + +void test_default_allocator_available(void) { + CU_ASSERT_PTR_EQUAL(cxDefaultAllocator->malloc, cx_malloc_stdlib) + CU_ASSERT_PTR_EQUAL(cxDefaultAllocator->realloc, cx_realloc_stdlib) + CU_ASSERT_PTR_EQUAL(cxDefaultAllocator->calloc, cx_calloc_stdlib) + CU_ASSERT_PTR_EQUAL(cxDefaultAllocator->free, cx_free_stdlib) +} + +void test_default_malloc(void) { + void* test = cxMalloc(cxDefaultAllocator, 16); + CU_ASSERT_PTR_NOT_NULL(test); + free(test); +} + +void test_default_realloc(void) { + void* test = calloc(8, 1); + memcpy(test, "Test", 4); + test = cxRealloc(cxDefaultAllocator, test, 16); + CU_ASSERT_PTR_NOT_NULL(test); + CU_ASSERT_STRING_EQUAL("Test", test) + free(test); +} + +void test_default_calloc(void) { + void* test = cxCalloc(cxDefaultAllocator, 8, 2); + CU_ASSERT_PTR_NOT_NULL(test); + free(test); +} + +void test_default_free(void) { + CU_PASS("Testing standard free is not possible.") +} + +int main() { + CU_pSuite suite = NULL; + + if (CUE_SUCCESS != CU_initialize_registry()) { + return CU_get_error(); + } + + suite = CU_add_suite("stdlib allocator", NULL, NULL); + if (NULL == suite) { + CU_cleanup_registry(); + return CU_get_error(); + } + + if ( + (NULL == CU_add_test(suite, "default allocator available", test_default_allocator_available)) || + (NULL == CU_add_test(suite, "test of malloc()", test_default_malloc)) || + (NULL == CU_add_test(suite, "test of realloc()", test_default_realloc)) || + (NULL == CU_add_test(suite, "test of realloc()", test_default_calloc)) || + (NULL == CU_add_test(suite, "test of free()", test_default_free)) + ) { + CU_cleanup_registry(); + return CU_get_error(); + } + + CU_basic_set_mode(CU_BRM_NORMAL); + CU_basic_run_tests(); + CU_cleanup_registry(); + + return CU_get_error(); +}