You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
e6f54c17c4
This version of mimalloc is very efficient at distributing threaded allocations in a way that maintains
locality which in turn improve the amount of memory that we're able to send back to the system
after heavily multithreaded workloads. This also improves performance as less page fault and cache misses
are expected coming from more densily packed allocations.
mimalloc v1 seemed to waste more memory because of its commit size being larger than TBB.
However, its allocation patterns was already way tigther than TBB but for it to become apparent, you had
to activate the "page_reset" and "reset_decommits" options, which came at a performance loss.
mimalloc v2 offers both better locality and by default will more agressively decommit memory with
only minor performance loss in some cases and performance gain in many.
Given the advantages of mimalloc v2 compared to Intel TBB, we should probably consider it
as our next default allocator for the editor.
- All tests performed on AMD TR 3970X with 256GB RAM
- Loading FramingCameraTest map on special project with -ddc=cold and waiting until every asset is built
- 699s @ 32GB for tbb malloc
- 655s @ 37GB for mimalloc v1
- 757s @ 12GB for mimalloc v1 + page_reset and reset_decommits
- 604s @ 15GB for mimalloc v2
- Loading P_World on Reverb -ddc=cold and waiting until every asset is built
- 2372s @ 71GB for tbb malloc
- 2587s @ 75GB for mimalloc v1
- 3212s @ 34GB for mimalloc v1 + page_reset and reset_decommits
- 2503s @ 37GB for mimalloc v2
- Loading P_Construct_WP on special project with -ddc=cold and waiting until every asset is built
- 6404s @ 56GB for tbb malloc
- 6640s @ 37GB for mimalloc v2
- Loading Apollo_Terrain on FortniteGame with -ddc=cold and waiting until every asset is built
- 751s @ 33GB for tbb malloc
- 744s @ 25GB for mimalloc v2
- Cooking FramingCameraTest map on special project with a warmed-up DDC
- 379s @ 34GB for tbb malloc
- 367s @ 29GB for mimalloc v2
#rb Brandon.Dawson, Yuriy.ODonnell, Stefan.Boberg
[CL 15859558 by danny couture in ue5-main branch]
67 lines
3.0 KiB
C
67 lines
3.0 KiB
C
/* ----------------------------------------------------------------------------
|
|
Copyright (c) 2018,2019 Microsoft Research, Daan Leijen
|
|
This is free software; you can redistribute it and/or modify it under the
|
|
terms of the MIT license. A copy of the license can be found in the file
|
|
"LICENSE" at the root of this distribution.
|
|
-----------------------------------------------------------------------------*/
|
|
#pragma once
|
|
#ifndef MIMALLOC_OVERRIDE_H
|
|
#define MIMALLOC_OVERRIDE_H
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
This header can be used to statically redirect malloc/free and new/delete
|
|
to the mimalloc variants. This can be useful if one can include this file on
|
|
each source file in a project (but be careful when using external code to
|
|
not accidentally mix pointers from different allocators).
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
#include <mimalloc.h>
|
|
|
|
// Standard C allocation
|
|
#define malloc(n) mi_malloc(n)
|
|
#define calloc(n,c) mi_calloc(n,c)
|
|
#define realloc(p,n) mi_realloc(p,n)
|
|
#define free(p) mi_free(p)
|
|
|
|
#define strdup(s) mi_strdup(s)
|
|
#define strndup(s,n) mi_strndup(s,n)
|
|
#define realpath(f,n) mi_realpath(f,n)
|
|
|
|
// Microsoft extensions
|
|
#define _expand(p,n) mi_expand(p,n)
|
|
#define _msize(p) mi_usable_size(p)
|
|
#define _recalloc(p,n,c) mi_recalloc(p,n,c)
|
|
|
|
#define _strdup(s) mi_strdup(s)
|
|
#define _strndup(s,n) mi_strndup(s,n)
|
|
#define _wcsdup(s) (wchar_t*)mi_wcsdup((const unsigned short*)(s))
|
|
#define _mbsdup(s) mi_mbsdup(s)
|
|
#define _dupenv_s(b,n,v) mi_dupenv_s(b,n,v)
|
|
#define _wdupenv_s(b,n,v) mi_wdupenv_s((unsigned short*)(b),n,(const unsigned short*)(v))
|
|
|
|
// Various Posix and Unix variants
|
|
#define reallocf(p,n) mi_reallocf(p,n)
|
|
#define malloc_size(p) mi_usable_size(p)
|
|
#define malloc_usable_size(p) mi_usable_size(p)
|
|
#define cfree(p) mi_free(p)
|
|
|
|
#define valloc(n) mi_valloc(n)
|
|
#define pvalloc(n) mi_pvalloc(n)
|
|
#define reallocarray(p,s,n) mi_reallocarray(p,s,n)
|
|
#define memalign(a,n) mi_memalign(a,n)
|
|
#define aligned_alloc(a,n) mi_aligned_alloc(a,n)
|
|
#define posix_memalign(p,a,n) mi_posix_memalign(p,a,n)
|
|
#define _posix_memalign(p,a,n) mi_posix_memalign(p,a,n)
|
|
|
|
// Microsoft aligned variants
|
|
#define _aligned_malloc(n,a) mi_malloc_aligned(n,a)
|
|
#define _aligned_realloc(p,n,a) mi_realloc_aligned(p,n,a)
|
|
#define _aligned_recalloc(p,s,n,a) mi_aligned_recalloc(p,s,n,a)
|
|
#define _aligned_msize(p,a,o) mi_usable_size(p)
|
|
#define _aligned_free(p) mi_free(p)
|
|
#define _aligned_offset_malloc(n,a,o) mi_malloc_aligned_at(n,a,o)
|
|
#define _aligned_offset_realloc(p,n,a,o) mi_realloc_aligned_at(p,n,a,o)
|
|
#define _aligned_offset_recalloc(p,s,n,a,o) mi_recalloc_aligned_at(p,s,n,a,o)
|
|
|
|
#endif // MIMALLOC_OVERRIDE_H
|