Skip to content

Commit c47348c

Browse files
ldorauldorau
committed
Make coarse_alloc() return aligned address when alignment==0
Make coarse_alloc() always return address aligned to coarse->page_size when alignment==0. Signed-off-by: Lukasz Dorau <[email protected]>
1 parent 2fca364 commit c47348c

File tree

2 files changed

+67
-19
lines changed

2 files changed

+67
-19
lines changed

‎src/coarse/coarse.c‎

Lines changed: 25 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -744,12 +744,18 @@ static block_t *find_free_block(struct ravl *free_blocks, size_t size,
744744
size_t alignment,
745745
coarse_strategy_t allocation_strategy) {
746746
block_t *block;
747+
size_t new_size = size + alignment;
747748

748749
switch (allocation_strategy) {
749750
case UMF_COARSE_MEMORY_STRATEGY_FASTEST:
750751
// Always allocate a free block of the (size + alignment) size
751752
// and later cut out the properly aligned part leaving two remaining parts.
752-
return free_blocks_rm_ge(free_blocks, size + alignment, 0,
753+
if (new_size < size) {
754+
// arithmetic overflow
755+
return NULL;
756+
}
757+
758+
return free_blocks_rm_ge(free_blocks, new_size, 0,
753759
CHECK_ONLY_THE_FIRST_BLOCK);
754760

755761
case UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE:
@@ -760,8 +766,13 @@ static block_t *find_free_block(struct ravl *free_blocks, size_t size,
760766
return block;
761767
}
762768

769+
if (new_size < size) {
770+
// arithmetic overflow
771+
return NULL;
772+
}
773+
763774
// If not, use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
764-
return free_blocks_rm_ge(free_blocks, size + alignment, 0,
775+
return free_blocks_rm_ge(free_blocks, new_size, 0,
765776
CHECK_ONLY_THE_FIRST_BLOCK);
766777

767778
case UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE:
@@ -773,9 +784,14 @@ static block_t *find_free_block(struct ravl *free_blocks, size_t size,
773784
return block;
774785
}
775786

787+
if (new_size < size) {
788+
// arithmetic overflow
789+
return NULL;
790+
}
791+
776792
// If none of them had the correct alignment,
777793
// use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
778-
return free_blocks_rm_ge(free_blocks, size + alignment, 0,
794+
return free_blocks_rm_ge(free_blocks, new_size, 0,
779795
CHECK_ONLY_THE_FIRST_BLOCK);
780796
}
781797

@@ -1017,16 +1033,16 @@ umf_result_t coarse_alloc(coarse_t *coarse, size_t size, size_t alignment,
10171033
}
10181034

10191035
// alignment must be a power of two and a multiple or a divider of the page size
1020-
if (alignment &&
1021-
((alignment & (alignment - 1)) || ((alignment % coarse->page_size) &&
1022-
(coarse->page_size % alignment)))) {
1036+
if (alignment == 0) {
1037+
alignment = coarse->page_size;
1038+
} else if ((alignment & (alignment - 1)) ||
1039+
((alignment % coarse->page_size) &&
1040+
(coarse->page_size % alignment))) {
10231041
LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple or a "
10241042
"divider of the page size (%zu))",
10251043
alignment, coarse->page_size);
10261044
return UMF_RESULT_ERROR_INVALID_ALIGNMENT;
1027-
}
1028-
1029-
if (IS_NOT_ALIGNED(alignment, coarse->page_size)) {
1045+
} else if (IS_NOT_ALIGNED(alignment, coarse->page_size)) {
10301046
alignment = ALIGN_UP(alignment, coarse->page_size);
10311047
}
10321048

‎test/coarse_lib.cpp‎

Lines changed: 42 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -166,9 +166,10 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_provider) {
166166

167167
TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_fixed_memory) {
168168
// preallocate some memory and initialize the vector with zeros
169-
const size_t buff_size = 20 * MB;
169+
const size_t buff_size = 20 * MB + coarse_params.page_size;
170170
std::vector<char> buffer(buff_size, 0);
171-
void *buf = (void *)buffer.data();
171+
void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
172+
coarse_params.page_size);
172173
ASSERT_NE(buf, nullptr);
173174

174175
coarse_params.cb.alloc = NULL;
@@ -206,9 +207,10 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_fixed_memory) {
206207

207208
TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_various) {
208209
// preallocate some memory and initialize the vector with zeros
209-
const size_t buff_size = 20 * MB;
210+
const size_t buff_size = 20 * MB + coarse_params.page_size;
210211
std::vector<char> buffer(buff_size, 0);
211-
void *buf = (void *)buffer.data();
212+
void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
213+
coarse_params.page_size);
212214
ASSERT_NE(buf, nullptr);
213215

214216
coarse_params.cb.alloc = NULL;
@@ -627,6 +629,15 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_free_cb_fails) {
627629
}
628630

629631
TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_cb_fails) {
632+
if (coarse_params.allocation_strategy ==
633+
UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
634+
// This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
635+
// and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
636+
// because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
637+
// looks always for a block of size greater by the page size.
638+
return;
639+
}
640+
630641
umf_memory_provider_handle_t malloc_memory_provider;
631642
umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
632643
&malloc_memory_provider);
@@ -702,9 +713,10 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_cb_fails) {
702713

703714
TEST_P(CoarseWithMemoryStrategyTest, coarseTest_merge_cb_fails) {
704715
// preallocate some memory and initialize the vector with zeros
705-
const size_t buff_size = 10 * MB;
716+
const size_t buff_size = 10 * MB + coarse_params.page_size;
706717
std::vector<char> buffer(buff_size, 0);
707-
void *buf = (void *)buffer.data();
718+
void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
719+
coarse_params.page_size);
708720
ASSERT_NE(buf, nullptr);
709721

710722
coarse_params.cb.alloc = NULL;
@@ -901,6 +913,15 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_provider_alloc_not_set) {
901913
}
902914

