1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
11 #include <sys/queue.h>
13 #include <rte_common.h>
14 #include <rte_memory.h>
15 #include <rte_eal_memconfig.h>
16 #include <rte_per_lcore.h>
17 #include <rte_launch.h>
19 #include <rte_lcore.h>
20 #include <rte_malloc.h>
21 #include <rte_cycles.h>
22 #include <rte_random.h>
23 #include <rte_string_fns.h>
33 * Allocate some dynamic memory from heap (3 areas). Check that areas
34 * don't overlap and that alignment constraints match. This test is
35 * done many times on different lcores simultaneously.
38 /* Test if memory overlaps: return 1 if true, or 0 if false. */
40 is_memory_overlap(void *p1
, size_t len1
, void *p2
, size_t len2
)
42 unsigned long ptr1
= (unsigned long)p1
;
43 unsigned long ptr2
= (unsigned long)p2
;
45 if (ptr2
>= ptr1
&& (ptr2
- ptr1
) < len1
)
47 else if (ptr2
< ptr1
&& (ptr1
- ptr2
) < len2
)
53 is_aligned(void *p
, int align
)
55 unsigned long addr
= (unsigned long)p
;
56 unsigned mask
= align
- 1;
64 test_align_overlap_per_lcore(__attribute__((unused
)) void *arg
)
66 const unsigned align1
= 8,
70 void *p1
= NULL
, *p2
= NULL
, *p3
= NULL
;
73 for (i
= 0; i
< N
; i
++) {
74 p1
= rte_zmalloc("dummy", 1000, align1
);
76 printf("rte_zmalloc returned NULL (i=%u)\n", i
);
80 for(j
= 0; j
< 1000 ; j
++) {
81 if( *(char *)p1
!= 0) {
82 printf("rte_zmalloc didn't zero the allocated memory\n");
86 p2
= rte_malloc("dummy", 1000, align2
);
88 printf("rte_malloc returned NULL (i=%u)\n", i
);
93 p3
= rte_malloc("dummy", 1000, align3
);
95 printf("rte_malloc returned NULL (i=%u)\n", i
);
101 if (is_memory_overlap(p1
, 1000, p2
, 1000)) {
102 printf("p1 and p2 overlaps\n");
105 if (is_memory_overlap(p2
, 1000, p3
, 1000)) {
106 printf("p2 and p3 overlaps\n");
109 if (is_memory_overlap(p1
, 1000, p3
, 1000)) {
110 printf("p1 and p3 overlaps\n");
113 if (!is_aligned(p1
, align1
)) {
114 printf("p1 is not aligned\n");
117 if (!is_aligned(p2
, align2
)) {
118 printf("p2 is not aligned\n");
121 if (!is_aligned(p3
, align3
)) {
122 printf("p3 is not aligned\n");
129 rte_malloc_dump_stats(stdout
, "dummy");
135 test_reordered_free_per_lcore(__attribute__((unused
)) void *arg
)
137 const unsigned align1
= 8,
144 for (i
= 0; i
< 30; i
++) {
145 p1
= rte_zmalloc("dummy", 1000, align1
);
147 printf("rte_zmalloc returned NULL (i=%u)\n", i
);
151 for(j
= 0; j
< 1000 ; j
++) {
152 if( *(char *)p1
!= 0) {
153 printf("rte_zmalloc didn't zero the allocated memory\n");
157 /* use calloc to allocate 1000 16-byte items this time */
158 p2
= rte_calloc("dummy", 1000, 16, align2
);
159 /* for third request use regular malloc again */
160 p3
= rte_malloc("dummy", 1000, align3
);
162 printf("rte_malloc returned NULL (i=%u)\n", i
);
166 if (is_memory_overlap(p1
, 1000, p2
, 1000)) {
167 printf("p1 and p2 overlaps\n");
170 if (is_memory_overlap(p2
, 1000, p3
, 1000)) {
171 printf("p2 and p3 overlaps\n");
174 if (is_memory_overlap(p1
, 1000, p3
, 1000)) {
175 printf("p1 and p3 overlaps\n");
178 if (!is_aligned(p1
, align1
)) {
179 printf("p1 is not aligned\n");
182 if (!is_aligned(p2
, align2
)) {
183 printf("p2 is not aligned\n");
186 if (!is_aligned(p3
, align3
)) {
187 printf("p3 is not aligned\n");
190 /* try freeing in every possible order */
224 rte_malloc_dump_stats(stdout
, "dummy");
229 /* test function inside the malloc lib*/
231 test_str_to_size(void)
237 {{ "5G", (uint64_t)5 * 1024 * 1024 *1024 },
238 {"0x20g", (uint64_t)0x20 * 1024 * 1024 *1024},
239 {"10M", 10 * 1024 * 1024},
240 {"050m", 050 * 1024 * 1024},
246 {"-1", 0}, /* negative values return 0 */
249 {"18446744073709551616", 0} /* ULLONG_MAX + 1 == out of range*/
252 for (i
= 0; i
< sizeof(test_values
)/sizeof(test_values
[0]); i
++)
253 if (rte_str_to_size(test_values
[i
].str
) != test_values
[i
].value
)
259 test_multi_alloc_statistics(void)
262 struct rte_malloc_socket_stats pre_stats
, post_stats
,first_stats
, second_stats
;
265 #ifndef RTE_MALLOC_DEBUG
266 int trailer_size
= 0;
268 int trailer_size
= RTE_CACHE_LINE_SIZE
;
270 int overhead
= RTE_CACHE_LINE_SIZE
+ trailer_size
;
272 rte_malloc_get_socket_stats(socket
, &pre_stats
);
274 void *p1
= rte_malloc_socket("stats", size
, align
, socket
);
278 rte_malloc_dump_stats(stdout
, "stats");
280 rte_malloc_get_socket_stats(socket
,&post_stats
);
281 /* Check statistics reported are correct */
282 /* All post stats should be equal to pre stats after alloc freed */
283 if ((post_stats
.heap_totalsz_bytes
!= pre_stats
.heap_totalsz_bytes
) &&
284 (post_stats
.heap_freesz_bytes
!=pre_stats
.heap_freesz_bytes
) &&
285 (post_stats
.heap_allocsz_bytes
!=pre_stats
.heap_allocsz_bytes
)&&
286 (post_stats
.alloc_count
!=pre_stats
.alloc_count
)&&
287 (post_stats
.free_count
!=pre_stats
.free_count
)) {
288 printf("Malloc statistics are incorrect - freed alloc\n");
291 /* Check two consecutive allocations */
294 rte_malloc_get_socket_stats(socket
,&pre_stats
);
295 void *p2
= rte_malloc_socket("add", size
,align
, socket
);
298 rte_malloc_get_socket_stats(socket
,&first_stats
);
300 void *p3
= rte_malloc_socket("add2", size
,align
, socket
);
304 rte_malloc_get_socket_stats(socket
,&second_stats
);
309 /* After freeing both allocations check stats return to original */
310 rte_malloc_get_socket_stats(socket
, &post_stats
);
312 if(second_stats
.heap_totalsz_bytes
!= first_stats
.heap_totalsz_bytes
) {
313 printf("Incorrect heap statistics: Total size \n");
316 /* Check allocated size is equal to two additions plus overhead */
317 if(second_stats
.heap_allocsz_bytes
!=
318 size
+ overhead
+ first_stats
.heap_allocsz_bytes
) {
319 printf("Incorrect heap statistics: Allocated size \n");
322 /* Check that allocation count increments correctly i.e. +1 */
323 if (second_stats
.alloc_count
!= first_stats
.alloc_count
+ 1) {
324 printf("Incorrect heap statistics: Allocated count \n");
328 if (second_stats
.free_count
!= first_stats
.free_count
){
329 printf("Incorrect heap statistics: Free count \n");
333 /* Make sure that we didn't touch our greatest chunk: 2 * 11M) */
334 if (post_stats
.greatest_free_size
!= pre_stats
.greatest_free_size
) {
335 printf("Incorrect heap statistics: Greatest free size \n");
338 /* Free size must equal the original free size minus the new allocation*/
339 if (first_stats
.heap_freesz_bytes
<= second_stats
.heap_freesz_bytes
) {
340 printf("Incorrect heap statistics: Free size \n");
344 if ((post_stats
.heap_totalsz_bytes
!= pre_stats
.heap_totalsz_bytes
) &&
345 (post_stats
.heap_freesz_bytes
!=pre_stats
.heap_freesz_bytes
) &&
346 (post_stats
.heap_allocsz_bytes
!=pre_stats
.heap_allocsz_bytes
)&&
347 (post_stats
.alloc_count
!=pre_stats
.alloc_count
)&&
348 (post_stats
.free_count
!=pre_stats
.free_count
)) {
349 printf("Malloc statistics are incorrect - freed alloc\n");
356 test_rte_malloc_type_limits(void)
358 /* The type-limits functionality is not yet implemented,
359 * so always return 0 no matter what the retval.
361 const char *typename
= "limit_test";
362 rte_malloc_set_limit(typename
, 64 * 1024);
363 rte_malloc_dump_stats(stdout
, typename
);
370 const char hello_str
[] = "Hello, world!";
371 const unsigned size1
= 1024;
372 const unsigned size2
= size1
+ 1024;
373 const unsigned size3
= size2
;
374 const unsigned size4
= size3
+ 1024;
376 /* test data is the same even if element is moved*/
377 char *ptr1
= rte_zmalloc(NULL
, size1
, RTE_CACHE_LINE_SIZE
);
379 printf("NULL pointer returned from rte_zmalloc\n");
382 strlcpy(ptr1
, hello_str
, size1
);
383 char *ptr2
= rte_realloc(ptr1
, size2
, RTE_CACHE_LINE_SIZE
);
386 printf("NULL pointer returned from rte_realloc\n");
390 printf("unexpected - ptr1 == ptr2\n");
392 if (strcmp(ptr2
, hello_str
) != 0){
393 printf("Error - lost data from pointed area\n");
398 for (i
= strnlen(hello_str
, sizeof(hello_str
)); i
< size1
; i
++)
400 printf("Bad data in realloc\n");
404 /* now allocate third element, free the second
405 * and resize third. It should not move. (ptr1 is now invalid)
407 char *ptr3
= rte_zmalloc(NULL
, size3
, RTE_CACHE_LINE_SIZE
);
409 printf("NULL pointer returned from rte_zmalloc\n");
413 for (i
= 0; i
< size3
; i
++)
415 printf("Bad data in zmalloc\n");
421 /* first resize to half the size of the freed block */
422 char *ptr4
= rte_realloc(ptr3
, size4
, RTE_CACHE_LINE_SIZE
);
424 printf("NULL pointer returned from rte_realloc\n");
429 printf("Unexpected - ptr4 != ptr3\n");
433 /* now resize again to the full size of the freed block */
434 ptr4
= rte_realloc(ptr3
, size3
+ size2
+ size1
, RTE_CACHE_LINE_SIZE
);
436 printf("Unexpected - ptr4 != ptr3 on second resize\n");
442 /* now try a resize to a smaller size, see if it works */
443 const unsigned size5
= 1024;
444 const unsigned size6
= size5
/ 2;
445 char *ptr5
= rte_malloc(NULL
, size5
, RTE_CACHE_LINE_SIZE
);
447 printf("NULL pointer returned from rte_malloc\n");
450 char *ptr6
= rte_realloc(ptr5
, size6
, RTE_CACHE_LINE_SIZE
);
452 printf("NULL pointer returned from rte_realloc\n");
457 printf("Error, resizing to a smaller size moved data\n");
463 /* check for behaviour changing alignment */
464 const unsigned size7
= 1024;
465 const unsigned orig_align
= RTE_CACHE_LINE_SIZE
;
466 unsigned new_align
= RTE_CACHE_LINE_SIZE
* 2;
467 char *ptr7
= rte_malloc(NULL
, size7
, orig_align
);
469 printf("NULL pointer returned from rte_malloc\n");
472 /* calc an alignment we don't already have */
473 while(RTE_PTR_ALIGN(ptr7
, new_align
) == ptr7
)
475 char *ptr8
= rte_realloc(ptr7
, size7
, new_align
);
477 printf("NULL pointer returned from rte_realloc\n");
481 if (RTE_PTR_ALIGN(ptr8
, new_align
) != ptr8
){
482 printf("Failure to re-align data\n");
488 /* test behaviour when there is a free block after current one,
489 * but its not big enough
491 unsigned size9
= 1024, size10
= 1024;
492 unsigned size11
= size9
+ size10
+ 256;
493 char *ptr9
= rte_malloc(NULL
, size9
, RTE_CACHE_LINE_SIZE
);
495 printf("NULL pointer returned from rte_malloc\n");
498 char *ptr10
= rte_malloc(NULL
, size10
, RTE_CACHE_LINE_SIZE
);
500 printf("NULL pointer returned from rte_malloc\n");
504 char *ptr11
= rte_realloc(ptr10
, size11
, RTE_CACHE_LINE_SIZE
);
506 printf("NULL pointer returned from rte_realloc\n");
511 printf("Error, unexpected that realloc has not created new buffer\n");
517 /* check we don't crash if we pass null to realloc
518 * We should get a malloc of the size requested*/
519 const size_t size12
= 1024;
521 char *ptr12
= rte_realloc(NULL
, size12
, RTE_CACHE_LINE_SIZE
);
523 printf("NULL pointer returned from rte_realloc\n");
526 if (rte_malloc_validate(ptr12
, &size12_check
) < 0 ||
527 size12_check
!= size12
){
536 test_random_alloc_free(void *_
__attribute__((unused
)))
539 struct mem_list
*next
;
545 rte_srand((unsigned)rte_rdtsc());
547 for (i
= 0; i
< N
; i
++){
548 unsigned free_mem
= 0;
549 size_t allocated_size
;
551 const unsigned mem_size
= sizeof(struct mem_list
) + \
552 rte_rand() % (64 * 1024);
553 const unsigned align
= 1 << (rte_rand() % 12); /* up to 4k alignment */
554 struct mem_list
*entry
= rte_malloc(NULL
,
558 if (RTE_PTR_ALIGN(entry
, align
)!= entry
)
560 if (rte_malloc_validate(entry
, &allocated_size
) == -1
561 || allocated_size
< mem_size
)
563 memset(entry
->data
, rte_lcore_id(),
564 mem_size
- sizeof(*entry
));
565 entry
->next
= list_head
;
566 if (rte_malloc_validate(entry
, NULL
) == -1)
571 /* switch to freeing the memory with a 20% probability */
572 free_mem
= ((rte_rand() % 10) >= 8);
575 struct mem_list
*entry
= list_head
;
576 list_head
= list_head
->next
;
580 printf("Lcore %u allocated/freed %u blocks\n", rte_lcore_id(), count
);
584 #define err_return() do { \
585 printf("%s: %d - Error\n", __func__, __LINE__); \
590 test_rte_malloc_validate(void)
592 const size_t request_size
= 1024;
593 size_t allocated_size
;
594 char *data_ptr
= rte_malloc(NULL
, request_size
, RTE_CACHE_LINE_SIZE
);
595 #ifdef RTE_MALLOC_DEBUG
597 char *over_write_vals
= NULL
;
600 if (data_ptr
== NULL
) {
601 printf("%s: %d - Allocation error\n", __func__
, __LINE__
);
605 /* check that a null input returns -1 */
606 if (rte_malloc_validate(NULL
, NULL
) != -1)
609 /* check that we get ok on a valid pointer */
610 if (rte_malloc_validate(data_ptr
, &allocated_size
) < 0)
613 /* check that the returned size is ok */
614 if (allocated_size
< request_size
)
617 #ifdef RTE_MALLOC_DEBUG
619 /****** change the header to be bad */
621 over_write_vals
= (char *)((uintptr_t)data_ptr
- sizeof(save_buf
));
622 /* first save the data as a backup before overwriting it */
623 memcpy(save_buf
, over_write_vals
, sizeof(save_buf
));
624 memset(over_write_vals
, 1, sizeof(save_buf
));
625 /* then run validate */
626 retval
= rte_malloc_validate(data_ptr
, NULL
);
627 /* finally restore the data again */
628 memcpy(over_write_vals
, save_buf
, sizeof(save_buf
));
629 /* check we previously had an error */
633 /* check all ok again */
634 if (rte_malloc_validate(data_ptr
, &allocated_size
) < 0)
637 /**** change the trailer to be bad */
638 over_write_vals
= (char *)((uintptr_t)data_ptr
+ allocated_size
);
639 /* first save the data as a backup before overwriting it */
640 memcpy(save_buf
, over_write_vals
, sizeof(save_buf
));
641 memset(over_write_vals
, 1, sizeof(save_buf
));
642 /* then run validate */
643 retval
= rte_malloc_validate(data_ptr
, NULL
);
644 /* finally restore the data again */
645 memcpy(over_write_vals
, save_buf
, sizeof(save_buf
));
649 /* check all ok again */
650 if (rte_malloc_validate(data_ptr
, &allocated_size
) < 0)
664 test_zero_aligned_alloc(void)
666 char *p1
= rte_malloc(NULL
,1024, 0);
669 if (!rte_is_aligned(p1
, RTE_CACHE_LINE_SIZE
))
676 if (p1
) rte_free(p1
);
681 test_malloc_bad_params(void)
683 const char *type
= NULL
;
685 unsigned align
= RTE_CACHE_LINE_SIZE
;
687 /* rte_malloc expected to return null with inappropriate size */
688 char *bad_ptr
= rte_malloc(type
, size
, align
);
692 /* rte_malloc expected to return null with inappropriate alignment */
696 bad_ptr
= rte_malloc(type
, size
, align
);
703 /* clean up pointer */
710 check_socket_mem(const struct rte_memseg_list
*msl
, void *arg
)
712 int32_t *socket
= arg
;
714 return *socket
== msl
->socket_id
;
717 /* Check if memory is available on a specific socket */
719 is_mem_on_socket(int32_t socket
)
721 return rte_memseg_list_walk(check_socket_mem
, &socket
);
726 * Find what socket a memory address is on. Only works for addresses within
727 * memsegs, not heap or stack...
730 addr_to_socket(void * addr
)
732 const struct rte_memseg
*ms
= rte_mem_virt2memseg(addr
, NULL
);
733 return ms
== NULL
? -1 : ms
->socket_id
;
737 /* Test using rte_[c|m|zm]alloc_socket() on a specific socket */
739 test_alloc_single_socket(int32_t socket
)
741 const char *type
= NULL
;
742 const size_t size
= 10;
743 const unsigned align
= 0;
745 int32_t desired_socket
= (socket
== SOCKET_ID_ANY
) ?
746 (int32_t)rte_socket_id() : socket
;
748 /* Test rte_calloc_socket() */
749 mem
= rte_calloc_socket(type
, size
, sizeof(char), align
, socket
);
752 if (addr_to_socket(mem
) != desired_socket
) {
758 /* Test rte_malloc_socket() */
759 mem
= rte_malloc_socket(type
, size
, align
, socket
);
762 if (addr_to_socket(mem
) != desired_socket
) {
767 /* Test rte_zmalloc_socket() */
768 mem
= rte_zmalloc_socket(type
, size
, align
, socket
);
771 if (addr_to_socket(mem
) != desired_socket
) {
781 test_alloc_socket(void)
783 unsigned socket_count
= 0;
786 if (test_alloc_single_socket(SOCKET_ID_ANY
) < 0)
789 for (i
= 0; i
< RTE_MAX_NUMA_NODES
; i
++) {
790 if (is_mem_on_socket(i
)) {
792 if (test_alloc_single_socket(i
) < 0) {
793 printf("Fail: rte_malloc_socket(..., %u) did not succeed\n",
799 if (test_alloc_single_socket(i
) == 0) {
800 printf("Fail: rte_malloc_socket(..., %u) succeeded\n",
807 /* Print warnign if only a single socket, but don't fail the test */
808 if (socket_count
< 2) {
809 printf("WARNING: alloc_socket test needs memory on multiple sockets!\n");
821 if (test_str_to_size() < 0){
822 printf("test_str_to_size() failed\n");
825 else printf("test_str_to_size() passed\n");
827 if (test_zero_aligned_alloc() < 0){
828 printf("test_zero_aligned_alloc() failed\n");
831 else printf("test_zero_aligned_alloc() passed\n");
833 if (test_malloc_bad_params() < 0){
834 printf("test_malloc_bad_params() failed\n");
837 else printf("test_malloc_bad_params() passed\n");
839 if (test_realloc() < 0){
840 printf("test_realloc() failed\n");
843 else printf("test_realloc() passed\n");
845 /*----------------------------*/
846 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
847 rte_eal_remote_launch(test_align_overlap_per_lcore
, NULL
, lcore_id
);
850 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
851 if (rte_eal_wait_lcore(lcore_id
) < 0)
855 printf("test_align_overlap_per_lcore() failed\n");
858 else printf("test_align_overlap_per_lcore() passed\n");
860 /*----------------------------*/
861 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
862 rte_eal_remote_launch(test_reordered_free_per_lcore
, NULL
, lcore_id
);
865 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
866 if (rte_eal_wait_lcore(lcore_id
) < 0)
870 printf("test_reordered_free_per_lcore() failed\n");
873 else printf("test_reordered_free_per_lcore() passed\n");
875 /*----------------------------*/
876 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
877 rte_eal_remote_launch(test_random_alloc_free
, NULL
, lcore_id
);
880 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
881 if (rte_eal_wait_lcore(lcore_id
) < 0)
885 printf("test_random_alloc_free() failed\n");
888 else printf("test_random_alloc_free() passed\n");
890 /*----------------------------*/
891 ret
= test_rte_malloc_type_limits();
893 printf("test_rte_malloc_type_limits() failed\n");
896 /* TODO: uncomment following line once type limits are valid */
897 /*else printf("test_rte_malloc_type_limits() passed\n");*/
899 /*----------------------------*/
900 ret
= test_rte_malloc_validate();
902 printf("test_rte_malloc_validate() failed\n");
905 else printf("test_rte_malloc_validate() passed\n");
907 ret
= test_alloc_socket();
909 printf("test_alloc_socket() failed\n");
912 else printf("test_alloc_socket() passed\n");
914 ret
= test_multi_alloc_statistics();
916 printf("test_multi_alloc_statistics() failed\n");
920 printf("test_multi_alloc_statistics() passed\n");
925 REGISTER_TEST_COMMAND(malloc_autotest
, test_malloc
);