Embedded/lwmem
1
0
Fork 0
mirror of https://github.com/MaJerle/lwmem.git synced 2025-01-13 21:42:53 +08:00
Code Issues Projects Releases Wiki Activity

fix the length for region size, add the test cases

Browse Source
This commit is contained in:
Tilen Majerle 2024-12-27 19:55:32 +01:00
parent c36034a686
commit 9f5e71482c
7 changed files with 101 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGELOG.md
View File

@ -2,6 +2,8 @@
## Develop
- Fix the wrong variable to reduce the size of the region
## v2.2.0
- Rework library CMake with removed INTERFACE type

1
CMakeLists.txt
View File

@ -11,6 +11,7 @@ else()
${CMAKE_CURRENT_LIST_DIR}/dev/main.cpp
${CMAKE_CURRENT_LIST_DIR}/tests/lwmem_test.c
${CMAKE_CURRENT_LIST_DIR}/tests/lwmem_test_simple.c
${CMAKE_CURRENT_LIST_DIR}/tests/lwmem_test_region.c
# win32 port
${CMAKE_CURRENT_LIST_DIR}/lwmem/src/system/lwmem_sys_win32.c

2
dev/lwmem_opts.h
View File

@ -45,6 +45,6 @@
#define LWMEM_CFG_OS_MUTEX_HANDLE HANDLE
#define LWMEM_CFG_ENABLE_STATS 0
#define LWMEM_CFG_CLEAN_MEMORY 1
#define LWMEM_CFG_FULL 0
#define LWMEM_CFG_FULL 1
#endif /* LWMEM_HDR_OPTS_H */

3
dev/main.cpp
View File