903915
TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
916+
if (coarse_params.allocation_strategy ==
917+
UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
918+
// This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
919+
// and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
920+
// because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
921+
// looks always for a block of size greater by the page size.
922+
return;
923+
}
924+
904925
umf_memory_provider_handle_t malloc_memory_provider;
905926
umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
906927
&malloc_memory_provider);
@@ -1065,6 +1086,15 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
10651086
}
10661087

10671088
TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple1) {
1089+
if (coarse_params.allocation_strategy ==
1090+
UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
1091+
// This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
1092+
// and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
1093+
// because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
1094+
// looks always for a block of size greater by the page size.
1095+
return;
1096+
}
1097+
10681098
umf_memory_provider_handle_t malloc_memory_provider;
10691099
umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
10701100
&malloc_memory_provider);
@@ -1106,8 +1136,9 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple1) {
11061136
ASSERT_NE(t[i], nullptr);
11071137
}
11081138

1109-
if (max_alloc_size == 0) {
1110-
max_alloc_size = coarse_get_stats(ch).alloc_size;
1139+
size_t alloc_size = coarse_get_stats(ch).alloc_size;
1140+
if (alloc_size > max_alloc_size) {
1141+
max_alloc_size = alloc_size;
11111142
}
11121143

11131144
for (int i = 0; i < nptrs; i++) {
@@ -1253,9 +1284,10 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_provider) {
12531284

12541285
TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_fixed_memory) {
12551286
// preallocate some memory and initialize the vector with zeros
1256-
const size_t alloc_size = 40 * MB;
1287+
const size_t alloc_size = 40 * MB + coarse_params.page_size;
12571288
std::vector<char> buffer(alloc_size, 0);
1258-
void *buf = (void *)buffer.data();
1289+
void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
1290+
coarse_params.page_size);
12591291
ASSERT_NE(buf, nullptr);
12601292

12611293
coarse_params.cb.alloc = NULL;

0 commit comments

Comments
 (0)