kiper220/mimalloc
1
0
Fork 0
mirror of https://github.com/microsoft/mimalloc.git synced 2025-05-06 15:29:31 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

various fixes for test pipeline

Browse source
This commit is contained in:
Daan 2024-12-09 15:39:15 -08:00
parent 351cb0c740
commit 8f5449d271
4 changed files with 7 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/alloc-aligned.c
View file

@ -29,7 +29,7 @@ static mi_decl_restrict void* mi_heap_malloc_guarded_aligned(mi_heap_t* heap, si
mi_assert_internal(alignment > 0 && alignment < MI_BLOCK_ALIGNMENT_MAX); mi_assert_internal(alignment > 0 && alignment < MI_BLOCK_ALIGNMENT_MAX);
const size_t oversize = size + alignment - 1; const size_t oversize = size + alignment - 1;
void* base = _mi_heap_malloc_guarded(heap, oversize, zero); void* base = _mi_heap_malloc_guarded(heap, oversize, zero);
void* p = mi_align_up_ptr(base, alignment); void* p = _mi_align_up_ptr(base, alignment);
mi_track_align(base, p, (uint8_t*)p - (uint8_t*)base, size); mi_track_align(base, p, (uint8_t*)p - (uint8_t*)base, size);
mi_assert_internal(mi_usable_size(p) >= size); mi_assert_internal(mi_usable_size(p) >= size);
mi_assert_internal(_mi_is_aligned(p, alignment)); mi_assert_internal(_mi_is_aligned(p, alignment));
@ -175,7 +175,7 @@ static void* mi_heap_malloc_zero_aligned_at(mi_heap_t* const heap, const size_t
} }
#if MI_GUARDED #if MI_GUARDED
if (offset==0 && alignment < MI_BLOCK_ALIGNMENT_MAX && mi_heap_malloc_use_guarded(heap,size)) { if (offset==0 && alignment < MI_PAGE_MAX_OVERALLOC_ALIGN && mi_heap_malloc_use_guarded(heap,size)) {
return mi_heap_malloc_guarded_aligned(heap, size, alignment, zero); return mi_heap_malloc_guarded_aligned(heap, size, alignment, zero);
} }
#endif #endif

7
src/alloc.c
View file

@ -619,7 +619,6 @@ static void* mi_block_ptr_set_guarded(mi_block_t* block, size_t obj_size) {
block->next = MI_BLOCK_TAG_GUARDED; block->next = MI_BLOCK_TAG_GUARDED;
// set guard page at the end of the block // set guard page at the end of the block
mi_segment_t* const segment = _mi_page_segment(page);
const size_t block_size = mi_page_block_size(page); // must use `block_size` to match `mi_free_local` const size_t block_size = mi_page_block_size(page); // must use `block_size` to match `mi_free_local`
const size_t os_page_size = _mi_os_page_size(); const size_t os_page_size = _mi_os_page_size();
mi_assert_internal(block_size >= obj_size + os_page_size + sizeof(mi_block_t)); mi_assert_internal(block_size >= obj_size + os_page_size + sizeof(mi_block_t));
@ -630,7 +629,7 @@ static void* mi_block_ptr_set_guarded(mi_block_t* block, size_t obj_size) {
} }
uint8_t* guard_page = (uint8_t*)block + block_size - os_page_size; uint8_t* guard_page = (uint8_t*)block + block_size - os_page_size;
mi_assert_internal(_mi_is_aligned(guard_page, os_page_size)); mi_assert_internal(_mi_is_aligned(guard_page, os_page_size));
if (segment->allow_decommit && _mi_is_aligned(guard_page, os_page_size)) { if (!page->memid.is_pinned && _mi_is_aligned(guard_page, os_page_size)) {
_mi_os_protect(guard_page, os_page_size); _mi_os_protect(guard_page, os_page_size);
} }
else { else {
@ -640,9 +639,9 @@ static void* mi_block_ptr_set_guarded(mi_block_t* block, size_t obj_size) {
// align pointer just in front of the guard page // align pointer just in front of the guard page
size_t offset = block_size - os_page_size - obj_size; size_t offset = block_size - os_page_size - obj_size;
mi_assert_internal(offset > sizeof(mi_block_t)); mi_assert_internal(offset > sizeof(mi_block_t));
if (offset > MI_BLOCK_ALIGNMENT_MAX) { if (offset > MI_PAGE_MAX_OVERALLOC_ALIGN) {
// give up to place it right in front of the guard page if the offset is too large for unalignment // give up to place it right in front of the guard page if the offset is too large for unalignment
offset = MI_BLOCK_ALIGNMENT_MAX; offset = MI_PAGE_MAX_OVERALLOC_ALIGN;
} }
void* p = (uint8_t*)block + offset; void* p = (uint8_t*)block + offset;
mi_track_align(block, p, offset, obj_size); mi_track_align(block, p, offset, obj_size);

2
src/free.c
View file

@ -519,7 +519,7 @@ static void mi_block_unguard(mi_page_t* page, mi_block_t* block, void* p) {
const size_t bsize = mi_page_block_size(page); const size_t bsize = mi_page_block_size(page);
const size_t psize = _mi_os_page_size(); const size_t psize = _mi_os_page_size();
mi_assert_internal(bsize > psize); mi_assert_internal(bsize > psize);
mi_assert_internal(_mi_page_segment(page)->allow_decommit); mi_assert_internal(!page->memid.is_pinned);
void* gpage = (uint8_t*)block + bsize - psize; void* gpage = (uint8_t*)block + bsize - psize;
mi_assert_internal(_mi_is_aligned(gpage, psize)); mi_assert_internal(_mi_is_aligned(gpage, psize));
_mi_os_unprotect(gpage, psize); _mi_os_unprotect(gpage, psize);

2
src/page.c
View file

@ -756,7 +756,7 @@ static inline mi_page_t* mi_find_free_page(mi_heap_t* heap, size_t size) {
if (page != NULL) { if (page != NULL) {
#if (MI_SECURE>=3) // in secure mode, we extend half the time to increase randomness #if (MI_SECURE>=3) // in secure mode, we extend half the time to increase randomness
if (page->capacity < page->reserved && ((_mi_heap_random_next(heap) & 1) == 1)) { if (page->capacity < page->reserved && ((_mi_heap_random_next(heap) & 1) == 1)) {
mi_page_extend_free(heap, page, heap->tld); mi_page_extend_free(heap, page);
mi_assert_internal(mi_page_immediate_available(page)); mi_assert_internal(mi_page_immediate_available(page));
} }
else else