@ -7,12 +7,15 @@
extern "C" void lwmem_test_run(void);
extern "C" void lwmem_test_simple_run(void);
extern "C" void lwmem_test_memory_structure(void);
extern "C" void lwmem_test_region(void);
/* Setup manager */
static Lwmem::LwmemLight<1024> manager;
int
main(void) {
lwmem_test_region();
return 0;
#if LWMEM_CFG_FULL
lwmem_test_memory_structure();
//lwmem_test_run();

3
lwmem/src/include/lwmem/lwmem.h
View File

@ -144,8 +144,9 @@ size_t lwmem_get_size(void* ptr);
unsigned char lwmem_debug_create_regions(lwmem_region_t** regs_out, size_t count, size_t size);
void lwmem_debug_save_state(void);
void lwmem_debug_restore_to_saved(void);
void lwmem_debug_print(unsigned char print_alloc, unsigned char print_free);
void lwmem_debug_test_region(void* region_start, size_t region_size, uint8_t** region_start_calc,
size_t* region_size_calc);
#endif /* defined(LWMEM_DEV) && !__DOXYGEN__ */
/**

11
lwmem/src/lwmem/lwmem.c
View File

@ -206,7 +206,7 @@ prv_get_region_addr_size(const lwmem_region_t* region, uint8_t** msa, size_t* ms
}
/* Check region size and align it to config bits */
mem_size = region->size & ~LWMEM_ALIGN_BITS; /* Size does not include lower bits */
mem_size &= ~LWMEM_ALIGN_BITS; /* Align the size to lower bits */
if (mem_size < (2 * LWMEM_BLOCK_MIN_SIZE)) {
return 0;
}
@ -1427,4 +1427,13 @@ lwmem_debug_restore_to_saved(void) {
printf(" -- > State restored to last saved!\r\n");
}
void
lwmem_debug_test_region(void* region_start, size_t region_size, uint8_t** region_start_calc, size_t* region_size_calc) {
lwmem_region_t region = {
.start_addr = region_start,
.size = region_size,
};
prv_get_region_addr_size(&region, region_start_calc, region_size_calc);
}
#endif /* defined(LWMEM_DEV) && !__DOXYGEN__ */

82
tests/lwmem_test_region.c Normal file
View File

@ -0,0 +1,82 @@
#include <stdio.h>
#include "lwmem/lwmem.h"
#if LWMEM_CFG_ALIGN_NUM != 4
#error "Test shall run with LWMEM_CFG_ALIGN_NUM == 4"
#endif
/* Test assert information */
#define TEST_ASSERT(condition) \
do { \
if (!(condition)) { \
printf("Assert failed on the line %d\r\n", __LINE__); \
return; \
} \
} while (0)
typedef struct {
uint8_t* region_start;
size_t region_size;
uint8_t* region_start_exp;
size_t region_size_exp;
} test_region_t;
#define TEST_ENTRY(_region_start_, _region_size_, _region_start_exp_, _region_size_exp_) \
{ \
.region_start = (void*)(_region_start_), \
.region_size = (_region_size_), \
.region_start_exp = (void*)(_region_start_exp_), \
.region_size_exp = (_region_size_exp_), \
}
/* List of test cases */
static const test_region_t test_cases[] = {
TEST_ENTRY(0x00000000, 0x00000000, 0x00000000, 0x00000000),
TEST_ENTRY(0x00000000, 0x00004000, 0x00000000, 0x00004000),
TEST_ENTRY(0x00000000, 0x00004001, 0x00000000, 0x00004000),
TEST_ENTRY(0x00000000, 0x00004002, 0x00000000, 0x00004000),
TEST_ENTRY(0x00000000, 0x00004003, 0x00000000, 0x00004000),
TEST_ENTRY(0x00000000, 0x00004004, 0x00000000, 0x00004004),
TEST_ENTRY(0x00000000, 0x00004005, 0x00000000, 0x00004004),
/* Start is not always aligned, but length input is aligned */
TEST_ENTRY(0x00000000, 0x00004000, 0x00000000, 0x00004000),
/* Start must advance to next aligned value, size reduced to next lower aligned value */
TEST_ENTRY(0x00000001, 0x00004000, 0x00000004, 0x00003FFC),
TEST_ENTRY(0x00000002, 0x00004000, 0x00000004, 0x00003FFC),
TEST_ENTRY(0x00000003, 0x00004000, 0x00000004, 0x00003FFC),
TEST_ENTRY(0x00000003, 0x00004003, 0x00000004, 0x00004000),
TEST_ENTRY(0x00000003, 0x00004004, 0x00000004, 0x00004000),
TEST_ENTRY(0x00000003, 0x00004005, 0x00000004, 0x00004004),
TEST_ENTRY(0x00000001, 0x00004003, 0x00000004, 0x00004000),
TEST_ENTRY(0x00000002, 0x00004005, 0x00000004, 0x00004000),
TEST_ENTRY(0x00000002, 0x00004006, 0x00000004, 0x00004004),
TEST_ENTRY(0x00000002, 0x00004007, 0x00000004, 0x00004004),
TEST_ENTRY(0x00000003, 0x00004006, 0x00000004, 0x00004004),
TEST_ENTRY(0x00000003, 0x00004005, 0x00000004, 0x00004004),
TEST_ENTRY(0x00000004, 0x00004006, 0x00000004, 0x00004004),
};
/* Start is aligned, length is not always aligned */
void
lwmem_test_region(void) {
uint8_t* region_start = NULL;
size_t region_size = 0;
for (size_t idx = 0; idx < sizeof(test_cases) / sizeof(test_cases[0]); ++idx) {
const test_region_t* test = &test_cases[idx];
lwmem_debug_test_region(test->region_start, test->region_size, &region_start, &region_size);
if (region_start != test->region_start_exp) {
printf("Region start test failed. Idx: %u, input: 0x%08p, expected: 0x%08p, output: 0x%08p\r\n",
(unsigned)idx, test->region_start, test->region_start_exp, region_start);
} else if (region_size != test->region_size_exp) {
printf("Region size test failed. Idx: %u, input: 0x%08X, expected: 0x%08X, output: 0x%08X\r\n",
(unsigned)idx, (unsigned)test->region_size, (unsigned)test->region_size_exp, (unsigned)region_size);
}
}
printf("Done\r\n");
}