From 4670506a224df2fda757aa561ad526d2d9998607 Mon Sep 17 00:00:00 2001 From: Adam Sawicki Date: Mon, 25 Nov 2019 12:46:57 +0100 Subject: [PATCH] Announce version 2.3.0-alpha.1 --- CHANGELOG.md | 32 + README.md | 3 + bin/VmaReplay_Release_vs2019.exe | Bin 238080 -> 238592 bytes bin/VulkanSample_Release_vs2019.exe | Bin 290304 -> 299520 bytes docs/html/allocation_annotation.html | 16 +- docs/html/choosing_memory_type.html | 16 +- docs/html/custom_memory_pools.html | 16 +- docs/html/defragmentation.html | 20 +- docs/html/functions.html | 3 + docs/html/functions_vars.html | 3 + docs/html/globals.html | 9 +- docs/html/globals_defs.html | 3 + docs/html/index.html | 2 +- docs/html/lost_allocations.html | 12 +- docs/html/memory_mapping.html | 22 +- docs/html/quick_start.html | 12 +- docs/html/search/all_11.js | 154 +- docs/html/search/classes_0.js | 36 +- docs/html/search/defines_0.js | 2 +- docs/html/search/defines_1.js | 11 +- docs/html/search/enums_0.js | 12 +- docs/html/search/enumvalues_0.js | 76 +- docs/html/search/files_0.js | 2 +- docs/html/search/functions_0.js | 94 +- docs/html/search/pages_0.js | 2 +- docs/html/search/pages_1.js | 6 +- docs/html/search/pages_2.js | 6 +- docs/html/search/pages_3.js | 2 +- docs/html/search/pages_4.js | 2 +- docs/html/search/pages_5.js | 2 +- docs/html/search/pages_6.js | 2 +- docs/html/search/pages_7.js | 4 +- docs/html/search/pages_8.js | 4 +- docs/html/search/pages_9.js | 4 +- docs/html/search/typedefs_0.js | 4 +- docs/html/search/typedefs_1.js | 50 +- docs/html/search/variables_0.js | 12 +- docs/html/search/variables_1.js | 12 +- docs/html/search/variables_2.js | 2 +- docs/html/search/variables_3.js | 6 +- docs/html/search/variables_4.js | 4 +- docs/html/search/variables_5.js | 2 +- docs/html/search/variables_6.js | 24 +- docs/html/search/variables_7.js | 2 +- docs/html/search/variables_8.js | 36 +- docs/html/search/variables_9.js | 2 +- docs/html/search/variables_a.js | 2 +- docs/html/search/variables_b.js | 2 +- docs/html/search/variables_c.js | 16 +- docs/html/search/variables_d.js | 35 +- ...uct_vma_allocator_create_info-members.html | 1 + .../struct_vma_allocator_create_info.html | 22 +- docs/html/vk__mem__alloc_8h.html | 24 +- docs/html/vk__mem__alloc_8h_source.html | 29256 ++++++++-------- docs/html/vk_khr_dedicated_allocation.html | 4 +- src/VmaReplay/VmaReplay.cpp | 4 +- src/VulkanSample.cpp | 4 +- src/vk_mem_alloc.h | 2 +- 58 files changed, 15133 insertions(+), 14985 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 823e3ee..ae69a64 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,35 @@ +# 2.3.0-alpha.1 (2019-11-25) + +Major release after a year of development in "master" branch and feature branches. Notable new features: supporting Vulkan 1.1, supporting query for memory budget. + +Major changes: + +- Added support for Vulkan 1.1. + - Added member `VmaAllocatorCreateInfo::vulkanApiVersion`. + - When Vulkan 1.1 is used, there is no need to enable VK_KHR_dedicated_allocation or VK_KHR_bind_memory2 extensions, as they are promoted to Vulkan itself. +- Added support for query for memory budget and staying withing the budget. + - Added function `vmaGetBudget`, structure `VmaBudget`. This can also serve as simple statistics, more efficient than `vmaCalculateStats`. + - By default the budget it is estimated based on memory heap sizes. It may be queried from the system using VK_EXT_memory_budget extension if you use `VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT` flag and `VmaAllocatorCreateInfo::instance` member. + - Added flag `VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT` that fails an allocation if it would exceed the budget. +- Added new memory usage options: + - `VMA_MEMORY_USAGE_CPU_COPY` for memory that is preferably not `DEVICE_LOCAL` but not guaranteed to be `HOST_VISIBLE` (mostly for NVIDIA). + - `VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED` for memory that is `LAZILY_ALLOCATED` (mostly for mobile GPUs). +- Added support for VK_KHR_bind_memory2 extension: + - Added `VMA_ALLOCATION_CREATE_DONT_BIND_BIT` flag that lets you create both buffer/image and allocation, but don't bind them together. + - Added flag `VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT`, functions `vmaBindBufferMemory2`, `vmaBindImageMemory2` that let you specify additional local offset and `pNext` pointer while binding. +- Added functions `vmaSetPoolName`, `vmaGetPoolName` that let you assign string names to custom pools. JSON dump file format and VmaDumpVis tool is updated to show these names. +- Defragmentation is legal only on buffers and images in `VK_IMAGE_TILING_LINEAR`. This is due to the way it is currently implemented in the library and the restrictions of the Vulkan specification. Clarified documentation in this regard. See discussion in #59. + +Minor changes: + +- Made `vmaResizeAllocation` function deprecated, always returning failure. +- Made changes in the internal algorithm for the choice of memory type. Be careful! You may now get a type that is not `HOST_VISIBLE` or `HOST_COHERENT` if it's not stated as always ensured by some `VMA_MEMORY_USAGE_*` flag. +- Extended VmaReplay application with more detailed statistics printed at the end. +- Added macros `VMA_CALL_PRE`, `VMA_CALL_POST` that let you decorate declarations of all library functions if you want to e.g. export/import them as dynamically linked library. +- Optimized `VmaAllocation` objects to be allocated out of an internal free-list allocator. This makes allocation and deallocation causing 0 dynamic CPU heap allocations on average. +- Updated recording CSV file format version to 1.8, to support new functions. +- Many additions and fixes in documentation. Many compatibility fixes for various compilers and platforms. Other internal bugfixes, optimizations, updates, refactoring... + # 2.2.0 (2018-12-13) Major release after many months of development in "master" branch and feature branches. Notable new features: defragmentation of GPU memory, buddy algorithm, convenience functions for sparse binding. diff --git a/README.md b/README.md index b704e88..030b517 100644 --- a/README.md +++ b/README.md @@ -41,10 +41,12 @@ Additional features: - Configuration: Fill optional members of CreateInfo structure to provide custom CPU memory allocator, pointers to Vulkan functions and other parameters. - Customization: Predefine appropriate macros to provide your own implementation of all external facilities used by the library, from assert, mutex, and atomic, to vector and linked list. - Support for memory mapping, reference-counted internally. Support for persistently mapped memory: Just allocate with appropriate flag and you get access to mapped pointer. +- Support for memory budget. VK_EXT_memory_budget extension is used internally if available to query for current usage and budget. If not available, it falls back to an estimation based on memory heap sizes. - Support for non-coherent memory. Functions that flush/invalidate memory. `nonCoherentAtomSize` is respected automatically. - Support for sparse binding and sparse residency: Convenience functions that allocate or free multiple memory pages at once. - Custom memory pools: Create a pool with desired parameters (e.g. fixed or limited maximum size) and allocate memory out of it. - Linear allocator: Create a pool with linear algorithm and use it for much faster allocations and deallocations in free-at-once, stack, double stack, or ring buffer fashion. +- Support for Vulkan 1.0 as well as 1.1. - Support for VK_KHR_dedicated_allocation extension: Just enable it and it will be used automatically by the library. - Defragmentation of GPU and CPU memory: Let the library move data around to free some memory blocks and make your allocations better compacted. - Lost allocations: Allocate memory with appropriate flags and let the library remove allocations that are not used for many frames to make room for new ones. @@ -94,6 +96,7 @@ See **[Documentation](https://gpuopen-librariesandsdks.github.io/VulkanMemoryAll # Software using this library +- **[Vulkan Samples](https://github.com/LunarG/VulkanSamples)** - official Khronos Vulkan samples. License: Apache-style. - **[Anvil](https://github.com/GPUOpen-LibrariesAndSDKs/Anvil)** - cross-platform framework for Vulkan. License: MIT. - **[Filament](https://github.com/google/filament)** - physically based rendering engine for Android, Windows, Linux and macOS, from Google. Apache License 2.0. - **[Flax Engine](https://flaxengine.com/)** diff --git a/bin/VmaReplay_Release_vs2019.exe b/bin/VmaReplay_Release_vs2019.exe index e144ae1ae1463de0aa807d990215a2072be0f6f4..afb21370e0ea9405947daf5a455c0586112a5e38 100644 GIT binary patch delta 66874 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 NBENatNI!z#`U7vk^tJ#1 delta 65942 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

*-yix8xL2uMdUfGswuWHTj0_P)=`eW_ z8ZDaaku}Ioz;ofq3juGedaR$&}{W;TiAsQTWg(rQt`|mzi&{ zsSUnjBJ?O(Ro38XI5)_cAEFhmr^2h{g~RDk!MY+3kro;U)%=ZR)f2tD(?RTwJ<)q4 zge3AmKkCU6dE~NC{2j8amT=31&s;X#-`MJ9dJi#+>T2D{ z)lMZeyCJ{=O5kh*(Zg6&p&`rt?J4DeJ2m7{2&99cX6Y1->lW0=q~)HFQpr-Lq@g3R z*)cN2Z~!u*HM}+;W+FpcU0rn*l~DSixD^V#hiL^1w1UcUi&H{^iv3a2(q1w~E2$c% z-(xdo-qIUiV@Hqtg*ohX>SwgujG5C?qC8uwjZ>HOxoIImx)jGMn8l88!mCuu^!fdDDXmdmJ(Zzx)w^8aVqqnvOxo5g<)YFb z#DuNO{xOH~tmSol^2zT;iD8Gu{1S)ktUT2v9u}i7^FzzK^>J0h*%X@3TSK{`%hb-+ zuHo=TQeOjlI@IR19>FAFQ7SA%gDn9J61wdmAC^T6aO9e5xmA4hiUxe;ijXuFo}EQ| zk?}v`4@TcnYD~THcy?Ae0II50GEO*aSsb5q2UNu948SJ7GflN#M(OA8c4G34-v_?{ zqpD&nD0csj()$T)^U4e)Sym7~y6Ji$1uKf|j&Y*IBUk#Rg(D!{hx?DVqD>%4$4v;@ zKRBU8ZKbP!2m`GP$Q6Mi2}uJEACMe-+$dtjLNhMBc6X^`NVaiMLiVIYw1cR5YB(Nh zoE~aen^FZ0_+SiT&G_TS&`^z1oyxj}WBkN{G(nU)ibzLcqQm^$5k}l6RO4~cpiW1g z;Bg*2qyps!%$eGBL@`A>bJ$H&{ws&hR?pkKwp_p7sQ`*LFuV|pAsU8v#(hpyfN9qh zc9c4rHv4$#lEcMd3j~-i+E4Gpy;A&A)S7vGo3bOSQcft+GoNHSSq z0AYOL>V|9<|7vxRX$Tq!0S!!}PaH97pm%R?pn-1CyLZMuCW0S8;`AQst|sOuWy#N2 z&SZ~@BVJ_ot`X;KUbfo2)+f=dC-3!1hZ)Hh095p=e8fEi(fRxQE$IH&;LtbfJWA_Fp7=XP>fjxPLb#quJ zeqdcNTf%Rw8&++622Gd!aq!kBPWhR4U+)>SZx-Ej&U<3gH#}}HQj|>qqJw_L!L8CN zo6>0PjCqOfqP_!CR<|ou;?LKw_e@hL>7XGgK+>s53XtwlNzr1Jl>k4h{6T36LlW^8 z<$u=l;m8M5{zv4cK2gXud^c^mzd~hL&~+GDN8;BlbsJ1k~v>FOu)G?x*b_RPsw#RAS~+H+fdNPRZt6+7yv? zk&-XK%yu|>sN*!c`Tm5YxdV{2g0_=HhZQBYumeR?ib6%Fs3=Q^TS)NcBec8o1kVLL zBi0dh3#n#|zMT|6S>0YynT#@k_GuuWApm6(C|J_sEZhbp*i;SegoYMDpdozdXJKi< zlx(b4F#j@DFcRDrYiKH^henyBfuafhb*5V9Dh(ynF80$>y7X$Ex#U$AMp5yP+IWp&jTv$rldRn>hp*OA(Z@Wft?VMj7o@KBE$~} zJqYDnUS(^5UnC`SfNeV#J=1YoHpM?88UL3Lc>AqQ*;+nrYgWTZ8RrAuV%Up_bF`+$ zWH|3%3>B+mQ}r6ZRMSH9mWwjy6%YENv+&4;Px>OlXZo*b#?q4sdW**Dc4GjlbL9KK zXeT^9$^ZSLx$oWcgk;}iOi~AsTW!Lc$vbZAhCQp5+Y;C^esxLlTv|EPm!ILt5Q; ziNc6z&wFGv*q@>hNh$dp4k;)j_W9ZJDynNjMB0VO0zrE0=u5De6cZ6qHOb1-WNPT8 znol8s+eR2H;vOtga029?T`41WV+F1_0wTc;Btr!M;OhV(LE+oJuEPTPnXjAqda9`Q z<{qgHOH&`9YPS- zmjn6Jor8s!w|TE`8V{Lx8%PU|tb!LEI{0w;p;AWd?9=7i?-r#CkaMUBbyvlNRQy>* z%x)DhxrXV~8<>SN`L%EAf$&~kq z%%6APW5SK3)%csuZ{cq{-ej*y_~$=9d#}ho;fL_ICwJM0*J^&|jrS!AcUSNo$Gq^~ z)TjGm(}v?PAU*c*&u9$kVT!-jbA9rZd!wl1`sCR=PZ=+hNgLPWjGbn&Pz#p(R;L)I zY7hTKK!cKS=IvIveB_;0Xlj94_8ITL-ylr?gTJ@G4(rO-?QiVcNhPp1L>sM- z=5_|fZ~V@FGi#U|@m)jajy+c+28xBk&f~TfWBH`->x~1jBaI#nxKi7Qy`O^nCufSQ zh=|v*Z`n;7?aKXOOqUQ9dksBW(OxT!c*|b1maAuvG_(w83))Fm9`RS-*B^HBifXm% z$!c+Vs-m4-$S+s=TiU_HOJQWTqbH$xHdVyjUIBBNnU3?^T0>cS8Lu_Z{Gm=-B&qHW zI+Vmy+7W4KrH&#Ft6LgD9wVxkRyt}BD?tiXh_eRSM36Iph|)@T4YZFy-)kUm4Rn-1 zv|<33K?9uwXpFK#gN16ayM(q-1BGj#R|J}(fub~!I$aFXKyezV9!(o24J2xyXacna zC?j?exBeKF){fff@dRi??JyNNF(VJHUOQdPzv(DCT$5@j=c%}tqrF@?qGp|u{eXyf zBP&Y1+>zf%`ORA18~I(7U!mo})9n!Dv$Q+~1XoN60HkUF3PB$e!YD0IF=$oNvyYaK zLq3@DMlCNQ--hy$eDQ(CX;VZb1uC-EKB&rWb$bsmO@*TIr7A2Uyen#!R9H{hQ^?v? z*hl&AwLGbCg7Vw7JgIPr@}FpVQsE)xrSZ15#DG+ACKcY(5J&|Bqn!z&%;uu7N;&#up}?{YB=U{YW;-4r~g{!)qHS+ z=*=q>U+*a&;PCBq{c>VF8lxQ|f3w6hjt2?iS-$0X3?`nN$0L1T?yk^!-)J#aIBqg1 z5^sKD7Td+QpJ>5;&MiFAi`6O2C0utpL!DNY?sbJ1^*}hN&C;jaf@loy`%~}ghWPaP z-a0y(qUE=`^#0+edaVrUX&My1&e>lmHAntQ2 z*yqx&H`F4(bqp?88OM8{GSq2`H$inNFgyemCOA^1UoW&%`Q)CgT;%ep2>iV-WH;&)HAW5;;?)6Hsr|4oHPnWRO$4_oocr=zHUPuGh{N~sCg zZS%T*mr;mcMLJ>gI*c?HWL>)}9;=A;B@xPLXeTP5t>IOE?v~bNKS>-&5+{-CSEi#S z?VYazmB$oZ+ZNICNkpWE^A$B*b83Dch%}`cBTlNJ>II6?kL-Wj5c=<|&|+HHu_ziX zc5fi~y5VfIbZJ=iB)|1@xJ&47;HwU+Gd%E2gm3a*wu5WV~{3#WQyM9|}dZ~5|HEQZ71V)84W^8dnx$+E^l2r!Yeb2Zs+?tQLT4<=HX zWpRRZf;LsP>ECUjLIdR@K@7zA>bGyVPxAH(?W39SwU$s1QO&s~f^dZYb*{Nfz`4>! zIl>#9kMiBMtwN*Rby9uJ-EdH~=kJ{#$nfg?`FNJVeSS^Ad%i<{?Z{5>&G-w?fxn29 zE_4*0T<7myFtRUs{)LXL4|l#eUbuISr(A5tD)TKD+Y2pr@Ou}#w3>|OR}G{O^uS)R zva%DI^pX%QdhVlByk_GP0|2znR&QVSS*#4>6Mq{j;9Z}ee+v{=pW+XGi}vZz9`S^v zn58FZ2r=vwwMjC@PcCnNDc1e|*EXBQI>TAac)$Q0%|E=29YZo=eK)_+Y!vtAQ3Gt})i1a5Km5B&fZI-|l;_yw#Q^J0Qz{17;vf0w%K>aG z&$=8H()Y6p?TFnc^q`y6kfIBm`_N6np+&#*8<*o)bZ+n!59U{85REf^<|YI=+ESwy zDy3Kiaq-o_v@ILUr5X!fl~G#UuVOfpSplP?7Whn4E2RDK@>(l(r8%xVRJK$g1Jvz7 zQ?1%-7Q!o~<@4^;;I^wxLhfv+pw|n{arlM4q1Qy-iS}L zp>)|sdem?7wjM1iVA%BtRx2o#MQgo1UEb8=zjft|NsqOSNhrsQ%F-@;>YYH|?OM~I z6)KK>BE^m;b;?gTa-ucJ(7^+X0{FUX9oQUx^I9j?oQGW(g`x{Q_4<>v7SN)2W<@29V$7_75u;rm9z}IY7ZfMc+hetJ1!R(b6W9^vRZ*SP?iPx{x7Ji> z`B|FqJ~+=PTR@@RZ**q)e9a9J8??7?m{=3u^v{yC)I?2qZ4F9G&?~Fo6n=UGP55$* zeHAbuJjH}tg03tiA%9nW{v@qAa$ z(oUJk?g!zL0yNYR-dLs_T2U@B=`;bR@up7eD`41lTB=s4>QsSmQDFR=I*nc-)GBK* zQmUV7cNdlCas0SapS~0GPzm>avYbS)tAzDBjfPM^c)ASUrl<@1E%*H*59)|j_xu~R zItg`J&rg~WLM~S7m?&LHkUGMzxSqff6<$=abx*P#M^SXwB!1(bXWHM`|4xtHinq;l zDbs0(nCAR&r67WQeAxy`xYBJDtf{9-+aNKKao$>1-ZHHtw&@W+WXRz-+|=$TF8FJ`islr{ zcNVwsZK^W2w+`BmT4$s;xF6)Ni+eE_-t(_sY%kyP*WI+5ACs0dD9X{aY}*X{%Y(CU zKEUF@9e4JW!f0)Pq37(khU->9w%;0-FnE+bz{I(q>jPim*j66; zAjwzyutJ}1tEx(!=LJ+hzVX3K){Fc8ox;xW5C3i{+-=H_|DA^K>2!M7f;HoFANFM* z@beG5U@su>QD@=FVLsteXK1(we+O~)xC`Qc%j4<7#3uaE<9`HWB;WsJwQw>lx6f07 zVV+O?XD+rsF8tHD(ofV(ySekT)-5{V{u-`z;L;P_0LwOd7pog-65T7a5!!$VZH~83 z`UOf+B2RtRIN+yNG^dx)0Yel{GQ4#uy-n6ZbZ+Hh^Rn=~XKh>;;&7KD2OPm%=ars^ z`MI>D?shh3PxUTZfq4`@NQ*40Cv)@jy27bQKK*(9*0bNYH$CoxHH931*22)MnGrjz z0-UaQ_(DD-ZJ@4LOgj(7&G`A}ZCq@a^l=z@R%yA8dzZw!3?yX-|vmy18BoK7ijYkB;OfXddUbZD`N zkABg@FgvqCKSpTQ_jOgcn~Wo&LkAZ*@b6y4vEjKdU$`-$_e5Ux<#)p3Px!HyVZDME zmK)YDT2w50LX6zTu&TU@PP1e|Ip&udW?x{EtRi`>?)J)N^MqG*5e|=k<GLfO6r2eGE?AAnWzxgrj#eM;Wp^!#$6;T%eJbXZpe71cvC;#GXdaI{Dhu@XJme)wD4k$p||b*Sp~U%pi=iP?#6B zVmNCTQi8R-`jsB9Y}gtZRpDo97?^d9R{7D_^ckmD9AyJpvK+)%Pv$SDFcx0zL@u36 zimh?uU!Qed-o;phejfowkVJjfHr$TMzw7Q&k{$aw%t$(37pI)ISb9N8pJhd1f`0Gu z_>7Xu`bFwZpV(LLp-oe3eTQg{yxe@U+K=jEqa=2W++1Mwg}uw=fdXrihBzEj8h0)* z*ldAxTVOP<_+bX(DAb%kN22~`<24)!lvwTv?k0oC!JH5O%XA?A2Vc6MO3Se9&XV4i7P{h+XQ zMY=D^Y~6=-y;2t;t65SBP^q7OPgZ}>E~WzpX+@GI)J|pHP~73nvgxzFpuGS(3r}br zyKIi2n_t^x?aNHj|Dg>U;>b6(G7>$IP-@qMtX_9^qDDF=zKw*u)qw>B+{9qRE#M>g zF~bvyW~;ve1p2^Cw3JT1?!c1MoCqh{sSmCVti^9()q*xXTe5929S zDGtZRYL1DnxoBz5E`pnI!P`ly`D7eUU!iuqi(<}p+JscmXmqU2EBR}C&rbQ8@p)@~^$z)_ zFw||qok5lndsvRI#2VIYM$wnGPmZ#xI#uYFN>VkF7gS=NmBvuIy8KBc7M0du2fUXu zB8TD4$B>y?yW?z$Hu>ri+Wug=n@{^zO)0w#*;4VVt*I~srhY_i@#hS3c-SdWUv5y} zQo{a}`j(RN7>;iOkxSOGG!Ag1qN6DHtjxlMgCELim6-u9V|`^7>l_FTPb>XDly6sN z^}`Fts8!O-i%JTb0M%cj5$LVKS5bNp;24b<*46#w7-!bH<)W{MNB&ZVi!aBEeIfsC zcg&nLN`62>sTE|i?W0i*aS9qh9IS~Wmde|mS%fgzS1xpBt%SNu{Dmz`ga1G=^4giB8sVl!YtBVbJ$(_M1%$BIP~7s8RhCzw3@@H#3ybKxSR$=Rg)@K`x3+n; zq;kk}ha%|9{&dX>BMd!6NM8_=r+Rj;mhUesS8q01N~i~a{Xnkj%7Q9CDtT=?t!$T@ zyRyb?o}A>$jI5Kq#g(;TU&=RJS)}8Pnl_vKQ8nfzH+5r`T@F!bt|o6VL2I)>}2yavO+TR9gEfaa2J{Cn^{($Q#m1~B0Hgu2xEojL=zCy zybO79wKCx_joOhjUZ`qSxtbB97mK zP<%H9gcir}PWa(-t>Yd8qU2{$qZsy6Fsk-gt#T5)v1li$F1Phytp$;g zYsontta4Cd8O2(cvP!T+Zm0P8nY<4qX-hYeMW4vjS}s|s2D{5B!Iuc$L&u8N*tR!b z+pr;>kfE@YYHGnm6clx)(u~-d6VR6Wto|x)A3)}Lt9PIKD0DddZ>_buq6eSBC*7doe>$8+wlnA(a6^7EFjf1e9?RiEO76a9c%RJIF)4 zSaY}EHUKT#DTiQVWLtICME?W6oRWzsuQ#xZnrnEj6M&cPWW^XR`b$1rgEb7h4O!#$ zdvti++HEIW>~s=_P=pf*T}-$>>jZwA=Ph>nmVj$jg2p-J1nziOc~4%p(>N*~Xs1b5 zX;gTRaq_7eEMBNSPOj$3YF7RiVN{XAxEt!lu$Tj=lp;Yws6f6|0bwI3kD5aiR za-rA61_w;6A0ktMUZd`aO`W*gV`DGqf4A_6N7|5lMm?wYY&HS4O2QpnMp51sJ;R!cj zvcyw}Cpw7fR^lnfGdY;){=`!pB;WI9-G$(Ja*Pjt3+Bp8eON7F43j_iVNt@ox$+Gk z<|i0FkzW(M(<8Z-FY6~fcu$@5g%zviY+p7^m}bxWtd^bpSb|W)p8xJ+d88jR3b}LS z?S7bem(P)Z@?-6UUUOuZ+W6Y-;o0&hwE_QZw)|afz(>rMUlRQMELrjg{M%XbHh=J& zJWH)Fzzd5z`l`xlyn`Q#?j8)opeeWqj9}Opxo!Y!6mV)Kxf`chSR3`r6OTLT$$0P& zFB%~&PYGZxgw~GoX8Lt;l&=P`X2E%{7(M}rTdf9VcNH?ZBO;FU+_Ha$DIi_6zKYx= zko9$0GXnrx?XA%9VZlEBvnY>O5rl}VqEr(n2xh6HvpMXL@&MkB2h|OicNpN(htH5- z1+qrYPnVNu)o#h?mo7q!OnIIG5!BXHd5?iL651@6ZyDG)L7%EM?jA0W4PqmOoD?nJ zipzI{*eJo>p5MDn9uv$0SxtFSFaolT(={~HGWkLab{`(=@qO z2x}vp%8`48K=57H*(_|aMSn$Ovn(92D`J>Gm?H2r`c%Z(A8jW?R{ID+b62>f*E7xPeZ8~VQCx|w6 zAU+{7tuHJpRwHg(N{p-YewBH-rr0@dUh2hkyIM@kjY_f;_4r`$4$=TyEEd^{QM`-Q+wjKWf23_ihejKeE7o z9}tH|@0W5gM%<^54u!^BEe2%+rh~?yKm1gs7rt|o|7yYf_kPoa{lWsT6cec{E@x|% zS0Ig27L1ZNgtN0k&LgerMYJC&sa1RLz157JW6oO;A=$hxrO5{(;4r!jmw$_32ZRX^ zR01|!E^fh|_^-#1RAQ5;!zxFd#5;)2BCe$aC|YyY?|m7`_OL+hD>xK<<6!O@nL_qZ zXWGgNhm{(J^1Pc~KJmTnALKA#H9FoxX82f?BF9?fYEi5Kv&d0VEJ;{3SY90kJ5Cua zABbW>9dXMOy}JlMmgtgHCydwP+BnXoaeH(Eb(qt1La|!h?cWRE0VuppAA(}UM1#7& znY>No-ss@diq~M2TV12Y{5y^$VVvlIZQY$)2J8y|1t{&j+iP(ExsB*flpY8U5 z($FP-X#9})L5G#e4=5nt`jfn+H5(+1A0#`rVT}!QP(y`(qGZBrB_~s=erJF&6!{O5 zd$eHz!hZwhsr38DK>4FKEXMiZ4eEwpX2}=8gALg05Y0Yd&bI3W^_ZzaSMNO>!|t+( z_P1yujknLtVMoo7lY{wc` zPNhaTrpRJDHcyz)S3cg31vl!{mvBqq8^Qc&XRB)~OW3i9bIRu71c$T4zJ%s1zZ@xh z#leH&NTzcf;;$59cj_=TM%G<9I}R(i4SnRF<5;9ig1w6yFG!Hx;?czka;tbYP*~er zULKDwp3__27taEnJ5VdTecnO7jzeI3u5Sl9ygjSyMrHP1Y|%lTGo07L`<+%U^^#Y% zX8{e`6LAW9F}v~4l+JcLLqGPO8hlu3b(>_Hn!opt_ROCNN0aux>cGZ02!jUi9o31= zaTKhb_ulBjnpI-o$TfPhI&6g8swWGrHVm6*rB^Td50fYLWPu(S1enHgq3&c#Wzkl5 zT$220Pgc8DuQSw2m$6&%>=51r`%WGCYdgpVJ=yujFKAxMX4)sl;(DoH7PC6tBxnT^ zvJYi#d%2(&<80{Ok-gazfz_6O?aLb5R*%A;?^^RJ`0lLB-a# z^5}jr9zS_`KQ_1CT)e{eCW%Z}97;)|h~!eN+%l163g;Z;9}-zzVY`ETGZB7qv4dQx zKZ|c^bYQyugQnpo=xCFKH>6I9(t8Nv`w2>zS~40X=C?{b9OQZZnRo5y0@0=b10V2v zgZ2+W{-!@$B6Jhvb^{PG)feP316aDSnaM>1SS#0wjO6U%tl#VOvD|1N8}4qPmo;(L zb%tL3j+*8zuN}xj-4kgyV5U30TQoc&D%D%QIFNO$PEZ_|k{>#OuS_XcQEoDb?Qw&7 zm-gj_zVf3%%-0U;LpN)_?kjr_W_9b+RU(6WsXo;qdrC6#rZ~aowX_2L@V@fM!K^)& zDW4B!_1zA`?HZPCht+PGeRSti*G`Ct;N-~Lj*nZ)8;$Ca1(%1wu%B>JV?YZ$^IYYTb7FxEr(?qB)W zVJt)lvB_sfvJg37IIH105dX)A2&aU)JmuKoAZz@uJZv~?)rCVV?eq0sa9T$a@X1A`wh;fke$a8tK)C$rI95kE{a8LUj>WoK z%S#r@F5^)$(t5M{-|4|vcrSf$m`rwi5IDtjGTFOh7 z$z3L(B;b*pJOO^@*+Y5N1jse?ANk+}He2ZZP;N63_aXz2L2{J|uYPkAEmn8aGSZFx{e`ErN+WD*3O`9Q8U89Kz2 z7tMQL9z2-^ySv#zn5Yr_9G@qDIGF_s*Y3+ZCu3Iq;=X))GOOpd;C>m;*I&urQ^2$5 zeK}?d0(-Cf^6V)PC-ss1#S|9hyZtW>mHx{V7}8*q-H_@$l3z|i2hI3P_D*JDL6;xu z%3~9HtKFGCj%L780Mn4w$#T z)Wp*bPj5U=u>d%MhZYfg@f^ZKFg^DCA7D}PJDxjusv=LY19&##$-%Q4&we}ya`raK zWTRNMMp$`^bUfK*mh#o_dpBgE$%LFM@_|KcVO`fN&^G$z^Z*gJk+30=|0nKZ_jRUw z&FVo&XLn^#ZF$sU_OjYgIuN7xcEG3bk~}#ZUU0xld3iSCo-p}9HVX@Es5Y%rZLEvS z8#LYCprc*)I)A{{)L?z&&7ZPtXWACGI-Te(w_MBOS#NpPTDFn(lKs}PcG&S9xQ-2I zw4LdC;EBZ};u(u)GM)^O{)pe<_??Jn4xS9!@UOA=={gq7^gUkNq$LYx(UGOq>2eRb z?gn;>^^hNJU_)50+gPcnJ1*7t?*dlj)Y?`2-^zvCS)A~DF8zA#ZS^JF$6VcZ(J6z7 zgKLLf^2@K-R-ykl^5(DE5aGp6*=Yw$bQ`X^%8P`ue5X8q2m47lu|saT6T2r%cgV>* z*&^YOWckHTW(h=yL)L$AioLUrk@bhtst49z<+eQP8!VuNy-~YZw!jX^hrVUAgmZ;^ zV|F9dX8+04_M*N1+q-u!TguqWy&d;sJBhuJGrngb?8V-#-!rqo405xB%v*LlzxW%B{n)Gh25))Hf>+&ae~FFwE;cdI~d zrjVWfC#K_eBK&yc8bCf?KXV5=R|K|NIT)fW6i>Ll+<`+QD^O4-`5HlE@Z7V}j6W&8F4faM< zz-skK?tT~zvEvZ)Yn?>zst*)xh^D$C@#M~p=&%U!iAoLS?T(4eL*Ig+z(vQ?O&F_ZVYL)_Y`;6N}#uZZOF{$;v7$4Zxo6?a*fFy9S>OJg8A6RUOG9yEXmC1x6e`&$g~vZTCZzfxpiUB_JB3cyTcUrR?qtcj zD(4?%VeA+A{!!L4Z7>dT;(w$Y73SzM-ugu%^7xWy6=SANpZO!kXne+LAi zse{oY`b=DIhAf@X?7c6cn~XWMA1)?fpCwMp@)6OmG2yFKR1-Q#hi!$C`apYyo)63F!`@IF zVgFxMY6tgaRbs7qRvAN8Viyy;0XY9ZCPvRpOHx~F+J@rsWNlMNJSJk>wH=A*Wj@}xaZj5MiQf=sdYLgE2j+Y*#r^V<} zQ$?v?l1VyAZz{K=TcD7{Y;`T5OBbaA%7w>RJs+}!eA>iE3!N8#xhF>dGNV=(t7C{9 zc$|5qS=O7Pugq{kucuauw|014Os~AHR~L0>6+fJEmC2&k+b%0_c5KFLhv_ZFUyAX8 zsA)}X$KGOaqXL5~*apkWD`PS1C~mhTL3FelRpNOl?f+^zYAg(!iZ=3A`z6pQJF6^) zJ)#A(vM@>_@`^I>gVsx;Z{$ux8fV@3ye)beUyR0@?I8wI#7TVlW2cyH!PST~;|YBO zY_>Kq7MiWIu^%%t$!=u&tRi%>NxFpBTJ)I#U}ZNlv((}ealwEzKE%E%mc~YBFmT6X zz@1IA^L>GG9IAq=hYkPN#!>`^3pT-+POV1+si@V|3J;m%HYnP#Etwx(I?7M>t= zih>>^<83{=XXeo-J&fLBexax6V1%JOOK~zqAD`Y7=k5AX?A}az+kRVV^#&Ne{e|7VH#B}z;k5r#<6h7>(XMeEXAqpz?3>BV~+E;<0fU)uT3^h!>KjzF?U5io#8{|&ykj!@g@(TReL0&~uu7ZS%b4{HFZ$!I z@c&oZyMRSit#RXPuRVhUqJV&aq7Dj*cT`jqFEa=_C@3l_n&zlzXlA6SsOeyMVH!!w zYFSxfmy>p^s5I=3my}8iJ638|*wGqNi^{xZ@%`SlXNC=)|MPs`^PlH=_j_6Q>t1WU z?_T3V56Y~d?vRQTrChws8?tg>R+fSRl81!xEWU0IDyA8P3Wp9~XT*Dw&RX{Ugts6O zdq6lO^*o7S^H7%|XB3LRAu9nr%y48(DzmvdL6c^u9ZR0)IOYKa@V>_vP++`ov)p^} z;XO`7Dc{suPMuPE@$aS{iuWkK6a!#QF`b2Xy9O&)mS%=j$B|pI@-(> zYsvV|uC(pelF?n#oa-#`l!~IGPo=xi+dWgX>uDM@sW_J_ol=2ef!P5n(NtH6^}x@n zwde;0uS;C>QIYA&WY!~AGt8&(PRVpCna(*#*V;PTl~z(!+rnC6?QAWXE=C?#qGq;# zh%7`R5Y)BhAiZeoGlCAh@X0Q`2kILhh{yCbpz2~MRW&MkKmLHQp}@FbGb<@AqlUxT z-sWoH^@nLyAP=l(X_san67L^Z+VLqbiqpq&))6lnj^h}*VV3ChnbMzsb6(&ivrp?~ zSZ{c%ciIK9^)n?V2J5OvW1B6MEINN-;>2f4q{E)+T7U^BNNYl9*T<)#9hYwSc)4E^ z6m|u3Fh8%Dnd$l!yHq<~6hRwE7mYrM+4o4skYNW3S~eWPt2X)I(%&wwfC!4>(xnZy z;furz#hdH+)<$m=f!c z$nEKJeKxcDI;I6*?~265bQI9$nixzcFF9LLSqO~P!#azhV0wD;68o~rno*yOpft>F zbEO~-OpY*Qf_?-2)Jz}Z(OU4chDqiyTk@fmEo}`SQP`!QUTjO@M6VhpI=Y$gDo#s^Z zyT~c@9~IUqQkep)dDLH~tIkTfxS8SlEfog$CNz7R>w7EKbXF|ttgc@VT;`Ud3%J(( zC+mSrMr+Y|#q+wrLXSFgJ|3dm2_+7y0=X8l;qF8Wb8U$Au8mSlNSOlxUKg_eW0pjV zX1Z{F7d}OB{YQH%1Z}tpcMEPboSyC)WWz0@1HSRjSUX~Ck=e%ax%7v|el`_!nQKh` z9q4$|F@=ngbC))b@6h?{Oa91=+B-)WWs}h%vz#P$#A33NUjtxTY@-ESNYl;Lb4*0x zbQW*-@mTZIeCL_&#`vZ?Ex8lt8ng8x=rWp(m!QXChN7C4lg;^usf~1#%~QHi_fjbO z0wSKgm~E`C(ZO_YhCRcjT8~(8*CisQ_DOe|GM#ytVJy*>stcH2@-V&R z$D}(8AD#ni~I8$r)kFUvyQpT=X}!eUUZ%5ZHt6mO)2CgYEeYSNQWtc>$s zPwuM1{_gc{@nYdgC2kM}u_WD%W#1?aFWfF$3Ile;iZ6cgDHPT!4cmgzet22M*EbZ? zjA(O>$`Xf9Vv7(j>Q5?B$Wg$TIC=3GiC-$6WBk5Hr(S|izNFCV8jpR(cwF>4+JtiA z8xJd9lw#$VO1D1ips!AMt+UHnp>&$!e#J@I#oo@Dh+)4swgj1=`yT@!w2Nb3DzdUA-XI$e#G($0YyF%XVr$?zy>yj%z*TF~eUW0=S4uYD^PPC)D@?U>kBK8+ zDLG1x==3$t_L6@VqrO&#!2W6N*UDr_PkgP+OE5K*C83zsmooGarW5aTd$ zjWWA0A45V7eEBk}A^N~0N93MT<{1zwL40~jnTBY(oK|oFh!}TT=^9QuW8VZ$7stX3 z^NiSZTIm_S4aZ#aP5dAcIGJn+FZxCtIj!{Lk3Au7oK`w2b`g0-SI#vz3PElgS$($Fn*)p;6?2FMv0@FE3kHU+31pr zBMoJC@$)xIH09SK0?sP0C`DrbS)7_xye+;vtK8Lb+E;QEeeUkKmR^X1Gh8cz$wZti zHvjDq=l%;7OyRdmFb~@xe*0eOBzAwRgdmc4zg5~Vew^;1X&R=BgZjy6ll6$fuk(>H z@%S7ye5D2ZWvtkb;@bUY-mk1{>RtL9d3&_S)`_Ygln#!2Zja*0{}siBHMb?Tw3$E3 z*=HlQoVC3@+ELBC!ytHN@N_E1gNU0xx(jk=(Y_B@pUKAo=zL@|t;<75!$jVjI!umbKLAVL?i| zYdKD`@UZ~iqpz%|#_y3ju~`84|L*?V^YQa=ty&+D*>BRPUb|n+u2mu&S7jDuA=j+L zgi!2=Z&OX{`06(dzazhBot#!M!q`qF(Pybg0`8sgi8T?aBSM=Jp~L zdy;#0rTG2_d~ARy?G!xJ7o~gqiiU7^JCfLn zdnn}L+ek=w z1pLJoAf5n0c{w1Prb)LM-z;wN*$+yP<5!fUS?Qyjd1M!5r<#9zl)taKy?D;cUdvzO{4XrNxJtc z8m}?@$+a{@J1?}e73;j;$b9ZjY8rw9d{o%1-09fnD>Lbm9 zpzLFE#MbjlTZesViPqO%6c&QeCMunIeD`GDwNlJp4bpe`ySn=EinCc%B-(FBg&oZYbO^(D%@E~1I5s$s& zv-A#c*k;!jHG^?JgX3|!txt-xAWn5H|EXvVt~bGw=xr=4Xf1>jHlLq7_`w!>bMY}z z^dpQVuQT!1k4j9)KCBXsj5a9PilG~P=6+GQe^lZO^lhLB`AK;%XytMFmd*T?HXCoe zD$f3dO#oS`;7A3BqtZr&J`$&kPi?N%k@ElW@IQEDl!3c2umWxSG6SN`PKlmmTM@ZY||I9ZLUP@$b9DoK^vZw!Leu@GRhvbNn5R5EeNtUj7I-K zpR}3MmGQ8n8D-BbEo?|n{&iV2MFmqTvZ10KrQBWOlhFqEu=i-`MGCzvcjgMpRwz~A z17A}gOvXJd*tdm$3VG=Sv*=r=L}X)Af|b*C$SxX?e}(eD5g&)+2oL$U7Ogeld;)(~ zMqkyUX=Q~{)k0<|K!uH?n<)~YV2Hc&G2$iqkocrdG4n5+;!>T`8H?MXpOwD;55c+2 zR_w5gF+W33lT%snvvR+JHQH|%mGCwn9Hq=|iS?cZ{Oe^Ac?qk^-D2@2CEAG2w>nak zUQ*g4!0t;}+nGi6C8c}x8k`x>`3WpFg5I)4W;)klsWdtm*GX5IMXSq-8SA({m!UfU z=&0CzS?R$auM}TihCXYJxOo|>V8c2w_7^2xSuY;_MVahhdW16R)qW@oM9{BFf_b1O zH5vzCI&-$baX;zRa%8)G?*8y4G5c3#A9pXUY+Db-BZnP*@84lxw{4Md{jLmay$dQn zXoyhzk?!vKm0$jj;`6_j2=xjS^F_MfzJ|RPJ@z&3_aceC0dTC zZh$%OCo9Ro5_WOLq+zqC|r=6na=T_ECAK7bb#h#4y16Njq>JbN)smlb%*d$B;IO}&o)Sg|GF zX%{^W+>8um7Mi7yO%I=WIXBXVXIQ;fVj|K&ANWaM#OkK$aC zZo8$AZCzZKw>0Y2%dDH5FT@EjQx*5LKzwtVNRUsdtukM3JS*rYQUiE?>)PFoqP@Gt!2muolb>+MDkWCM#idTI z#L9_MNd`@63bszTe%zIk1&pr?SDRVTV^t+qbUwP!xm70YR&idAW8Z4hm5Mnnc}IsG zf3k*@Y|hFGbmXI(_v6X1_k^Gdl>9)i5+fRuXC>`KfldLXIxA~|@UL)mF{-t6iCMn1 zX6%BDE@&;jtSrBb%M)k|?(T()QV?!GR4%l^G})Y+t3V@;Y6tMq&ByS>{D!l*tu;i3 zhf+NF-^`?YBh#_TLx59|BaT`PxiwS|gjlWvNiE_STyJmPpQKX8wz`o&cOVXPNoL|w zW=6@}*Kv4FSwmwDaKMeh&3zt1@<_D+M}`-Qy9P4Ka6D<8G4rER#^4ik65thJb56*? zo|@impSxkzi(rD%w7IrY=^6yZ0U4#~lbIl+7$WKA8*GCPP&S8itE?Pcu$#mRCRtsd z4cQutBaRhgyb3SZ2?~Wn7DEmG4ZNWs*0s47F$Dd)+9?T}`b9?ahOg;dWSJ?$sZsb_ zMH$V~16J2BsY5C$CqbJ?g;|#B`a8w7p&@=AWlpWaJb#qJ+ScDdtd^C2wgYu4z6o{7 zd}Wm0*D1aD$68WV;1kx-coCyM-oY}4rIwC$rk1AQl&UpuxNj|QxGx=>k7N0lsMHw! zn=Rt6Ry?(TYRR%xdN(zM|Mem{K})~V)3~FuGMvkD0CqqgrpNrT&K(W$;=b0rPwT(` zMZT*&0mLh83O$}IlZ-Vo zJ20(XFI&ZByhZ}&dTI|iAJ8~D4FY#jHqHEy>_@o5tm6T&Bj^HLe8>1?T!ajk`g$;as1uag#Nlg&Nme z7|pmlabTs;?;28S-B`qgyY(Ir9cd8%Lhg- z##hn!BJRD|EX*h%_QcviEGQFYZ8=P<#ih19rsdYBX6s;n;6)S`Zk-Y6xa}n;3k*_DL`K#!n zAlR}uJQj(fr(gS?jQ8y>Khkl%_Yu8yWKX_!8X{QyZ24#xMD-0D>5%v8s4hwYF2T>F z7{$AhykBS@<+4gzHo=mhG}G?>N8npN?uL=ZFJQ zysZN(;d!(TJ1oC7qzxG5$#(5K*OrS??}iNQmFL%_oV-rWR=UPcJ0bMZ22wKO>vP*v zjj#J&pt0ngkmX)IPFqX+y!F$0Gm^IqSKy9VdTC`k2e`IXi@ELi`Y8VtoP+2S*GgX; zFK)HtdHjnKv7kLK45m)uIuPqOj4#J3W-}ANwC5AhA4WuDA^7kvaZfZ)lb(vs`4!#p zdO8@*SK%9nVI8y<^Y=o2lPmrLigmbG1ViXL|FP zzSPmN0-dvp7$DWdc*TjusKuO4CNx_YSrE9}cEzy+vv7SUTT`BeH&J_G7(~rnC4K#8!HzSxoB76I#53Ji8vM7S6uBXH;Z5eNq;bdJ32{2hL6) zBHecsh~s_v3N%7$0`IPTE|w(lw#G=gxOXOSGAn$S9Bkr30w2Ohd?n2N_uO5`6a-&83l*lt2^0Y&)v36nYk&e&18Z1d`$!hZ` z<~D2#)<6YCQ_q?_=bC)y8f-`3Ekc~>&gfViy$o4nUeUYJ3Jm5J7^Qf*f9jt2EZyS+ zvyPyRf55-AA6sT#`mL>WBQ4nR4~R*#m`%JskcSUF0=+<)tMoeL(26-X5|QZ&jI}z` z3vIZfMEc(+SMaXKOR29x)v6y@>mW%HpN~I=o zt*=E%Fz8ZA#h3vVV;yyDtzSaNctAFmYf`XB$LJZ6*wm4V@!@!pj(boBQxJM_6vQSZ zS#c<3HPgZie>bnaqrTQOj8a3~*`s5`iz7?CI2bcyy!d1=uOwU3$I;!A`0&;{aR!K2 zx<6@}H{LH!B=MNm59nl5?|*y<@9YWDZ3yqwx{uD4-!HO<@RyC)17d1YhjMFc^P0v8 z4Qs@tp}cda+f7w}!I82z*@I%+P(B0dG+`0H4dwA8#_1gUf-a-dxkjU3;6`7%AlZVq z9a&;|?PYrC0{kPUCG!P}N&GUD_Z+!qRbx7{LEjb?EzR^%&Cmttvr5Dd!&r+Ii-+O( zfK`?b;~f+;YHwQ-y>E*TXWfB6Z6!4?Y%SlxQUtT`wgmCXa6S@M9Wa7-4#;1DM8~@J z{1`6=jo?e$zjPP%Agm;gyWft1Q)4gsLL3@_ZF`RRbp&r4Z>Ec)@ru_z2_wb7_KN== zo2VbXFR=HH#Eae|c@iHyP~0_=cjdct#nzG7V>@%HyUJamt#m`IMeY^p^D0J|$Q=4&#&+_p5F$07DoO)-&!G6*U z#!9k`W9i||l~UL38!MN7EMt$Rg%v7o@Af9AB()r`@v@3rN36UNBgAC-x}Ol zR&yln6cfVATcL}+Xyu(9`=V}(JVh7Ct6nuMre+~!wkF@6 zLT!6*X~pOi9<7WO^HR7q{M79Qo!?%(ox;uhKb^!kDZG19WVBbK*75de|7z!r7McQ> zmePk^SPYrmOFM~Sqj-n#|JqM`hdvdTYUyhxQSF2#Uk4D8u^sjJM z*Jf(r)MR(i0|BtAOWSa@V3?+~SR~`^WOHGKB{k)ry2r@8jFL(V%7fS1>BElHIb=-z zKQ76%q`9t8pAm*stc>NFuei_-EnH8G#|<9`ZKS2@ku-}`B921klUbfFnVKjnvP{O? zRI|=%O|?AyHs8-R^(~v{7uk$5(th5|uW9s0y{7(1+I9Gyjg{qOD5+4PKX*VHrGa;d zb1A4h>ZGDE8gDGIjj?$1w)-0`Zy$$IH^Mv;K^yQPx2&RC?26oBzc5m-iBm;~F+3u24Ti67>d(E0a! zJ0X+zNQU(m502rTjCk2kG>ccq@N~X0R2-PhLzQ6B%En{)ns#D<4adZ>Vww%#CI8b# zx|*Hg6fLR!)XuPqvypnV_bJGryfeFdhG=o%LwXzU(9(vvFU|F1+K_#*;#V7w;48FP zdMp1UmRG*^#`1hH^}~~7^=Eeb1<5G+fiST(i-+?7Eeifvm~f^eW49s&{?el>e?d#y z+&Ap@3_gF-8}$h-HtQ|iHl;5HHbz&huERF9D&4i?Be`gj1xl2Sh7YJIE0wr7ODksw zPhz{8MMJeQ^DA#+V?9}49;#*igJ7+8(gprfC7xGA2>fS?IU>Du^kgJ#y_)(FQ|Ql5 zDXnzPulZz~rWvIa%Af|+e647$RnE>f;_@UOiMFFA?7FNm&@57mCdnxm+EsU5TW`?U zw9IuH+UVEUpnkpt&WeY}@-W__jaGszPl>(>5u-AAS7nq~1jH|C+32(qyE=WXQf9~b z>OM-wg+X*WgU3a!qspXD)2Xxy?(Nb_beAWp--BZ|{FGykZ-Cu3p!!(cHxlXr+@ z`nZa5qn8#}olLM(!T*RV`h+*CwlXTkD$Zu|j*$=GvNB(;jJ}xemNA*H2Hl>igI{=K z+TK!Yj6*@HK+De`t;JK5c~l@KK-?MNx@sM=&n&Vg@Q4sv z^960BFEX@fjj}F!m$kmVm|?yO>yMJiw*)oZV;%)g8S`}c@xG@3Uqg0&B z;$b2&i-+*Rnv?lptJ@=AQRB@)uD_P&t*x{Ucgj5P2{106`y+}ecU7+_<=w%Ya(yQjUJC>n#V0ZkNq`|$}CYe zk+yPW}XmHus5R9S`C|XrJtq~Z<#M5zZP1(^=m2Cj>AM7uhrvFwJ}t)nP3(A4*D4W zmWcY;@|va{tf!W0r?=!9ylJX0ANOWIM^sJbVe!SyJfTvcl&0>n3O5>hd;L9HltXQe zzMFOX576&mA4-deeYB_xdSK>Xjp5B&__)7lG-z+2X5sHccx%JqwB#3K#prA(DBss= zrTzB*&mgVEv)Q~yE7u%)ce-ZnCku4(RW|P(nGO*yfuThwY>#mmH>HAZhwdxdPvN~o z0<{38W}5M^*+>=Br|@BpsaBUIINf!_bp{(z-sM!9E60@P$_h+#SqxUXB`}trK^uOi zZ5{E!xcgXH9%C*3lv|5GFpFe8CI8at;V|X(DE#6mxE%~RNiB;tNK8lNv&Rgu7Ne+ z!1RDSSUnI_S)KgZGLtg`cespn{nl_W9sib{rdB0?x%AOgSCF;%MuYqVXKPT}5i;Y! z(qnNf_RIy?_Tl(A-g@UDWZ186C~|}EFwS~!`w^CDJVL1vIn#Kzpr>ci@$W`jz}awC zA|9H?hbV4QJ&h*?e?FeJuCObSCo1l5MQ{#}4tLKaub;U~7Sn7@w-QmaSaW#i&iBz0 zruc9?{%P&lG0S8!{+}u@%&$k4K?(IlwAh%#`#AQ~D$%(&wwA=D_n9-Cdt$LnK}L?? zUZ_lG_e^J>)TD(d3l2KS`o?2#6jZW=Lb@XG`4}!?BSjKIx)CxcWJByOiVfDx`+<{2 zp&_@C!?cg_=~!Nt;pt@hpW%GEUVAhSiSS8TP{yM+j7P!uZM~UC2NDeGH>Wif4TFnb(SD!0cOS<8&rredM!_SfbWlwHi8^W6 zmM3P<;JuWcV#^GyO$ytIw`TBei7Ix@QU$*O*B63{#U|)iNyUS@AgNxUz5$i)yt~F$ zy3i~_?%<)Bx|$``61Gz%^hJ|vOrosUw%1Nk@)@{ioth=BJ^GKe7Z>ltS9PN2Ojv)|KNNS)gm&Zwv1%sIj_!L(v-wy)f0}rBHm~Jt zrix{D_>Z3|KC|;9JZFk{d=8()1E-MtXpu0Nujk3x;?22yJpW@d2{T33JYK@XCW|xk z;In!X2`7lPxqJh^I8mtc;q&>4n$Pn2d@lbzOBfdL!TjwkF?<0(%H0!$-(CC~PJaKn zi+A9s$BPbmme+hlx%bc{l&zQcdH^$`Qvl@;m(D0uzG3gX!YjCf?b9tk3n1 zP5gc%j3@A=?wy+uZk*SpGH^40(}b9-w(@mIcw`xmZUJ_t;3I&Z5>g%bt>6pzjk6+c zJD(bP?w-FJj@7*eRS%|6-@RDNV#J%-6%wifD;87oUjWB&5|?;%7;|pilp* ziv#F3&y8l(d2w|E-8C5k4>qT<9T2gE!FB;UV!Zs5IPnDU+GgM#e>W^Iw9RXk2LfxF zxI2XZlly;x*!er%P2B^mYamE1yBw#GvMDj zsxV(0pQKE>rI1Gr z3MN6;D35csN;wS&XNJM-mEt6*Rh(CdkTD%ahaEgR+9gk0-n@9XDtZyvrDf#8 zC^2ORAIN(|i7h)Y8*Qx>AMW7e+NRY0)8O_;CfwD#{%&v|qDP-vVSbuN@~~Pl^l2Q; zp7~xBJk3+OUHvcSWF0qP-$xlqb+)<%GU%P3!h(uR zG{H|0yz2+r*`fBNSX9n?jeP^6;%XBz1p+6yxLo&HP}Zx5%msblhN$MKaT5eaI2Bi$ zQ@fmY8rOkOO+LLmsJPnV?64S|)41rQs4eH_K;mFGcBnXR{*NMXC#KCsVPfV^RH7|R ztk{WCH-w7HotR_Sgo>8W@lLH)(_S8{R!c+p%1|-*Io>to*E6^+PrI^pz{d^Y!J%Tw zb3B{>&_*17j^~dx(N^o-{?C2i`-z^Qk`FB}uoch8-;9)IMmB^8$c=Scq|KQY+z@U6 z2ZO(UL^F-Xe5di(L&Uo0`H<9&w8z47$7Z`$gTA_iSPZ3EhxRiIV_5H?`F5gxVI8y- z>&|1xDsYh=8tG}s4$-}`?qzetU(fTX5jF%3dbA2(;u_=5lVhndTw>o%N4VntZWp2| z9i9txu?-B8$qd7$^T z`KWw8E}s?hsrkPo>1R+24RK}ixmrFK%jbCcESJxA@|h@~S7j*8|0F3Xm>|&t`OJ~e zcjWVm^!lTG*2^a~Mnl{Sl3pR7+ogo+u_11ce6|j*EP9d8Q`+ss)~F$Fn|yAR&oS~j zBt-oEFW%F!cLhy(58BWb>ukB0xII6}%p}|UFWGJIuQ3lMfVZtbP)_1j4;PnxfJIAyR8Dn&KPO}Jh%DF*)s20=F?-a1v7z1!d<5eOGiznjFs+(|IYnVsYhipr zhBiy)Oo2Wb`o6YqaI+v0TCAQZBI_J4H3^eLVPdr~-rSNXgbIlg)90LZ1`1O8;C{-I zdzqy3iN0T>%Zbj{=o+GPHJZ|_%K@!xVhc2}tS(jakVEu-DpTo$7D{MG0qUsqK@-ts z8to=O8$eSeaEm9tppmCc*ImJXlX%=^oae#AZw0xX^0;~29Wv*KH4i1^VZTOOh~A^o zGLmwlT@Ok+Ov|K<(4?b>*=0gB=hm@mnfWq`=j1Y9h7%;O#cRVo1xV22=*f}H(3N}{ z5j?QE?Qlo#CA~#Q7wPB%9i6A6XX@xI9i8f>p%bc0@-m=%>1Z=(QS~zK&?0CV-g7;Q z#QB$bY>O*P!8ABT(7$iQD9-b{d`+pW(mC&>r5p zZBkRYo&09+5;OMjj%^Y>Zs~-byXhHrU6%(`CDe>+e-obGmTLw?| zEELV7jl7xoy^VZHGhP-kx6xe|DZ7!E^|_&um+s^r#jm2ca$bUN{uOSC`11tKNjHO+ z4#rBXh8X-ikn4cx*HJO&JcRQf{Ex%W$ox^`i*TeL$mc*}X2-I&n1pn$pxsP+tZp2- zI~B_Fqqi#}-bhP4oRz?MF5G#ViLM=Sy?sj=dm3V=o$XQMV0fY*t(^y-7Wcl&Bip6v z0;UrU!=auhY{frZmpSbCl!|0&w*CG8Tc z_wqr3`7dem_+8v0cAC}1fc^bc>9g>8adR&YV-rNoJ{-!J#2g@zwT}lY_Daz8y~Gng z@Lwy-{>x2%R$5=t@039ceXP5NPkC^y2fID^x(AzjX#T1zPuKC0ew7LJST$B=|ISmD zfV9Gb`Ae29ymyINRMqp2V*4MwwzB97-){`j5@T$db<+6s@neQcAMM4Io4iZq;G6u< zC~>GBmwOElQ&)>FVd`Vzuj@Rz^7Ak?!mn~&dv&hjNJ`WaE_z&%#Wf2JCwOqxlN!%( zXREBZr!*Yw;mdbud`-EAtDe_z(QXabzNumJJ`XO@aLrp1<7Kd46C`+W&LAyAS!+EW zJ-B?G#@Ei)aJ>fy7iql3gY6z1yk3*rJ-Eh$%QkuZZzhcN&7K@3cyQ5!nul5suJ+VW zg(tys58m>c)@A;GVR{+SRB-*WglvS1W$w( z4=$_H-E^6@%0{_&GGP_CP`4VCJ6S(%^qCtktcX~iwDonchVbxm0sRge(gxbh+DhGnNI2m z5o}gtr@ipP7dUB!g){&Ms4RN0%A(_FFU6SG4a-Cp1}KDEVKcW@kkfi|3*5Fex>dT& zYHy`QZ9kP^N_jXYO4P=xhSt}?dw-_>;^!E(t5PdMI;)+G_5D?rASQNJL;XtzAQad# zVk3+`GE@|GRwI>q@kD2}TZj$5^uIE3qO;l_(Om{IlB-EP+(nIeIKf~fpE)veff>u7 z7UDl`o{dq%{oM~DRd}_N*HBT|1@R{k-9EH@U}OA+i7KlZB+EhJ6^r<`i`pe3N9TpI za(xhD8>9+zjM|}P{1%nfB5KSvRDKz*TFi=7=?l5_v1+Fl6db)l^PU6m`w<=kPZJcn zkS(NJ?-6vVhoA&OFcS3Tmh^SVkg_+S(0rYr>&S#B^VA5T_}>X%_#%CdBauKY0`4E^ ziwH-8-^Qt3LZ~46UyTUqs&-TMiy>Xnb`@~V5wp6gJwu7q|751ZW$P=u#J;X5eTg`Y zux3ih`%^>ctQ)&7D&)2NN#3UM^l#8Xt?boz~g2kqeJ( z_3G8RbMJyYU-av)hFS}Uq7PA8OAF@3rq7r`L5lRUY^#-IB~4_SzcR?ODmQjl2Pi}K zfQ|_;uz-RV%$V)RXz#fhu%F}z-<+r2C&~7}1X~SlQ&WK=C#!5VyvBD2F-WxSsSe`V z6=Hl(wQcuoxYL>^2DZ1Rf;P+&hs6mX7hWlPA1_LKs>yMCJ>vTAjIHd!n8srWpEog| zOkD1%j>JXVy?d$cL&An>5!Li$tX(h61!8(HwP)|e9&vtetf>GRk9IhZlez+|ZxT(+ z=O$i9kdVWkAXR-CGhtFXEG{Df<*@MYt+wy2xq2cvj0g%$th^s%UjV!zeY}|1TkWgl z;=euAP9eF&wH&emXe~glc%8(DJ>sH7#vTM57Uz1a5lHR^T*HfA<1Ar>%HoIMVFB=f znjF!)kJ@vH4O~n+18Y~vnK4gg3f7QQ0of!+l{V+g2Wv8$c({)`Amjy)H_K4Q9tON1 zzC^5;xRkzXsN=fFb@Fh=wgEIA4Uor~1w6^?y)o$ckT5?Mmg~>LP_JSAgYzl>1tXFF zwRi|XKx^|G7%c9H7(Kt*M@_}KPY{?St#pxVi5B$YYcCNIN z{4|W$_eh2;lY1ji9XGIPIQY@W6V=|21wLY`_p3FCh6L3p2UL<(Whw9&Zv|l!ZTqR6 zCsHBuz{cN)$D4q5t*fXIHF(@vOVl6qQ1K6E>q7D9)0G~Bh#gJTbb2f#b`?=u-W1M$ zYBxs}25zS{j8!8>%6}7{%9!ZK^5Oou&QBBGws9 zJf`5m+c{WNFF)2E-$VP=8}d~<&yo`c=9icrCf4J82Jd__learOo|_V<^5AuhRRD4j zmNMIv$7~4y4E`DXvu6IIVq35_xqVri#NMop(u1|k$B3zLpl2vZj7m}9$1IOvcmimG zqy+T55@cXOiT*5TQp{bqiml3KBD1<$f>xzDg}iBGd` zqW1tb$U&26KB9OI=V0-xhyVlzRCL2l(T1VrK@dw~8E_&X@afQifku`Q7{~&7peZnbDFGON2mPuHn2BQyoEZ{BSk()Rodg^nr8+P> z8!$TuGDB_~DLe&-8Y+|Q_$E>9?I_yI z*q4AX$S5~@KB}u93s?S9FvjGVrY=?$gsNy`U~R74R7?e&v$q&q0?6=$*Yi=)=)cMz zikh!=&mwQw+#8B1@w!s`4jam>?_!-vf$2qe{&$7=N?6kZnj4~6)R zfC^8X&3RoI@t;9zh(jkpqoL4gPezh7)8#lH@zmJ zk`UT_hOtKh-s<=9Vj`U7Sa<;eCec`U1;o1mgB%MLm;%JsB(=Mv;sS02_z|ZpaFaEY zZIXOT$WD+WKW{ad0!ZO7^H?y^2JNj zTlODvxK>?btm}1bD#m%D#SBF}{ZURL$&kFf{4hh&L>Pc9`m?5P z|63jv7r@$PhqAVbZN#`?YAd;z+LEDrT|6ch4O6?0qrrO^@-KQ|d>sezCm=Ae3V-2I zF_fMM_)@$wfQHs!QKJM7t%%2T&0pPwI%qSLWd`si2Af}ssa0$7%`i1i8}6AZTZB@@ z4+k+8UOpK1%Jy;AHl(PU5J%@x@Tb67bY*$x z&7ydPJqz$I(wgwpMiyG_bywI{fY(zKUXDROW=9n{0A4>nUSy8IUdf(-t1bceBb(ID zO?l)R^SMtZ9vh)14>1o^*gU{l83avVfM$m`hDoid8)gTc-w^Ris@g8PimE7Q0y^g$ zJeB|q0YzgJW*J&EMvNS(c5hD}c94e`@pwaeut*Pxdfxg9(G4vMyj8yw3rXq_~?4&0?a+ka~XHmnbAifZ~nC$5a+X2wW zMEnInuZdcjn({O#O=y)CC=>dDH@ui)Rn3lZXhXmT84^R3eCD=bmL_tn6m`6uc~L{? zrgm>P&4O9oTEIz)rjzjnB-}s zCOooPfCkD%19{~Fdy^!`EQP%a*yRaTrsI`1M%HF->-<*sz^s-DjLC7DqK(rl@Nd6? z2k+0KI{LAo>{i$|1hSx|E#-_4@7jD=(2`Z*uV4D+D(sdg4Lv{Pe+9-a-xs(D0UH2G zleJ>`c#$?rjn9~mzr+I+cwDn|yyC~1Uw>X36Ya;Mu|x_*8&SWiUx0t=xl3VtJz;#j zczcu@Jq#|N0o>$D^8i8-e+zKM6QVg^?hPYCQdM(gp29W(EI8JZ(}I^5>8WaaIYPI? zDSjs&uLAr6vSur+d;}Ivj#M>{_UZphRa1g!AVyD7Sstyc;--jesp_W4%?euu*aA7l zZSnHru{1R&_hE$<0N8{a-R5#^gQJQy|?T!g}n}tdrp}*Kgm}^cFYrw+#7k!4$Z?M zuljhrJMK2#E%&f#p6W^yZO5p|(NE$3r~!Ep%Y`y#8|IaXd&a1H?fdW_#DHEop4z!$ zko+vj61}qXMn-%wActhgMRT6w@P&aplulZ_V!cg`&4E$#^8jteK)JI07_?4}GP(H2 zT+>`m^@JHA`E7+w0n~d^_wnLyn;IXDkBwttTi9#5r<5o|g;yr5>1wE)(@WqiyVApA zZo1l;y4j|5wQuAh{Ph@MzYL8@#mkH1>1w3qC~^t7MXnJB7J>Ja5oe1eGgSj-X!X&Y zFY|^Iabwj9(bSc9!E5~Mczg&j$v$sS8jVh0HdZyuQE{GpT*l)Dz#x5;(Wv-ztlB{v z4R?4)!yV$tEA&+(iqO z5_rcLVDS%wcoCrGN#V#7&Y+gkpsZtyguK+o^^rD%&)gTMX^k0=^hI>uO3ee8QA498O|= z7zX>Rus4G1Th|8W%SCo>2(#BJY~4A9El}vxJW4~&d9oLb8YP*a0xK&aXt17U5wy-oj9dxm$U;C42cwBzx|B1bb4vGEwarLonb-PmhY9i`e_&F&v=HebnpmC(bzaE9;7Q05-T$?`XR}!yjG`=3IE_j>kZN=0Pr@`ev>W{$;y8^JlOB zN`AWyl}Iw=irn?QK1_(XZ;aYrYNz(Xd;I%&90pK%#rxT6CwhB+m#uc}K~-X!4=*8j zbOK;QHXEaCC_NR`G>h}g{_K5|;Y-nVirP`ma@p|KxeZM&SlG=16EKuLk;tdAS2+d} zdQw||*0#XN+U6Rt&sVX}$40jn@*tH3rL?pMz?UplqKV;C6gCpD0nxOqhX%oovrcxzWr%kF%Em zYyqN_2RR)ie;Kl9lEFW@>v?^cs4gv7h|-Y-)S9aN@{M)_HV(dY0u3ziWHjC@9azzP zK9tqXM_=|PbfvxIdn`cVJqeM!o<|@pjCg%2lzu)I-t~K#Tj1^ZGj+z3aF#$y9FtVy z#Pl?-F67N88Tp*H{qc+-}W&1D#tdOy0bwRdyI7js9Gz#gGT1_KVwlg8@;vwJw} z4A3XsRE8SX`_Y9pFX1c&poN7Jh_@F$)B~1H>$C#=Mse$c2PDhmRNQbJX^6K2|zoxqbzZ8;DNPQs?zR zjv66Xgty==p5C*@h2p0iHAb#=6vxU8dc2AJzyf2J6eTUkU&Ij=w4>qBl z8G8gXDDfY@fV+`j;G`}oRrGu0nLyJ!8* zEfi6q2bX(rwFlRGaHMeNtD-XDJ~i0ipJJy#ir5(gG(CMyG92C z{|qRHAD_7iXfj2Kf`LgjXu^E~XOkVOB!+>x1P8(?(gC>xo(o{ZP!qtP0!*NNRw|&$ zS|uB%DY2jl-vO|ICOii)6ExwwJaV783gl$c@|vSBN(SaN;C+DYpb5VV*ag~W$O4)S zS|06(p$MArlYn~Agvo4$4TrfGu-BZ0@TLAx7(h<=cR&(o!q)-WpdCJo7BFPllAnl^ z3DAUB03HQR_1z@ZAnTcgq5L<3(KtMz2P=?t0Bgu!Iy82k{9 z1=NDp+su$jO(;I4t%sa&EWlth0O7-c>!1nGT7f=cMLz(3VeiU#FG~rhPXVV-wrUr2e za0w2C`3L9+qtULwUXu*MbE?qxkP}`6NClk_d>%kH0E8d<2on)#!Y>0#KlgkR?Mkzy?2rPt;+G1x>ie&&V8T!qYtTw4X8l=YlDMgU^luG}$+V zUB-M3ns78=KWM!%0~tA-`V|R6PWT+a4O(xMpf_S5?wt9Ow-T$iU!A3k5N$68{4_3^ZY*2^s>>g!=*#K@+|UkOev)_&+V7 zCjngxd_4^MQqW`@FhAU(DQ)t>EQo|637YtP;9GG}hkz#Sen>Y(z7@^Dg8wF?c^@g4l z3x_P=YaW{QQP>&)m9hx0oWfG!hj0`i2egBTk$^lfdZj)Y0bBr- zK~8uCl=gc-6HfEcgvS96L+;bpgZ3)(NtaK`{#DS*Uja>c6Ce<}a>83O(f+Yu%D`Lz z$OR{`SJhAW0{9yM z$+PAt?5%kkt+xyyi-9`;VGd~Bi6{ibgZ5bffF{d;p7Sw_fhKGNADYFM#&x{XvsGz$1Y7Kofofa0)bO_8nex0KM9u%mGH^p`CC(OV|c5gC?8}NC0gI z_8I~Z9={M7g`DtQKpyCP;F3is9OyFO$Cn@zpv!@OUM`!-!RkT$U5FgPfvtkI^lDH0 z0ss4cjjjM5vlg8Qe((h&`vhQu9Y786nIk0lrjZ#{n7S zA9(#H^nB3xVv&v5?7$cW<1;k?O(qC80p*|xhm=6S1{z;7vb7JQPk_ePjO-MEW>0+4 z$dX(dT@Fmf1hwQJ*lVz$H#*Q8Bp4jf((VEz!AgMee*qbw32)wp-VU1Z+DFmbLF=s# z$VTCNKndi8H$H|;gC^_(ya!ruQJ}X#AWMYE$Ig@n!UE(80jx_h<>%1D|>mnT8yn!?HH}&|zUi;ImEut+!mz zTQ!iiL)crW(HzYGMDzg^Apqg`0A-*F9|M$w#&@;sW+mnZ(0bzrGJLoJsD_*{884g# z?K5HkO~wsx0ZcG6ApG1rcqN0DW(y)gtCNqi27o}o%y2Racn;oy(ar$7_F1;_@?KEdPz zpmjz$aOiQgKaFYgaV$CjdF1IcR4HHs(Vr{qB|tUk3gEmNl=2QtEWmG{K+S=!0)F}o zW=7EEz;nMv6Otd`skP`6GcgAMdkq5!+kU{%gxvN6#{VKPTfpQ4&-xLakpcjFHT{GS zxe?JURpO;}SVVv>0)GEDlo)gs@X{-2CXxet_4ImuJn8Ar15UvYVZ&9_x&sUm?Etqx zn}Ii8M`Cwk>;mt*iQWzx-|{ljlb3+@>B~Xub?KyIw*t;XPPhng9W-GVz%(0i0(+I~ zgdJ-eP#QQ8b^fpb2+}Mtl!wd_2sa22_FeX~jX4 zw){D$#IJ)U`~e`=j`hD!H*Qy@&fFY?qj1oKdjj%6`;_6JNpZd%Py(9pOMo4q2^*my zuK?}Sj)Nwx`F&809|KMJB%mI&rXnZ3(HvFk&KI;cVsa`sme>|2N)!r9iLus*;`s0=t{1Qf=Q7meg> zLJEv^=3zbnCN;K$^w>nCj^faFV*Ur70Vn`%2M$X^CP15kBSxbdi3a`wV93Qn1NaSS zn~BzIne`fI(nS9Sm8M{BnG;k@FY|j=o;Xk z?40$Q4>@rBT+SAQ_UUp#>-D^P9Wd#FP4iGg@IyEPP&415N@5V0S~w8C6HpIYugTSG zc}d$lVLqyNfhzHA&^FM79e^CrdTp#;aZ3u^yY51Vg&)Ez9e7lLSqc0&pb9kM!+;vl zgg^DjYk*rW)Y_FShf)BS;3o_C0S~QL(~?Se!yK@%pGY$0g9YL?WvR{;S{0+KCPe zIeU(?n*g~9c^=AYfN8PH5`psp^u8zre%?dB-~jP0fHsb`z};WaJoN&u^w9f(vtC4} zLqvoN02C47r#*Bz@EH$%7WfYU#d!rd{$HAZ!Z!eki02mYJujjChk?O0J*?|4k0;$UdP-H+7A3W z;1p=wOT>NvRDh-rYv`*Q6V8PQ{~_t&u%_6L5di1~PlWFT6k#W12mS;=iPZv+ep{on zfZx*S%HLk)EtJaE&!~O4nEAZgzg^buoZa@_dAsv>7w#_FU9uZz+GdmuNIY1s?vJX5 j`hz8)0|A+Kns>(U1W^QyMCJ6I>MAb2dS2~;3q}49$ccy0 diff --git a/bin/VulkanSample_Release_vs2019.exe b/bin/VulkanSample_Release_vs2019.exe index 7eb686f4cd88f6410821fbec713182d0cbb4b87f..31fe0d38be67ba582de6b7e71857328bb106570d 100644 GIT binary patch delta 100636 zcmcG%34Be*`#*lqxrrOgb%Wdp35f_2YltQGL=tXDh$X}xCBz;is>8cUoS*^>oJ^`!f(tJI;O-w2N?{hjVF&7mO0E|81xOONND&D&vC4S9N07!@N$TCdNo;;!BEgRL!{zzW#fHK z;1bv(Ik4;+#6l1o!@fWaWiZHyEn?T?>J_=zH*``yD`R~A+R5QY!`&SnjE2+rXLFdt zMj*cKWjv4K%U;IsQheUaczhb-nTR9pdJ3oO?*u>34+gU|kCsvs#0?2usBRAw(zOPb0)aFcpWWe3YxeWv~k^C7P@ zzcOJ#Z3A4~Z^!&A_hVVCsma%CBIo{OD(hiN1@~>H2=DPADW`06j|L4yajJ}G4^3T+ zy;>OAp*Fs9{6v=Q6()^mcCW_LIJU(rT$;$Pd-cKZ=4C@b>0h>iG=b%mZ6u|z?PaG( z6SmhYCrMSoG^Zdd(WWTbR11ziAyH22`{P;1^6RD1>~{H%^2T1QZiQCTST>}>Y$=`n zP@%p2c~2H#o+*uCZ<|}-_c?P{sWYoyaRtJkRcwNEKO&sQrdbA93_VEd#l+lc{WhKb zXi1Vrv1Z;)!D@teOYc7#8V$-3o03>!i#V;#Yq))rx0fW1WZNq(lA>9s%B`j0Y-Z(= z;C8cePw6$*qDmmb$yHiPBiOo>_C;;0R4y;!tY4Yzqfg)>L9dp^NUIMLzx8JeLj&v-m$rr~(ZB&u#rg*t3d)n<@>an(S1 zb{)2@YUdE-o>P!%DwZRhHsuKzx`cCDyA7rs%zwtS>V7FTd8EXaQ(&2=K~BIVcNxwO zV)=fdka&+@^O$&8U|vk7EpJLXsXUYm`Pv{}Ehn@|yo@C_<%H9^9>jSCnPmuCT+x;{ zBb{R#4`Sif()>jV&uKQ|7aL-OD8CFeLesv3*tTk6(m?iowfe0=vCS=UX12E}gMi5! z6p{ocniNd38;M_%m;S28tuCT*zzQb~WbLc3FFS!?DF0M-+Z&RP+%uR-{vq;)7*@}} zd6lMkS?uSuwuU69ZOV6AY7Cp;KgKkSgxJuZUH7jh!VCH{r~iEUR1jMb5ZrJ>5M^CL zHJYFt>*}b`DzU-whznX=W1{<_3rSEqdnGhDtU06Ew*e9IydYMtMl)#uYhNR>&QO3H zy}hW!L6&|6w!HGZv#?Z>oz@2Z>80oCbhfHSUDWoW8opjBoU|aFU9V9Kh9T9o)`;~m z#6=W1t=*wAZW!jh>AcoYX#)edN7S4qNzK`(fi0v??5Dt?@|77ZCMX3BVs%i6)Sn#+ zvLbvjNC_N())Uh(dXEW-|FC$+gd`|2sWzn#)v)s3fUko)g8+)LPUM zQfddjl<{I_NQzCVak(R^ohQqi8Io$txsd4_6*(m+!4U)7=;obZi9POQ8Ei>#Ro`}$ zYJZ50>{v+*qGmg(x{-YuT)iVH8r^2PHshJoX>(X(C85l8tzszY$6;Oijti0^Ahq0( z;(DxV?NBM4Mb%zYrh|t;i=4LoPVK*qrZyhXWnyo3x85vMYYNxu&Blig65+GGSW##| zd0xc{AxT=*J?u$ncT*(c_V!{4VI!q}YE z-_(-mi<7pGYTzT8T2Q2U5B6rmIwG8#$hI`BD#BlNXQvxB7UA37nbgRq0>@wIj*5N0 zoz-eI$=;k8m_dN1scxsC`d4sb5QsJ<3vDLL50#$>qD@K8=G9JBo;@STkZ6f5q^d`? zS3phYJkG3?;E40vOKt?Uo==;~f^l*#_;%oYLlgDPlF_|&G1uqBqb?%4b|9^sxcDWJ z8m)m7$GC{eD?$4ug5w~Z`>RPKGNfL1B5lK>Z21T2|ybcz!QLca0p8xKthN;N$VjX zejGxY{>fi3S)pT+w1xum=ueR-Njs=RzIH>(3djXFWVH?n@99c(=T|Q5RyX7gf1{mC zvzcR1o}&Wd;1I-9bS4#g>E&4~0OMSMRyts;3-G1@baMfGb--R1V3+{Z7l1lzv`5uN zai6*nQ36rc#p0XltZ{e?xwZ#O3vZm(l$3Y6D~%kM+?mh|j0X+93KYADzbk@DBOd2v zh9t#BoJ?@UQjbAzGx%G%o6#_LW=N8kWdS*v368{!QkVpexz?4HgnwupSIx-YZQ9fr ziRbyIZH#f{jjUp`s@`!VZ_brWGg)g*5L+~>XWZmxWJ8;EuK!6n)D$}PiZ(||J=@%y zH!vKP6bCr1*T~^Y%yDL#vX|PC1RNA4ptJAEB z2eU@Bk-}I~M5w$hicOE$HnOpYL2oE#6T(jGkDWzL)I;-0P|TG{?cnGYomqbKy2hzqMz*JUn4OzgVw5&n0M%W9+g4%gA5*75fN%kL`kNj<3IO$;ms|jg09B)psKG9Ysu#WVa2`KdJk8ZxY)=!9262xZtu_|==-DDtd?C`ftBLf zo01mfd3M7SB8Z zxS;Zga7j;w8(H*U)mds>Lpvr@iH^>p(UG%*;H4DCE8V@Lohw{pW;fJmajOJnk~bMb z6b#qPrnHzxGcfXT5|A=VPiaF+=Zb6$wuu;QE8Cz7^omiui_kVzlOfGFO-O+IPAiw> zZQGLmwUb6MlJ;(>mUTTGxOi@@MnAE;85WQ;M?W;UB2aYISSr zm)udJ)`rQ-zEUqI)@KvDHS1a)FXNTYehP{&T)sCRz!c{kjf9$L#E%{vJ!t5Vfqd9M z+ZJMB(6(vw&hxG(@sf*B)w#X6+kT@|mu>8!gj7aJzO9Wm+BU1e@@6}*N>J>fPV1aH zdbxJj5fTsWRfbJV3iPi;y>{o&?Abwv-7pUW6kZ_Imcc$x3Xa5kQmenqhbjdkM~Zao za-_0RRH0f{QDzl-237sYj9ll&cxg`S@(^8s(;-5Dj=g=@bARk!cLNza22z!a%V_y;{ZwK2A}Phb!b|5bkWTOZ#_<*4->;gc>%_bfX6ef|CFK|l=4k)(Re^~lB|oz`B# zY*63oHM#VhKqba-aG*R%=FG&l-Eou`m11Zo$bHGOH#yx}fb(q+a6~>ciWq zQm2tm22zFlI=XXkPHXHXvq}B>$wzOqulj|`fyV8B_KT3}mxX5YvPPlwS>>q9h@^U` z9tW0*U>y&Z@Zpa|gD>mZzgo32)OVW_lrC6js$jG^dWO>cvX`fk&Fw!@_VQrG{U^%@ zquI~_sSVmUk_-vbD8IXZzu+yXeIpdfk+@i!cUZKjlX~3mKD#%dvGkNx8#qPI&tV@7 z3TE2|zU@_p2Gu(?jI8INCbc{%vY;kR#aU>Zdwg1A+rKSu?gQtjdCp9mHftV|^_5%P zU{43tvr}*3NW7>uFW@;nKd#45{3>%VB*X=%A^=xifDJm}Cb|#K;g5ry!#)>az78md z$vFp{7l2hRKpFt-{lQ_)>swop?aK>{VQ2~Aasub{y?R)-iQCJnA>FHgn<0}9vf z?&D&9e%M8rc~_M5Qe7A2xPUBnL;CBG7H%$U1!SBX(o%zD- zV1cRYW^-Q?!enBBL&)1kK#Xq486EPmn@d#zxpByqW|I!-?t=Jef1>@vO+4VnEYR4D z*NW=BFd80O>}X|{N^$SwXDfaVYWpH(K9ksprUy5`YGjj#H!=aM?Xk-2qv1WuP`Gwg z_Sf*5cIrKO`P%H^c^C^^gfn+UY5G$S&mmO>$A+3(M!`>SaE&CYRk0ZjW`xp&%Ft%pTGC5DoJ#pVzfHlvCPOA~GL(=NYRg5et zt&a3Jo0=9ar?q5z(xOa%qdY^a$V*4Iw^Q(nk1(GiR6x8k&@Wz@5)`k@Kr_F|2R()Q zA4lRr?T;_GwEGU|@%gtzk;k|I=LKMu3y`J*_R#1-9JUF-8!mtxdy9QJa+dTLYd6Zj zYY_EY)L&7*CHk!5psq@vrry;3VATda+A9b#>RrjK{L-DFCGzJ_*axHfn4Y0*RWO?T zJt}~QqbkWPFx_T<3i@Z2(Phm&nlz9m^S=ZN4Fzf6@8Bg|yU#@!|C1eVKp^c0=kB1ncscczD~`opkR3#mFGyD9!n%*%YjP@C8OJ!kb%=bR`&6 zFqiO3P&_>m2icb%sDyD&>#0gcI1`?~l;Gj$2A|LT6hW-o1v#y|DnZ?&eZ4?{uYt&f z(f+Lv(H5h;m@em>gpP}cg15Ju(M-X}8;tVYj5Z)`!DwGQXY{c*<=71fnne#JelK)> zTljdDfKs3z3j10ZQuZr`baN=x@tGPVBbjf+c3#JS?{N{1-w<`&i3U*)@fMKFd+aXC zS{<{%&F0t7Ih!xsY_fI82pwY6z7i0oLu}e$9TM$^Y!HwPH>3?g_&?GX`)17R^1kaV zaqLKWbO_ryHbic8on0B*OzzQyS;nQ6gOkF?cJK3S_P7W$rvC6lzJ+J56&0~B$JGkZ zb4t}Rw{dyf?-E5y)lApeU*mdKxq~=aLJn=aVGG7k6JEpk5sk3+0oThrF5*}6fWmE# z*FzJO(!GDv1lprme@x~K&x}%9F)O& zOo%Z(gz~;CBeS{+Ee)_5fmQ(J2h(|45n@W*0H3TsTU8W@IDPy^B;i!wrb95_cY8_ zp!aF0ANW}06PPgo>UFcdXlgat_bzn|T|&tS$X0X*kU6JS55z01#%?1SF+q$0W~`3k zlL+?U4PUwY9hUS)uO8Uf{Wo0rG~-HUH*~Ybt!&CHKN}X+(P!6~0z6oU{ukC&E8mv5 zjYYw{ngXx+)L_-8r&Pn#pHCJmAE9o~!5ad)leLGLGQF+6G8j7?1?W>Waa~OVRp?|;I40cnREki zv=Y^T3rF+82On_J_Hq!PAnL59alwdkRzOrYWS9w;@SY;Z-BW;+d;@)wlch6dW`kxa&?5C9 zL3}QtET;`bTFG4GM_tF*(p?9f03^#`+RQFxkdM~7gteHp!+4~O#D1BTX1@uM{%3nf zPtecR6Z{u*r|AhF$;0)Y;H*}RGYGsVz~aZnct?+1&4T_}So_S7sO?3wt4q>Ptk@nF zlzyL#%N+I-L_+flqQ&74vHMT*d1`MpWX-c*H~okr%<`4l=h+?QclNV~+5P3H{jB?( zvGSCC%(Kig?0fX@Eb6ZSHnf*#85{bf z=~vk4`90;KcUj;9tAB1CEJYnBvnatx>$K+nrl&gi8&dhRF$*eMy}XS=$uoby! zzQ}=hY(x0GeB4 z)lu6&-RV5;`Ry5yu;YoTOk8eU#H~2x?}WUxZ2YjIyr7`8-Gy=MP(VX$UfP;C<2pMnU(<@+y7Qm96I>zEr0Vx&XLsh<*^0vPQA zPAm5{I)=R3@Ot%;kovC%7f{V}3v+FGkaF&Cl10v`&9*J9V>h4WmE6*UD%oK`?P#0s zQN1pwFsk>{XR<*X^*W*8E@_RPQC~6>j#J@L7??9&xoUGB$!-^D$a)g-*oNiSNbH*Q zyN~Q#Eco(FS}}xI5KP2Mb@c@0h@-Cr>!{_l{z*Oqy}^DyKq$tAZy*fTaDr(KN1e1p z_VFqUtke3=UG}ykKAo)FWf*A*oQJA57}x_xkSPQVw4ZM?zeP=D zk4LQAqBiohhit*3#`4AoY}caxmPTJwja!f%8T|_uxVWXPU10qdx9++A0@7YW=gNCY zGBGNxHnJx~gG?5iauFih3H3*SY@nkAS(- z^XX67=lQYr6%^O9Kc)5Fi{uyPoaSo0hAmo`8YkZYUzZNdnOJSsnoM!2@zEnvBX(Hg zoku%mx2tW)dW>Txa9E4L-vNCh|KI~_8hfh$pvfZWY@5w-(D%#Y-*qI$N~Nf8Y#+$yicIE55O%j*P&orXwTV z7uF{)DcohDPH6R4l3`C>n1D9_W7w0!b1mH4y+okxEgGdR++-fh$>$f5*hVGJ$WK)Dlo|T z0bZe)DcZ&|9PZ{3MLdk0M_g`fn;=WhBgn^|EjQb1;1%D!M6%KUNG4ITqd!oEW}!k? z@G{YPj9J)zuW|F#|Eaz_PD%#n@wqQ#%bWe5JK6jdb?rg40Rzhj*XGaXw$j5P%qd)} zhLM!a={6OOLxu}TLpS8{b^)30hC~TSSvTZs9b$4rY6!@kg~&)OU~bbfxBhbF^el%9 zbA&KFYljY*^k9mOPgiyyja}aK!I!6E)o41!yh+&+~M^2_10y zDHRDRstCYU7hnScPM?lSj_zyoc8m-8%r@tjOWd5y=L=c#suofxQ&!cfkswwlaz=>e zJ<*o8Is{D?;@0S2$j+>)(>RFSPjWlaC<|XUN;**Vy1PxL9VPoWmnmdH?=&}VG{~&q zJGDD(Iu3F3X1%Vr?-~CqR%ecIRuhi1-C*SnR=>Z~vX%4L|AAHT5jJRbO?lHXHgk25 zoa$unt*+TB{r|#AIm{le4!3_yPKG0KgXW#h6?S<(*T)8J-DaV%To>SXI|uA`0p{v} zT~BllX9YlY0bbJqon0I@3&2ztAbPWG=PfhK#bTjAB)bqnI*X$&z*qrj?gBV5(o@^M zNdqDkqpJW^aRILBfInOu!UW)t99~Y34cdWES)KRl#a=oB!ra32Ogip})0P*hOU>k4 z!pR6DlO9Rhsq)B1xkUbsfK4w2YkZOAzn5f+1tZP$E&KVs5K}b@k1Jr6-yhq1!(oJ{ z|IPiUoKD;zXNAL-qF|T`-l4;e-VTne4qbC ze6v!~uex|v{=e{SagfEYsbznSJQm(xoxscn^}A#)RTuR|1K|@;jlYk{uAr8PhP){t-P{nX4tYvm66ZTqKtc&(;*>u=X7|@Lw9|$%n)(`EW1ioCj`w_)vy$4r z!`u^@XcdM#otWN46j&o`6!;veg)NA>m9 z9FR%jUT2@J=p*m7YE~1HHlZTQ)xfB~YidI$Z zf4*FiMFR35a;{i%Zj`|ci-h3w9KNiJ-s&25d^8F39LjnXAT}iva^^g?%v;D~WfB|{ zY|+ZqNWXYX+z;f9VgdngwGO613Ch%T%m}^kgYuaIcxr395#VDn6|Q#X!!(<`w{fTdEGhWKfRp9K62 zvgLIdm)9jTA+KIS-Y5t^$~!i1l%J*2f^4V^k9_f1BObJF1!94C(DoH#H}F8hX$g57 zvUzYrE*`OY8<5scfD%OUpkV|LKk*0^4?6P!qD?$f@Bo|pf(@lZ%m5;|>B%z$GFv?I z#e>WnT(*fvfp`?*VMqFOJn^7}cud0s-1PJsVn|pb9$u&|l2ANC#UoNYYKAND6 zOs9i#ahLFO13#M0o)>o?ff87wAy&Dcm~$&LOgW)XDgVU?FTn_rSG00AzU}GBH(r`y zCvb-u8jO}4A1>J}&C`;DGYe#ga3jKDhktQzzn@rT$CPU7e)KhV#k>Gdr}eXM>4fp) zguK_ii;W1_lz#5zh(tmv<{=#D2Ov;hINo6U_sbC-fYX-XBxOP#7Q|IDHtPBPk*85` z^5L91fD`n;ivtujyA+9G-gbuD{ zM;iXo51bWBK$B0$PX^k57MjIQVvPq0l90C^%>vWbTbZ>ZPQsJ_M?aAMpHy)845{D% zC59Fzkg3g`H4VYx6m)ALnPQ4chDnuT4@9lp-^)uY@zORxX(O)K^4=#1zFD{eG+DE& z3XcfzH+VR$i@rvtdGGW0$^x=|s-56}T_V~HxMtW5Pc83#4pYkT+Oe1JCd;A-WTSkC zZG2=x-uNi|*zl8tpA^_=YMka=wSZ0>Ddy=!AB?@X{Jp&I!05Gg8495|Rzl6RXb^=c9W+^^ z7WI$gs(hoDR9`mUpp$q_`o$x-gyHkZ}Ui z!VPh*L6Khmv*oc1GeUjteGEys4|4;RG}1EBGbo&O_@G;$rBWi+7(5r!es5kJ^yRrk z1icZQy^F2;Ab8MjH~``hcAO*HLuk9lne`kNK?J+7e zE^;JoE**89mV>NxuAN-km3-1gB2@Ss?Jws_)~*C4Ek9oQhG@BWB}25uyK^Y{cBu$; z$61_&kPM>P;KpTR!a%rCYplY`23D^5`rquus13zI6;0M?S&S{4y7mp1 zsgCfeLdA*P2rp)lg(3doYGH%(U4UOFaKINXz#IU`0@FBv9O6>~v5X^#FhqxR(jhi& zqkv4(A+`{$t)9d!u6(MmW+&D+^DDRBWhxpCP7d=PB+%L=v&tV$Z@dz| zFgc@fSZmFjg}0@)`!QlCg0egny@hZ{+1`&DW556INB;hi*im72`59XErK8)YZZJxwPqra4`yR{Q*jZk2nw{9#&1=bFEL$q$)0zLrHYt^j__(oL z?l4>S@h01yEs&SizGxB?8#$b-{N)Z0xsW~yjvOyY<(_Gm`;_){`gyyyr*XpY6E=U- zP1C;3$a&GvEaQ{T@<%7x?oZl8Gy}=a|6eCb#Gfq6%gwz1CRXRuPfUG21*>{@*u_sf z%NrpkGy=>WMtn}&{}C(M(%EzeEnnMnlf`XqEZ;rGvbLs~x)Q0zP4?r~`f|@>%)IUO zfHky{`?3;CZ?|W#HQTH{h3l!t`nqcjo1W{~$!%YoayNk4z#rM#&-%-$N7#$cS_C}! zs1&n*)EMjWxvyMx9UJxeE>jucw9D67o$Za~vWHpn_NaixWPC5>ctx4)v+aKJ_7B;q z?O&SSS%;((uCe?b6XYQUOLt~<-MUt!{7*-ZX%^#Z{V%`aI=|+h#d`EUJGgU%Ndi0V zo2#t;7oFt$U$O~bG>?4q!~Z!4*Wu=Tw>7MLpMC#DXz(-aRnnIdf6$(#Vy*&SuY4(S z?@Jc4YrbhZUTcY0*k`+1$(aY(yk`^i<`W21IAZ(a3W z+0f15(UAO%NY@sO;@K6+DdSGWMllb^ zdRF?>`e-fjN?a=2xi83)KKb%X4}Q~Dc57cNQ&}X|PH$ns``bkvU+tFkpXXAbo-60w> z94k>znpZzQD4ZXR>~+%H^TfC?s}$_Vz8tox6l^kJw0hE4z@UGFwpYOB3K%DK)4BB{ z@73W*!3RwSjS1W!fdkE;h3M?U1uh6ap*BvyS_l{?J)bLbEh}Kz1d9`}iUP(--|4WQ zXiwDPh@u>73fRx~LAvTl!L8=T8e(%F;Vz&!0R|gbg?!WHPfn2or?u2^)dlVZ;bse57r~B`EIRB;5f|(xPK$(h z;DP_chwBq!ezPz_w2a5}TKxS%WA^sp98(zzUp~j`9BC$d ze$M(INi@w~4pPr^Z1a&$UOTasn5fK3XHSl_gR57ku&&%`0~>U7Y{1}UD5J|e_@`sB zwb0jR?vj7{bsO@T`B*Ej)Q@zY3CCLLJpWkFK0Ov=YQd1R*BSQsSYtVIE312alto<% z(wNg?YVm;wdvUC;ylM+OdOXx?_d2(1p)8=#OXt;d9ZM|i9I%A8oL%z0dT23&K|Xoc zB34+~!4wFb_QzMO!imOm@MhNTM5tHPT4J1*&c>Y}0oR?VD_{7Koj%bjpjQ5WXBybW zK`RKeQWM%bv$iBC<47gnqRKBWMlO4gvfqoEg*=Abn4f${j^X!XV4jMDn+Zmpv53;B zvrWvFjXQatk*|&E%9~Y0Ph{^%%-3FEbRx6;X@?Go7l6txzz+b>JmruJ5Gnu5XXz#p^-5FwW5$%a4SmE03crL{j4k5xcoyj+D$YB9d+>m4)a@h@e zUqI5`kY+k$f*UeZK^y!aH-1c`hks?dM}5d?sKNH!KcES`A$PN4Q{}n$+Uw%Z|&RYi$zCrDim(V z&au{PA*{h+E|2WA6;0UgQ{5ZY1YJzp{>vflw%jONN=h=296&t$Rn4@eNNUJ_#N6)sZ7)GSO zvByaZ0yg%}*?Mxrk65#FtxWsS4Qh*yu#9t!tADwk9Ly|8j|0G>il)%(y18ukxmsmU zy+ciIW=J~w>0C3kIcrhf&|#qI2ifU_)rHOEJ(|D9pkl*!w%FDv$gIuJ(o~9({pA(! zvh1ST0dwfJtJ&)}N8mg&KV!%a7Wr1+ki%Q3A8(H*%w7NJq zf#}5%h}Y10NNygZ1R`AUu;W^-4JN=c>jempyQt}C5 z-nGU{<9V&*jPUDA)9eAxV&Y#4(q&}IW7lp|LWpE zsr&+_6Tf6g+cua!Y0)aoLWbByne)QaY%okNa$4)VV8a;FPD-vzus3Fsb!T}cw0)da zgaU0tfz0&c{&oo)ktZM8EcMSlwDdP0eJmq>f#P2yZry>n%~9hdhCWKOa7qNL)f@6%ACO4a(Yx_b5_fA!16YTvt-MT2(c-iR{n)Il z9m^LiL4?liZs^AfuePji7xA;&$bOWHpBAOn#wUGQ)gQv_`@bNT5cy$C-n{m=Cxb+M z!3fce$MQTuxF7)UxBw${Kvx04H)sMdT>vnP1AxZpFagNc@&%y30Ay<+Bjg~C@N(rb zQ6M5+c^F5q>p!%W?~P*t*LqZWdpd6{88DlV5OiA88Jm60ukL&v35Urk@20}}MUxpw zP`al_F{ksl!Hn&{*3#4r5iM>rdwMM)?D`uB%kYV)U6%KzAz&tbz6KqoU~M6t79fAX zg=o2K!u4Qz-Xga2dXp|w7Evvpzy(g8xp08~uv9Wwc6sI?IFhcV%Uev_Q2Z7SYdVNp zVU{@lrqJk1tZke%^SV*D?i~k>AzMWXvo_60TRaARSt2%abU7UK-@BakxzXSBI$mmB zKW95`G?u?#%5L3=GA?8Uyp*gr}&2^o~5_alVGgCcc@oY2mxE(I%E@CZjH#8ld0#Z&68-2TG z{dW;YDY8to+}EP`zf>6e?6y_@B7>c{9U>o}$bP#WZYo2JPR?U>?lg+HFj-W`e_2_k zmER)wTHn)&Eay%muRrGLlZ3r@TEnmS^G=v-pT`1!o*J-t(tqa2KKmKMOkgK|Zegki zoc3%J^UzR2g|*aL$L-8;C#5B_3H-AeeTj@OZHk4b8@e!OwX5U*xnyP-&vs}%^BOAb0&{^&CJ?xjeovmF_pnPgho8ie7 zZ>Ez#^}4by_ZkOmo#2+reQDNFm+Q0So;B>dvCuS*`hJ$c&!{Tq@kp_ouFQO8nXaS4 z&fRNls)v`_vklCnIJ{9V8W6u`$VT7HJ3S_^f?Zr0kJK=iS5t3(iw!HTS#v#JYUy?f z*OBz{#-$8W)(yDIi$RT5b{DaCi$ep?;cQ1lfpT9diEka3KDC*0!oBl^+ci?zt>U1% zuPg!1Kmr>b`^*`Gb3I@uyV%wLrACd!SJ{QTPYJk~g}lP-ui0RRlQB7!1+Tf|aET5U zB{%+3FX|ZHMJq4jX+;u8Ue01Kik}g79e0UCG*bD_nUpF{yd)pj(@W)gTELbI7|(UE z4!gYmrEu#7Y(gnmOFh@`*Sv(y7O*bjiUv^#i_Y#Z!Olj7=qGSNf*mJmJ%w9BDxVRo$~n3wfXDO?`mw28IE5WwWb zyO+5t%-n@ zgz^$|Qh^RzCtyVc^AfQ09M;6aX>aSeAL#U&!$Aj5v>#D^2)9YFNcG_zDrP;Y1hV-35B*SRTYVn6L8JFLdsGiF<_DibZ-F=l2W1O!#;Q`~>$U#6i4$ zkH0-Ji_QP@U>EyT+2H6`5ndW*P;kFc%5V5o!0d@$OVd1^&OMK?X@!fQI1&dHfE-3h z91S6P(2>2_fh~NrphczO=<`BWV1RVs+?ONS528GO4YZ)C628@#M`PVGFPZ{O1TUNn zbXq@}sWbk^t7ftdlD;o8Y&;nV8PF3$#Ij}2hW0oMN<8!kuqejKZOejW|H*<+QHKpkmRAhJx6_4ED#fnDVbrA|gKh*fI&98a6TQ z9E=)Sxpe!~zZ_D;8+e(Ic@$O3`iZb({jRXLc^K6Tx`V=~DuQZ}tys(F?JAZ-1dAKz z<8e0Rx0WpXd57{}B6I$+&-#|^{_XSKmCG4C7ogd6eOSd4*Pdx5!T_2r~% z0c2i+^ihmx!)>rm?xOu><*;3)V0OT0Sa^rGlEiJ=R|3O0266ik9npz10_9_YnCwEd z*8#OePSiZK9D(UBa^fUk9rlcT23^P@0#>h-K)-jQ>ao6f;pE4361Gdu99j0wP;({e zb@|tHRg$HjA;5EQpFW_^wwJme z;pJsa#Ua?CEg=;4)&DKZbprr-!m93kp3?^4!a7*nD4R1X(rKNUrsuz%0=Tu!X&Ze) zjWbF6(QS2!{0{Pd~!ywR{qZ-=PKW}&If%zro z^4GQFUfkFhTc}MSJ^*cpEPW9lH$Ye~025q*);get3ouUr5?z4WemY{c3o%?E8oCfq zTByb4rLpDvrc#AzX!EJ+unLm3$(95x!Z~pJ%9H2fd^p`&c^{wDdud}a+lwXhtIQLj zgNaX7*H@5MmY+CO=kn1|;!;H&XqJ4#iWf+RyZ&?r-(juy78RBj(s!2OgxO{)EfH+Z z)m3IG)SemQhYxh3``H|yhNM0R2q*W+Z&f@)X~BW7lINr2!m`jr6iXZM>kB6xro~4( z1%%7nA94cEXytK&qy3qyFPu0sT;}zj3Xb$HT;SCNQ(NOX=Z{D|45^EoBQT8u4G>t2 zfW0^vp^u1E4S@p`z+#X28wy}$z+8-g))|>%cvQPmE#VVQ3^;2M#!yKP9s20P916gy zahN)XoHtt`e;5psp)iL=UdTxArXk3$Qbd@BHCzS|46C8;z6e7W9rTZa!HJ=^#0+XSiV^5y@o(gqYhR3ecWY0m??MHtghO;M^PHbm4ZTxQx84 z5p*_=i1uv!%GaJ?-i6OWIw^xfG8E3*vi6c??m`HWpd@A|V6ed=49TXLKZz%=VK6c# zsXGA@tDHhj4TrLe%f;dYL{u%pv4RoIU^LaC$1g8%nHXn5dzea%vEYN#+B0!798L9q z`uH)@Jx^cQnWn~`v~n#zp-{}#h?Qe`k*KA@917^lASVjSpodV#eT3db7z(%~;g|$f zSU4gjpgXNAhlygPV@a5Qb-|S}fXB?+ZImUyM8~C!C}N+Nlf)CpATduwawX}?NFrtA zNJU;k-ZTnxu-Aq9$1kb?JVZm$3DY=X9)9CLAvSWt zvX_M2oInZjABk7HL%9gm0WCIf=Q;%OD8QqTv!HfZn6pO5CfK3ErkqEe0VLo7Q$?KhzIOL{{x*M(?KYY7A(wf6@?sQudfmufG! zpmbXtmj|`mHCJ1-L+vS0`<=M|u6A-1=!-IbcgoAQXo}%#&qZoiTU3^l-#cF$6`ZT?099=T-c+RI=0CIB)y}Y0qc4)NUx%+MmN>p>`|* z(*bYM+9MzujCQb4`wk$4+KcDCRD0E&(yjet7=gC%PN~M83avkk!A{SAYwiC*?LN_5 z?aO0?+9S~ceSk339*!DDRTSn>Kv%mB!NQyb{HDrBWu$OI5)m-&5G9gRV(}YsBBXOd zpO=JboIoiFQJ90u*F(f!SNjMAq4sP%3ONfOjz#0>8 z^QGED=5n=@tmx#g!3easZwa-71@_CKb_4j3*0CdQ|FtncT_%jydd(n5@+!s?E+*89$eL(eJ%ScgUpT@Zqh8|D1*~Z)*i-n}y>IzFx7DHd<^{lB*c(uMA*Ir?TXdN++KS`y?zngx^; zqaR*itteK>Yly)_3+skYQWSM`MQNPuY_DFdC=CnCe4U!TC1(e;q{OA*Tj94b;lZ~o zaH01XhSOe6#n{#eslzN%kU#!35?cFWVn_VZukjl+&S`(dtE(+i-HDZHx`Yd?(5QKv zetC~6zM|1@I;F$WrEWi?QwaFe4>(!>IBSb25Q?G~XkHy&pndH`f$*YKfd}1qdgDXodtb=LWg$xptGlzKt^3;}IRmWA9n#ir&sP9&mYRMfE)q=_rv(9Nv!xBxy z99Vm$nVi;nikea5`{C@J2+tAMb{@;&8KXq*~x3)sv4+Qt$dmwJV%xC1gs{zU!{~S*1|_WuR!I zFhK!xTqMJpWfLtXUL9zaTJ`9}lVFmn8~LapTG*l$FZxtWeC_Tw@(lNa*6`-Kk<&tNv)kBHf`%>T|19*WMp~fmob4_<(CPx5P#06)4Q2r5mzZK+@chCOYKQ zELWm81f-K2QbC7I<90!-AbkZSkRakpn7cJaPG&bILSX)W;^KQ;hpd|IqIe6)WjAE4 z4q1$)WKpDF@AD#k;f7@EkZ~@EUHeL4m>V-#$DDVUX@h`dxFKzH$OJcJo`58}Aysuq z6*pv%IS&j$4$wk3T4K27FCe!by9irqsJE(0A@Zkn z)pCB4UGCOgRs5vt)nO%cU*!y3a&}yNQ+N)(*CpIlsUGx`Lb}rlG9?*TBP5=nHU=N* zl=f&O*1aN!2Vp~%`(H{4QvL}B;sO|4!jiMUAt~jMN)vR^zL1Zu_-_ zbANjq-r@@yT8wv$Qkzzn8p%VUUK8|>W%x3=>;Ozoj zA%OU2%To{6l)~gkUh1zkrMmJNFVz}|oq{30YMVf5iK%QO6yxeh^+KRD(Zn! zwjimM34ad)JNhx|{2(c&dU=Xmi-qAh@G&p_Q9g4CwzRc(nNVcd$mt3sc-fA zM0_5@anr=@+f|A5eLMANEvZ)9-)YkqF2#S^LJ$X+#AliYRFm6iD~75;!BRK*Gf#DV zu+*w@ZbwuSZVaafol;2mRKEz8g6zLd5jGaCRk+P-?b~7(;r+^@+CJeBd~SP>rZNue zc8)-NwhkD>{b!uMJ1GE51z@)}SO-M+;1zGsHVVKb0l=rRb{$dF-IeQn0qNluqnZwx z<(71~fHZVN9#;~Q{={AH#3C(PAj*k+inMQaz-UnvO$!o$yN&K~$uw<;j#$H4Q2+Mg zCNFIvM-X92B~=QM;*Ddf8`Z=RX+fKU4wQIVNCC{y=2#d)OAGk>IG`rzF&vF-lIT7f zxiExgp-yXl2eo1ysfC>Oz8Y6Yx>o7kZp6phD-#dg<5$i@ZC+RESZz;RluBDG5p`im zK9bTlY=k7M3+qaA1F(&S^EmkPRJcMYCK5kU^k=39;!i0V+o}!fNwEQ&;Tv-V?g7zJ zI$~`bRjDTpHlFr1s>SsrTa~QU*kwIPJp%q=T4J?*p>__%hji`WZQG28oi{)`I+^5j ztU)ogf(VFH7^hLwyjy@@c)z36`!)J|>Ok(U5$``O^*$T#k(^!^#{JR^kK$Qi@j)rb zU_dJBnBoC=`R-)(K`1)Zm6O$qVerlzlhvkS(n`7N3-wf(6f8e{uKpe-S>=>KwM>1f zw$BlaRkWXA{hR{WPq4l{No`+W%8(zLu?;0l8QJkjO>TyqM&qVRJttU)JEyb0YJM}RX~dDyRJDm%6AnXFj!oP>w73c6 zUFISWB(f5>8-INzyV#0114gTVHj~=O6-TS#5z;I<;!kyJ1eFMjb$UKQrSi$Ns`nz$ zjqOTTEzPB>{)^IienFZ!loWtFJRvwfps=Q;tI^G+Sf74HFPuv9eVfDc`NwDn%Ce&D zrRv+wrC?JvB-K{$RS!3pnj61+^g?~wTyjKIY)lMsRiMLx;Sxq}1|dO2&RmIuI=EhYXMzuy8X@j63mN9M+WL@UVh9ww)AKeod;LaB-^oemf~p9+|2Zw38OdZ{Jhn+e^VwS@&Kt zxKWD1=r;0$oX2*Z{OH9HMibGGx~$?WGqcxz$hVCvj4+ZaYK-0 z7x^-g7ZaJ<)z^L1DV?RxCjY*$^7l5X1)Zf@zHR>^4bbW@eKOkqeY&K%?qBMY&Qf3b z+zquy7pb$n;D)MpkrL$AH`Lo*K>zW&+TI3l$#Gp>Vv_=E&aB35E=xQnh{q`LNUf%x zwMp%&1|y1ZnXhx3%SHjH!+-ahS}R@(@p*j%na(8sdo2H*wn6P5FE#b6{|Mr7k8c~L zahPlMf$)RYs~^ToeHvZE8kPIr3HtlE|MCGNNcx2m>1yq+lIt6$#C-0KE6H$7&S{HV z{F^TrQ~4(#87l0yv8fR<(vqy|maftq(|W8HY17)OExVyIQz+7)tva`xG{r=h`)Z%H zQJ;5{Mw=#3B)W|{J^`aqIfGF>lOVPC{|OgT)9TE3uyi<3m>Bbk<0L-a(sFbRHlL)u1Ml;D*E_d~n!;Dx%iyEL%# zSI<#fv`Ql`y?Eum2FyfU7afRW;4~L`@C;|Hp?z!uxc(x8&oecthg91%47{}1X6p1F zQnMP_mB|aC4+YO^Be0c%euL`+I(&3dJ=p`3Tt_e&QewLHCwc=|8~-cD6wk#SALu)+ z<6MBR1z`1;dV)~^kPq9<1^8S5X1D;Ibq@7ifF%Mjzy+vt8~Z)PqO1#%ArP%y2oF6E z`txvH${qsX=K|cs)(~+hbO9O*z>@=dg2OtXCY&D5!7KpZ2|%56?E@W=<6`j(`a-bW z>0*(6OU2(xZ($w(D_HQ=89!LG6B`)XhwrL`dP+SShM_qoD6_rARnJKYj;W!T8Af*I ze?yTr29jXV+u-FoSEQ>Kd%iSibRW28kbk9gR=d)O3|jvKici3RtSpJA%1|5ilA4>Q zJVT}{%xZcsDZYdMMH&X_ax-w*7KAl*+_;q=aUps)g~@9;f<6kgT!$cd!KV1UAlH6QS+z#8lp+s( z!hr#8Ina_bgj$nw5y-BJ5C5F?yq9_=S(;Ge?Z@E%%R_NZSf%(ww~UF(QOw|A$WhnT zl)h5)N;ZNtXuz!$Zp!(y>brfVR#w}2vhzeg>Zq<3(KH6P%+lAe0XSPx2Yo$;*_!l# zibwi$qtLW7+qlYC?9$`Ia8EIrmDQ#bJ{5p07a&Rp__zRy0Q7MI0s){bj3SF{ZOk@1 z&m%%0vb7gKh&+D6Od6J%t;Gu#m0f@z03a4iy68fL3c!Oe^!R?ALy=1elK>RC0PpAk zC+E;FQPb{h{-UlJBn_^1`7|{p{H3WA^!H+Mx(;90XanH0 zurnRPO^s=V<;quT%wVa$@gUM>43=6NuOaa9U}=Cnv{>~VB8`$WPpT7!!13sPQe8Ym z3Xng$r*0l1wUk?*RBsQFf-BZB(pb862|O(=euHWqDs?J*>;$&ZtmkA|O&uz2lD{id zE2P4U|GZEQPn9C&X@%;TR1|w8rda1wrN88)#JyMmf`r8nCE$RSYT+bBXqW04zo}H@nU=zRQyHb_j{ypvzwYR?}YF{kl-cyv# ztixA)`xG!$`zu~CMLEvqe#tjZ1=fs1CyzQ-y+PQc`TVb`%1+jO5C3Euu=V!v@@Yy( z{RA|B$^eq|btRef0}q^zBu{?96Q?UZ{Xf7w>ZqggH6qhCkFS}oeA%q-_Y^ILqWQR@ zJvvYQQXRTaxD%g~tc2I>L(R&%o4++f>FGNhv!tVr|E%MeW+4Jl5-w9 z?&Lp(muQtDddFS-&zXqsbCaSE<~(wia+~cc;%#Ol7i)`(5@#z{752*x9+jp<`R~D$ zwyX9B!! zEAKcLlvi%$!{#bR{fSeue9(afxiY%v6yG=(72ISi_nwCez7Dw?EpaQQIcq*2GEe!e z_QlPv3ce&N_>0ZFb(Ydk|A6{yS-}PuwX5Y+!GU~b7UqgmH}maTsJY%(iR4l{ku09a zA7v@;vp%2l_vhp53;vXs&R5z8OgRA^zl!s-a5LHo$Cwk`dw~+!{OTr50$M;r_bVts zGI9hx0jqt24_~0PZx%h5NS~&*P5!VKsjcGkyE$w(a6NHV!=sIw0Lv*Zq7uy`1`Y}RY!jhc7NQVTy3PhrtzlD-S zu=4m%QOZK)xWfMUFOOWLgf#qmH-vGgKI#f$>`nro6o2=B`HPE`h~SV+k-{x}j)k-y z;_pGE|CfKf2%S`&IsD2ZRBYK#yyjx1wQey%-Th^!%e>EGrD?qz_y94ei^8aBc7~n2 z#Ahs4f*XD;7CX=4I`dn56%Oh%vKdrOq*tt_>vs1qTk>@#~q|9-~NtCW0%u@W?4G}srs$GhjE9Y6C0 ze=%2isntuho{ls1K$SRA6ldqVyhfgq$4>e3<#|{H``DLn%Yz=Lz?YxNQ%v3Cd~vbD zb7`1~O-fLkqD0MDG{ClP=7lMrHgDx|J2Ps~?>f^XNPxEVm;cFQN?{!o+W7kuogZLcei%qL>jrqf+%JTu?!d3<14{TjyqtXm~ z<}#&q-Hy~f;5=EX(idW*G7bELWlCKAyJzV$!l4D&N{>snVls4YadMjM>veMZ*3@^Q2 zRzkIpm?vIDLq6?gj8x@J;VWNO26S5XIBZV?v?TRNsZWg-r7_`(qupIHI>9X^Xb~s` zTzumgjc7GgrGs}kUV5mCN&Ax`X+!0+OV9IFWkB0k;Ds!LP2Aaq_Jlq7jzwP*>PT3^wUmx9Cj}7RXc*B z5fo}yBG`=A`A|D_N4uT;J-ZU>9qOa-w+fY({13ZQUpvN0pDzRv?24(+{a2txws-PQ zE0kW^8;?9ebL;ag3flLGg6i{6S194yrH{j#)aO?yJlPfAXeGj%JPt3e#|N)O`0o$- zoRvy%?dFFb(l6HIyD2C~1O@UNE0r$VsK?+(*82(SH+4===bbL9cwvI_Z2La`tl z-6NMh@X&e=Gh;N|QlFYFN}<4Yw7W^QR^@|0tvw(P0(qlXh{MNG{|?}TUm*_fm54A zC$9p5)AzV-74q=uJ&_02#L2%|g|TudCfTk^Xa#Je)xfsACled8S_$|689D(M;46Q| z^9fLNR|38u!2HL6kpSEvz#tc(^%}5S#{+nh-Q0(K+8U^p&)ne!Ym^SG`$N8Sjgr8| z+~MA9!Rr18yyH40ln-93)c3!C+rvhsALFyuqQH*c=Bw6X2)92D>yNM>C~VyAS6_wL z((-Z8#yX70zlxy0Z}F)Vw(FLMx44m`BfIqv z$A*_MHvS%8$(8wR_&>b%I*i+2-z9!~_}_w7*HvP5YBQd(4spx==6oHrRo1`x#dXN* z#XDU08uIG%H-Gju#GQ4ATVF%m4=@>Y#r*;^i2bi2?!24)*Vn*r@5f=!W2VsIb)|WL z*5wD?2hJocJHyAn4(Z^+Up)JDr3?G$FTUe-rImlqUmmKTVlHtNG1)VJalbc|Xr}** zC%gfUGH>zuZzxfXKgO(;I3QUNjcY9K8WoMJ6?_LY;`2Rze(B1j3@c~pJGCge3Fmeti+F7b4>9Xho1$% zk@&5|kNmnqPV&X?+Hu9}Hhv86Wz>5q_8PE648~es}SER9^IG zvocZfcXH}9Pb2SHj!i!n&Do05V}%#_ifzi0Fu#i^=IHzBP0bM(=}xec%RXlBk-p}V zD?T**+Xn_XI0H!5ej9S zQ3e@7}#1Un5hfkr6eg(fp_!Z!{5kK#EPBk@&BvZWamEXGNYQ&|l-dewx{Gi54#o5RPI~H# zYE~#a6+dkeZF{5zL+>Jf}$uJ3l3ANpRg7&hn0dTV&dRd1#AO@u>ZM1t+rfxO!f%1L%1x5)Q` zQovZ~IKJwVlEpq7P~`Wc(v`9I7W4jBP-^2B7cIM@*cG_mV&M^lvt~-L_z7`E^WtuII4B|vi=u-f zUE$=8qJ+K$Rmovw?`_!7>Spe?Co+)464AB|GE|`->wyrV8P}Cgih;j%U0DY6GKhix z7WEjEj3&Bw?}W3Qtfoj4PuG~JrQ-Gw^^7#5GC&aQuP%3z6{7j}50z$J$tNcw`Ly3K zacG&z-~CO=_8*=8Shnnw&O80C^w!{BW**MdepkZ$^;LoorSbQFSEl<U3_XdINb2VNb^f_PyiHe#BwxQ9(^ zJE>LRDs{3V5DOt25W`|iEU>^Rq!c&BJYR*=AL&Q<`mw>r`L$Y{~T+ z*;f>`q{QJ9svu4Zy)wMU6_#ApWdEqx5;vMvof;nytLBwZ%|OeG4FvhwNC>9pg?Pww z-eDg~evW5Si6wckzIxIev6djh8s~d+Pdhm*y8h=Z7_hLsG6d)3(CJrk*>P&51$yXI z)2&j5H8C|l)f^oko~}!bK9{bcX|cvsq~J!2&M@8i!^GF#P(qY%`L-KMck5Jam@$1x z#`c!zQ9-(8BjC|;9iN(e*GHERp%(>wJ|h`vpgx9Ip#I|4 zk!_u3`}k#= zPo2DGjy^fJ;UK$DJ$~_~qPI@mk`R4fx70^ecj5+=hb|wZxtHDa=qhF|UZxyK%`ie< zkbo;uaPdwa&I@$XwmMu_D)Sjw>B%ORQjLWEpK>ZzlaX(kQ_RFqSRKA-mZU0!#f~`N zD|#OCDl#0Go%WxrXK?D4NcR-II5B~xvJI^8r1`%V?UM~UMf%=3g}1m>5=A>*At>IriD98 z6QaMLTN_1~sX_5wzg&e>3`pe{6S1r#XtJ1N^HsM1=h zWa&gK_A%lsJmENihDpnNHhe~1imxui17(HEXdPy19R=7lsjdx2ecOgxL!%1B#(&rs z025Bf0Hg|YV2e5=GFFX`LOy1joX;fX6=%eOYPh-NQlQy84myKd8JdLXvhMdP3 z_8ql}E7pZ42I$%(mcvcVT!K3i?n(=;Q=&$O=@S~+K6CW=R4O0c5^D!E=d08micHcb zrUWMh?)a2}YH+1HlSX6`7o1E?2F(=wQ08^2Wzr}zNzKt*HHZIu2CYx#a2Rr!>dIjf z<$+GSfZ@Xew@{e2Cg_6T4YS*H6JIp;8Q|Xjz$lX zy{OPjm$x4K)u3wWVYUx2prTFLeQ}l?T|P7xJ;8aX1xaHvc8av@{|H!hz-)|oA=pMR zVD@9gG#7&U;OiC;%Mz7ICWVHCvJ#|=9SLatBcVz1Xl8JkQGT&Cvu4?V*=P!)=hTYy znhI)}NpUdaA8uB0$OhU_A~qkyN5$exoQ(nBnUtJYoY{}I@q!in&AnsL<-QC$l+~-j z7(_`Qv<9+GA-$;XmnHOqd!4RM1r`~%Cghf;l5Q$1qXDhF>(c;mkLe=`jM-9>geyE+~v>q@3UzYnu>E_cohwRz^(Fq_P-;mr@$j0=pwN z7R0oSwJkKp+N={|kwdg4ocWGV30fs1FT+784#JmxL@~aA*`@JGU}8MP zhVwZ0Q#4V(OQg+I6=zZ;%A+>!?6pK+NxO302UwV1C1%H}bxkGLyiM7c6^yhnLoZHL z6TM8OCWAu5PNLPOB--ZqnrxpJ0wM^=u&@L(xF&aE^o`7f8$!FY!`KmUK+wLl1N+jQW7Yn*?jprxsDxF!&iQN01 z(!oCh7R~Oe(oN$1?kUZ!kl5CQJ|%z!Rlyydh`OSKyuuSy9o^fee&bBaN>In4$S2_w zAU_nQN%#3+>T%}e9m=d7Wx<~2yw|`y`gh$@YUGLPpK2-Q&!`J@v5SSzfE2T8J)YRJ z_rZ)h&SEGoqYtOuxIT$CkgIzw_65$w=o9HdgY13>6Cz41cAo=xs8sAjeH|SJlRob| zw6x^wo$?N4bf$5nJw6o->qPargODWZxT`s%zD2!GShG4bfRsZ$*Pw?l9gqYX)^VbB zbgXiRjU?e$`9wpZgEXUWqM>LgqGHNjZ1l+(mJmHNH9b*8um?KKYJVi_YgUCIb}=G?2R%?)*Ra@7;<4PMu=;~HqHIlSg+=|# ztlo%KKM4&IAH@$Q$d@JvnAqlID*26>vVT%c>VXo61`=kT0J%DEI=2kp)ofwfz~6bG zgjpj&0$yfg0j{-H^Frx6gF7m=fVLaKBLE(v2NRrF)WH~u21Kdf$Z<%Q*9jeHT;5L^ zV>jz0H_~d8bqVu7tfn{n|2ufdkp!Vhd!I?pCOGu+i4Jmh|AN12TuNi8@>A z^B?nGve1#Pcz-P4(#PV5Mq8yzr1Scs?~5)G4P6}&fR7Y}64jcfQlkOizce9E zu=ys~Qqd0@gH6Rh)r>1hY2ixORA6kLXq%1B5Zyw_@90W@R^kd$(JAK1+kdHz>m0?) zsEccW1l;{1O){VA7iCWvh`vuWYwRF3jWsl_uN(YZQEE{=p(I&-PlhGH;zZ6J$KBG(!j_Is>-mbGC&rmW3p z&6|%Kk8`MI&Nka-W|`E%S#cP{6KR!GZD2PkXv0}+%UJ6UkA9`Ed~vGins5ueqx}lv z3w2`aiaOaIS^x&f7OXZrQ+cq$%;9L;({Y8TT1z!yn9M6_hy3SWs(~-K9N+}|{O~Tf zOi^D!1vKLweA(ot{YHWrnj8FwE|yh$ z;C9mh+?j+Hf7}s~$2;kmo*(pO0c=eHH`QUy_+4LC7ewmRVojzus2=CtTxui(d`)8c zDn1-np6ZL%QSW`i5x<~X5*bgy1@7yG)o_+v9^lVHtiR8%7S#CPNKC9w;;$vuIrDdM z_G)#q`<{Yhc$pVqrEJs&ZBp*(9Od(fn-h*Z)iaj=RCFqbtwJAs!qKLBY9pV5qe0FK zBGPXP(jv7MSx&1+?&a#qHGC>QB{$5K+!tBZ%FL1TWLbz}?^2y?aTVM`e1yE8j@8g9 z32G*EXe04F=4ii^+C|&glhrddu1f3{rLrxw#Q}DdFIJtYjyZgD9oEn~S5OjJzCRb8 zMXoj6nLd*uJy$)AtLU$uZf{?%m1)>T^*qs}cRvNEa>mzk!l8H)wK|p}Rr33zI*$vV zicjUd&y`%W>d9H2f>Uy-M0&L#E%F$I)IP)ahWp$E57s9bu2Y4=A{-q?q8t@_E;@8m zt~JVQ?hJ|=Tb94#aNm* z0>dr^9<83~(QZmrx_}*G3FCz0AuKeW>SfwK1;@NYjW2&q5xp33z>R~w)4qi;vc{$Essl}SIS()5gi#4};T^H@>=jz!{gLM9M zXtL|U~%M7Gyh;c7D3}7GvX47X^Qd|(%qKiM%fO$n$M)!2gI^4+iGR|RrCuO!SD%Gh zX@%5CYo$p-DgJB_ZD3Ckmv>myYouVnx&-b{hJ>C-x~TIRD5;y~l3#qpW#X9qqu-rd zDHNQ;Yxt5b7pm%-u~D<18up28M9(}H*E7>gx4Z#;t+we_+66ufBJuCKyc3jHXkKvb zURBu`YE$Piv)a`mH7Y`5pv%M55rrRbF!zj4)h%5Km)JjIa>k!NQ6p?- zwhzYaZxL3U#O%)+hyej|I#ezjQR2jTemtmfX6(B#;Hc~FBrR(DiBA=@W7 zOD$p+E7TpP>_tA9FbH`P#Y}n>GzZiIHLj!#lg{oHIw zv@M2gH6TDSVXYj-j_8hx1g?}8vdix(~OSOs{W(Nm3=4TZB6N2JkgVK4+W=OhxKA+i) znOS!$-`R{k%h)opcx|XK$~4RKDNVOQK#EB7h@)Oj{+xkDutg!;=Lzw*m&uPoLf}zjbvQ8lHXv=!B#xD`78y_9Puvd~ViC{z7l!g3s1Z&TFE#yA! z*kq=dir#<}dy~s1#gX7zC`G@Vrk;hMl@tYkn7YgT= zNU#^qGb1r^do_}8h-6`{W9L=F7?F07OtYR6}EW#O!0Am?4tPbakF$GWnY{WH-n-P*s=ZTZA* zY?gm`6~FJ>@XOs;zm)#TH~_}W2yCn_t~l0a@=@7IN2pR@@>Q8wkt{IPqBn2ys|~Fe zredZ5Jd^MYGUqNZcBWS?npPw0gvd}V8p%-!c} zrt1TKH``azyx#FVmS{ny7)wetbM-abmRS$N0b=ENlr8%ff6l{D}K-TFJ*)gOZ9* zmL3>%%(fvZn7PyWoF^Q^K*Mb3lqPOUp`1E7(SRQ%Nq$!0830cr5k%vCfV+-tD@94= z;$Tj%j8P_N)_WGwu|snQ(EwRRQyQz5Q0yq|<$=ZWJzSonE~DDfeSFX+UJ~pu|Mf05 zM+cUr`0i$zq`ugsit7etNo zYM4u|dSk1oD)_V5=QK;m{pAuZ`h<|YD$0dsHD0myfjP1E{skDgao4%Oxa-_LFw3bY zy_itRE>q0dV#{L5P{51>;lgm#M?pG75tu>Dqbp`m4qJbQAMc{AtWDRRYVolL`AbN8+|FS1D)g3pQiu#B!<;DoQER5@Vu_o4> z`J$ni$vR9EhVPGz#B4dDepF2?dDwEOVi4Rwx=8Z`SEO{2Z3bND#MhG(E?qt{EK<7u zkYQ2MwNtuCxdUCE=ALw#WuTvom?T|iWEhEqNFqhLQl#sYbfrqy9_gAbT`oqmq$@zu z%$BZqB(eamv@EROCZIFb|AHk3Y|Eh_2%zww(^ky3+(Mw7`tZm852gP);U7@Ve}nM9 zBkC3AFu3tl;x`Kaa`Lz3Zh<3vA$A5uBL5;augR4BUKx#&ZwL=h^8c05D9!AJwL~-# ztFef+{Bf-2GL~c_L&l<%vlrI(%4nXmP}Fof#%IA=9g1$%_mMba3f3jMJQ%5<5NcBM zg)TSOm;A}3+T{+AZu&Y!c#w1lx!nfoHn`p4(k;3Pq8BOMk*;uSZj|(haz`*qx6$o3 zOSjqWPLghjm6CyE=}vaLQ=~h^?M{{MRJVJ!bkCM)D1lwKR9S7T9#TZA7iUgYjKK%^D_c>6wVL>OsQS!OL$ z?&bTju-QpLH~3-=avxTN8)EF;NY4AP@0D_%(U(Ot?Pk8UFFV3^KIDu0v2=gZNhjEc zt%L60p$p>9eyq82pEozMlsdkdwQ?YI(?G#L;IOsqxiU~%Z2`pLsco@`<-vJ?yd%7iKXEe*e5ViAE&=#05C60^%GuMo5A z{=`H2vyLE;*q@mo39anU8jK9jUi8Fi@tC#IqK5%xl5qQ?m;tCYXq9r$0ij8U!ql*9#GQUdY-FwllP=xGC=!!y2wr#sSPEBSF|Eb~U;@ouVVHwCDosy`HS_HY>hkMi z0Tp~~7fOCwm%c-JwJ(HX9BWf#Al3jwAPzWb{8-w_zUC!T$WjT%J8=?29nz$^4+(_O#j-|2}{@@?Pv8(`UI%-L1jovI1 zBHJ=w-eCZw>~g+%00dvq~!_JKwi-CA4F2H8l$}9Y(cnF*&e0@A?E|PI!u=WSDO%MF-bm9w*)ouF+Hh$`9TEQUVBoN%~ z#wVKD%V4F_%-Z15IDxetnH2)#0|O=xnDs$|fE7+1H3qZQG0%V}js9v$}$WFcIDF zs$0wvm_)h4YY6Y(xO1Ziy~W`xvJ~#r9m$jxQO7c|tpWeiZA6e45m&acZT7#_hWq zEv1@C6$Oxcr>SnqGFMq&)u9HhwfVqg*1RKqKbSsLVvSUk7~b!|>Pa>^@z@N_k$HOr(G1 zKvyD(YJZULe+Tzy8OYBFdIQxpCyZ2#c0Vs{b+te!gW+8C;RIcLF|d~s9`n(S;uIr} zIr^Yk7jw|$+?QY*=!lK}Ax(v9L6_H$BxSO5NdQY%JHdtSldl}jqJ1srsMN=W^HZZ) zWX%_9z_M*cIj{9Bi)ds>uwhWs#a7@+3pTc9cnNYGIm;8DWphyn`>}xLJx`ppY2eXgFhyI}iBB2>g;(Fxe8U(v5ix2!$41oKh9+7Arb=-Y32F^zS@h0u zKI1v|yz&`8@f>T(&PDORpM!d=oJWmi?TNA1oGw~ zm{T3|GWS7U3VG8ZxvCT6%fcnZ|xPIa=w{Q8qX|NDRAC@=;c)!Lk0+CU2w<7A_EGhj6_Z>Zl&Od4`<j1rA({~@;%nAII(nxn22 zlO8k|e1BaMRlm?GQvkjsg|+FQ-X8GiN3h^m^To$$54>ZJxD9O`tf&V<8&>M5@hefZ zQz)fmwn1~@Y1{iA@ZVD~H$SEFrq8oh+P@xAZhMEKf4{zgkB3(*)sdRxKr!GujHRVs z3zmAXini}r>V>)zSI5bv-d3JL)V0+6N+dt@JPYeVQD9pI4P#`K3Ccnfy1xXh&mM=q z6JN!5a;2AStukA<)_O5ECG)TsV2m5d2fo0H$jzJwBs#0y7n#XF>fU3D!T0#77g>vc zv66081$FK&51hzGV{Mb0`J9O?yx#;&ncQ5(;~gj79mhsnG!@(}K7??na;aCvc!_WM zg(?vm+~pM$*+e3jB+0GDDC;IS5AW5;k&sxG+^Q-O2HfErCqbJO$?r{q7_$-ki3$g* zpZpTZTTNzZ!2>T*lYkI%%wcPVpvTRk_AS1BGHVOD<>F-4AUr&KvB3*+0hWBR&v7se z$E93w5p%|0+#}PT(nubXif-cKw|rD8YsFqW!mX)LILtpn4N%O6&Gx)dqnIPpc0d@i zggZG&gk5f#?aThX_q~dZOzN4QT+D-GTpB3#F#7eQMRZqbM?uSOza8s+` z7Q)K2yfm)Di!YnXw5%eGzd9AmOZnAf)vFTAy$1S656R5u4Y8a?O;hJ+(x6&;6^19X zA^2)pJ%ueE9Pd7j1+&IseE2kG)Nibw)oup<(KKkW-wowQrm;3rjwbG<$3Lork2HIn zK6V(6qD^3sZhRg6LwURDEJXiq^*Gth__*oN*xznR1I>(N$o83-Lb=y)j5ko5&I7Tw z8ObJf8P#!Yv_rR~HtaCt@@{4HmPI65)uWq2MJ(ED;e8Zkx81NXJE~ z^Pz%7BTm(%R>S|E4vAXGbGccmSgnjuV37}#brNw)QNBwdefeHfPgP@ub8AX&TL7=CgZ z%8r`pp)b)n9@VSH<`+*!M2zneum^)A(16#RPTl8; zMw7ENE?R1(mY6<)878a?yUEH}QJs@%j|t-Bz{izw1x-D{zN~`3G7}n~@IOU|xtT^& zSo!JlQc(xQ?L1MEPkgaHg5r~3?42$$a~tbd`!Y@k6Q##+LDujjSu9E&cWesgoo2z1 zCa^hwb{4+R5){-^oyFj%Xu+mo84cIa?p;z>Wuv`Nu_o887E%9HMD*q>g%qHEH&FHa z(J_(3biuhlG5Y7UJXw@CM~LM6RbBfmZ$b&kwNFe)jqZkR#z$RcOnB{gf~^nTN&MvQ zpZ(YzcI-YrWHxKvb>snrL|lUYYWqwo^#OT+cPolm&SE* z#zFkz|D6q`yMZ6agAJLQBR(Vz>sJ+ZrF%jnzAz0f3^Y6ps!qQ-)+QwVw{(I;-@{L#FeCdL zww9#FO;DdZ;6nR|7K9O;xLJl1ekGCLML`&{o}xjemDkaoQe&ACiwhFWD=S1K)+mUV zrGxkEVB+0?oj&`Krs-DRfhd%hk}+N;(NHGwPQ&V%`5Y@W5)|typIHt0tPIu=>r_-h z%+!#-nZbhmil~{2Qe7l@G5G!qxpp3M|JBOkJ>5VScT-mmK5D?bWrF2^CbGEGGFd&g zQ>JZ*X;7WRS)Stl*-w%TXuywWvd~5YsSHUZq5?fu$6cUZT*SV@;eztRdffi*wR2}T z#YIfj^OJK~{g&Zq(lUQXwN=Ot@sQmiGh{IS3)zjNpB063xsK#fE69d48eEmw$=Yrn zd$@@04Xn=NFBqyMu@_y$Rt5?l!=gMqmitxVaTv&=e-Y_Vb`^X7K)!w+3t~Hi_~-Lj zGd5Xfm-j-Q`t|jsu%@-~Z!@&%NAW%1 zdr0!8Ei z|2xo%DY^CEm4`q&B{uq_$CJiFK*RKb{Y2>l+ZY`uyklOea)GxAu8H zjGjDlAqzC@M=wdEi8#5z)l*f3yLq4F%R4PZw}>-{6Bj_GhqJQDZAkf-Sld0Zm@8KM zx_m3en&XP~AfS3$DV|vWsVQhTJ@gdH>()MB_t&g-QCjyDhI$M?52ao%N)w+#fl`2* z(nqo)3|$3=hM>n^%FfpA{GX{I3s?yd9Rs`Ls=jY@qGvE9pbZbQ`+SYvNIqtJX1UqB zGPkeS-08CB@7ENu4NIx*iec_?8mC&h(+GE^F-*ssWw9Xt1l{8%-N%()kWMsd!wR%C z82ggIB3tN^=k7m7SIYF*5r2X1VglOa+#eVHz8FH5Y=gRx#z2djSuBo4p|LCYx5oqu zT?D2{0_?|n+`b5Em=%}#PMr1IX#Qo&$Q=@Cb+k=i9kG#4AUt=7`z&Vd41oxSuFg&) zFHL72e25X)zCJV(jW|Ia6S;cm^LjpUG1FPGdOST8=07k&F%36~yC6-f5fkzoacZ)! z>M*HUel4%jUcj^P_tC{(!(}bbgV@IqXCI;D-qFm9M~y!-?xEAXPF=nv;9aaXdmncG z7~69-+0kd#!08Gsv!$udz3WX)xkqYT55iw|{Sy7nJ>hG;UMo($eBB35SX3V{l_^kY zIZa>FUs4i;o759Mb7dEB5<-V5|C%muJ6_a->h>d~uf-Nr)9v!O{C&Fo_3)2vS!Qba zw@E#C@@meHBk(UaqQs<@n{qC7!M~DgEax)4n7qr?!zEXJtlo!ne$?S#ta`{)a@9B1 z`;dCPr_#keZ!@oQ{LbL_J$^sqcMU(j(FzrH1wUwIt#xrfki3;o60aHh zBmT$=bMs0bmCd5+UM{5;fHNF~mdO#KTIm$E=d#=k#2vjv&p+FaMUS4Ri@Co_)kXVPnrU(O?0G8uT zy1Fr25^OOLL~bNv0YJSM72})P!o5TX)3HGTiT0Q+(iASPb8%efLs!=dVuPYE`ND2Y z-Kay@keQm~^JcWJ?s8$AZ-F8qn?SI?Ck>srRFl3Yu^N%Zmo8x~cE z%Vm!7flYcB(Q@`vk(kDb9TIX?OO%-P=_2d2`{^RU*7(o3eBwU=U1{ZV3n0} zXEsZ3^76M%XD$wjhKb&q&}^hcCWn}QA8~Bq_8drZl|}sX92j=}gqo!tNS6p>pAv4d zZ4a%$JE{&=Es3^H7F+jNY|#)}N7|X-GRo8yypEXIBRr~@+S5*ouGZAm%@b`VHY(jW zvyHpGA~Nk!kwIp)yh^i8@U&Y2$Of4wS}tvXhRQ2THdAWYD7vJe-RnJ7_=;AA$|-kP&dftsQxz6oJS zl-E(bg~BgPyoKWpN30^W9o}%%lu+h=BDSC<*f97{!_Fg^S{;ark);H!u5&f5IYS>( zunBCc@m*2Iw<|2TI+#8ecM-=mL1wI`+%k>3{K;qlR-OM_x&KSsclQdeVn_2w(fm^Q3EKID-qjMI9bB=`WnL1j4%%d9PzLqz?lNYZLqPJy`hYB?)l(@*e$ zcE}yOJ{N(?omXuviT`eAc`W8QPhWv}I9W#U@Xaw9FJL8mfwefsGgh)5?CMdzX(cOT z#-n_0A-j!bqnWR;5LW95x4#0i7Y_5Cc-Go>nB)}$mqaES9YEQBYmW-aQH z0DI(o25vOyofMT$7cRPE_o8ax7Nx_AnjLxG@>pF)y}YoP`A z0`TZHta+m-Nytv!hU49PA|7n)PL}e_HPCZ9%Zk8D7*pmJefcVTT~W>#C9h*zALUrl zr1k8a0v)^QKg_6X?KVKtpxGo zn-Oo2JEZ8PEo_@FC`ayMi^0I=T`agJoJWgUUp(rRkR3x&VhNk&<9~-XT4GtEW~Ebe zCzl^Sz}kl$5PrDj4gr~sDxKP$xftnS8C@4k)r!Ey&+oK^-W^jQu@zRaNZZhk9Aa)s?PB$Qt-bI`QtjG+l+52FZQ#h;j6&NPy;Mk4c5ao5ZkiUP3 z_3$;UrgUqM=06=`mWD@Hk?ZqhN^pdcG8yUAk1yo$hgt6iSGzxSUT=a`Pjkds%ueX! zp5u<={I$cZdq`X%4aP8(Y2b>Kv65)uswhY2&iuE-=+#!P4y%@aF%%(M;bcD6Cjwd@VI^XBH(3H#`xiH|M>oFEkdC>Zr4T+)w>hf<= zG`l{>9WdJ+a83pkxC2JH14?AT*Y1G6?tqOl;13FjphUuCNCw>^p@5!9IY4@5F5dMI zIu2xH1@C^8g~E870CcN?UHb?mP)v@mLLNF@up=V);O?48#Hl~M93!riWoUApzL|2x za1{aU+7pQC)aTpzM@Lz^h|SZ{Y)R!BmxShCvVa;fhCU(FK(@vCC$IsI+gPUQ@Y1Wt z*lfMucCuR074(8Qhh79duy)FHo_~xzum5Vk_=>Cx@t}E_#jed=$nPIxp>@Y%(Vt>{ ziuQqI=FaDl$C)+w*k{t)1aDn{=9j66snQh^TJHt?$Z^(UL>atvbrS**dQ`lc41ehY zwB>mJ3;vO+<``aWrYL;A5yZTz&C8;5Oek1)gs9g+$uG7?qAiZPzYlAzsdg>_Zk$;^NO# z64ZEhIn#9dDnrr%V~a3%4;lG?qQhsEV=-x-h_*g-w#ew7P?Qhyl9)u_!u6r_zCARX z{BriE;32O3-FF&pd`Gh#cd1XY>-W+sr0`fio;p*z-gw3hIU^x&c_33+{y2szT$nakfe z$+E4_ZvhyJYP}|8y`#qY$Kl=vToEPzwZ`mNGr1MSRvhXHfzbxD7w;+nSb5I82VaB0q zze?kk-?CLLUQj7(n)Gz4p?oiqf80u8+C@D9aJAF;d#BmN`on+&f!}bdT3i4DM;sT1D|A%H-7kkkj-*gf)leRQz_M>&-yM0I`RPFKEy!;G= zOidcUdj>*i$jiLvcbGbK;N!o;I^js@WgsRMIQm40##N&;u@3i13=Y(`PP+lY67aKF zegR;M3()nbi^Bc3g2H|`V5JMtQnVSwI41$`x&bqjz4$-hVcIwPc_b>DOaQeFyCzBS zu0MpFAPfCx(a3*vsVw|H(8l3ZD{+M&3Qyb#VpjEUN^ApxjVh4XuE1hYLC?@<1Ogyh zT2yTe-V!1XnM>|^o1@RBYZI(?ADEGAy2AhZkhzJdm`(yxVlKG@NX1-e5594{*`MlG zTZ2$-Ff?X_SnNI!8Ze21T#FUSQB)4SF9LIUCepI?xq^qAJtv|eD_QVz>R(?b+1mw$ z9`eE4oMl?;8HpGo5L@#lVjCea(m!WW_3tAjK|KumtLaVTfLWqT(zS!^J~_xh9=xv) zn2SSxG&ur6833YqE>1xxcZ@KS&7viu1iR=!o;0q(j7Imvj_o78`hnw+7(@g8uJpjz z^Bl_6DB0RIgBWk(V#^4&kedhaG^?;2(qEgw|31s&1Lhzm0zMM~`fW4#pmQwD6bc$p zlw~HU`Zjp&sZW0aUrvAhbUb2JjTU~f(R*Wc{r9SRKLHpg0i*CxwKrz+t>;)^z3)I3 z@M5H4!l5_%FJ|)Z&cVp@j~U!>p7mj)X7cgpS*xH~l)Ai1Ue%66+p;BMbQ=3SfAc&< z%8#cZ)V{VD1prQWz~$7>%az4FB!E2icW5NWfDnkU=_P`zTD!ol%%gBz^=s3A3kJF!O=oceI)?JV3^eUU5yYg_xrDiO=U6uE&K#11osl1td z<@c;{zb}V@0b58g5U3|DJy1_bTi=OzR<)-v20Qh^E*3r$8uO5D65eVWcYM#9wpt8K zf*N=ha8&M?$~4Txe9fAE@q~!YvnI*K~%@y8yi?Y@#n<58Y(`%LNwhyEv6% zuFK{PF0!F@*DgX2MyF1`6oVsoy4_3VSr=Jf|6c&I!X{TJDckO}Y;;sW|j z+@66#jWdFw4FEY-^1+vwk^M567hb}e?~%#;!%Hl}QjcJ&=40A3VP6{nBv{`8ms3AE zTQ-14LWQd@qyZ7FsR^|vf}=GFTutCCwy@cgdD9;;&uoy&jX$#f*4n@WdY?`!vX96H z+*iO~uu8HSl59*BvL^_uYA@m8)IWoKgKSHL$J*X6q{(wx{uVs09eX`m)f@paTmBlj z%ktOZFI7cZ{(9HjBwgECnqBDDCh4sC8{nyG#)}9$MT9*b*euP>A9%!Nwy(z{qzZml zz9{%D1|RG3>eSDDN%9*3dsqyUxKs(MTiPs~gkh!4aUOPs86%s?SVqKZCu02p?nxHB zQ0sB56pA$)u{s^+Yp<{l^-Cs*v?$hbyuxIC5kGSU+Mb6?inKqmkxJv9@Kz5}vSwY| zlA9Rb3s6O>Hf%!CqMwt>`!}rf?lj4)wWB`cSeWKAL zy(EbAnSlq6>qERcBA({KSR#j!5!ICUC0dVXQ>mtnh~iga#-Um%h;d^a|K}%)emFrC!=|Pa5tc2!FJ7^g&{fnUP<6CDRn?3nNQ5Td z%|diVx*zh+;l4Uh=yvoAi3iu`cJVp9tJ+FDoch|C_<-lx_H$05t1vAQ2Zs z2tghnxgZZckedwzkv$&BQWs=kv71V{guEspR*;$C!hGn#Y?7F{9x_H3#HYkf=4A;P z=7EH`AagvB$r2Ljf!vFcS^CriiM2|M)`R)Zg}Lv+G?$QT!R~BtcR`Z(x|w;T7uhcJ zKwfb{-uFPxOUQd3$V>sT+V%DJxykI5m>dsgkc-TC4`i)`jPpRkU64;akTeO2_CPd% zV8*V$>w=^>hDbM052UKkBk3LI&`iJyzeTZ!&te1cdm#`lMEaY<$r1@|(4ytCs)~m^a;5|H?dJ7>{ zO(sFmwN-#>8;WJqOch>oQ2ks+DHBoJqzN9FVA^D^RI-K<58#P$L)Cvnaa^QF$q1<;!qnMA_^rjqsOUONFeF%v8H zMF6gWSxDiUzedtb)fr30hv^QQC)9c)X3D5|e}e(whB-2M>e zDGqDozp)hT)PFWruyh{EQ!E%H^U;6dP=lZOlD}B%-Z#N6_2UCUK?*N%g<@lU<_45X zH~MO!UNTY>F;amf7CI`^=(<2nn|=J}zgUN;U2s~|i5tx7*mW)nk+@&dnBC`V6ta?; zfO+mihzcThq~m27`}|%$=q78`dQ6qr*dCHG0e1ow?e&bc!s!2m<88j~CX2Avssb+6 zyfGZ)%{gU0C?G`5{1kl0+ICdRQH%~!&c8$Nb@P1*0nvvZIKh9jaFIY*CW5@YjN~7K zWPu70{)8p}vV3%9*!WIwy#L=2Un{-%i+?j?NaZusa`k8FVYinvQgL>5mF75J@;5AK zFM~r+4EF|MRkKFABH_Z=>JJyjR;!5amaB8%a_Uz@RiEAGSUj?)%U^}m(NFc*K{T`} z0&or$ipF|=7$vRmEra4j(AN|MO&R&sRkfXj=f@K7Gn}XW!&=4kMm!|_^H7RTCOO(` zcy;Qh!=KuM4YMgaL_OKn;*x{GgPJ%BWd_zX@!=!&_8Hg}&-zlCGz>Ihnisgl+$Onl606U_FmC(-Uz_jw3*F9-{c ztt2Vh*V4PtRL6q@!oU&){&s^8Fm{QdcX0YXs9bYN*!wUyZX!7AlIf|ql>0o?8 zQtToDY?jI!-ex`9j{_TyF%ck9?W@Kov|?h_PpB(jbQ{?z;UC<_H1psPN^t6AESQRo zy4sK7p=$MUViw;34^@u}RL8TX{VCw%CU|0?c zpz{@!SY7PCSer(rsJhR!b%?q?2QEw@@iz|U=k;*1LZKJRPEA4 z%G|~mWnFFH`g^Q(?D^R+7s#OmM+JqhQ|8^__NsCe~U-eyK4+0O;SpTH1%d&2SUe+V6;sw)x1Wructjp z{pTqzj+&Qh<_o|xV7_vXq}^50?g!dGV0rxkYpZ|79idbcPI#aP?BPidU~~L4Pkq1& zt?vyK-*P@4_)H?v3!&1ia5?o`Q8Vfj$^qTsCHbh74===lXMlVd1O-hW zqG!vm00cc(Kk1@)aJ7*xLaJ8LJ)(;vM?TTd?sEmFs}=Y-qG$L&)reClQQ z+2IcIl|jh-0t~lEo7mgE6Eey!udmiIxe5|zH`R3PEh7O1YeZ|yl?G^t>0PATrg@u2 zbrn-we)l0ZRp5XHjU#0eT|b~zFpT2kSM}Tb5=J{3P^bP%is*}ng9#D%mJIAI0!tB? z-KRd@y+{YD?Ta^oS|m{o1Zo3NW#Yb$)?V&%4o4JK({&(lw*0Pel;ua_FUp8|{xZbF zmtSlaRc1f{_&E%hQ@=iimpwxBv;l&T2PcYTW|hUgBqM6xC13l96u`3u{MvX~!`*69 z5>cRps&>`2Q6vkP7yct!A1yM8lLRcJ8`gx>4>br#eDQzW(DefVT2s~_7DzJOL@ z970*Up!eW%>c4j-T#kJ);Ez(kDF25*3jV$kus-AYS57vO4gPv2RA;)jqY{x^sZE?M!G>AUp z5(%;#G>Cp(q-U}Z#ilOpX^b9DeLT2!wB^Oj+ZcFtGO4OMINScT7z)xgDMPMsM$aZJBWV)>Ov9o;S$1nDix@9Xs)6#yU9KCC&S%@VY+U zt*s|_!f8+3=tzC^fL8iCX{h|+et_|pCVGa?U4VEA2yg?=13=SBE6H#eLbDuU67dHH z2I;YrXgDtX@&NV#dQe z1gvrc#<~D+y8#;|V2&Hmn*gqVBn`lLJtH)T4znbChi8pwe@^{!tfFmI9ADC|Fjc?Q z1j+Z7d*W&^B0G@X@o?(Dz_(?#b$byA08i7yHNU;vPrzymScZh{kg%pzV5cPP3LZ{< z9KoV&-5!Y~^c`Kec&G}F2wcc|3IW$CMx1h0MPpD3g#qv9>)oKwwcg;_*6oTU@d-V^ z5s}D}B613KwCL#4rCd7m|cER+9Kqk{IXWg4P~Blf&~qJe>M} zXtmPTt*?ZgpdeTAsS>tcz$T3pu+8LW4@oApy^jfxLL6*z$DDf|XP=zH@w%#JxQu3< zDB^V#@w%9!FJ^vc?%6FB+-F3fo;u@5W|-yngV-vYlpxL z=wi*QXW@jV^0 zq?Q1zqqJN_(_6-mqc~Uw>-Li5W0MO)b<;>fS`b7ZJY0~q3z*iQf^c&fCHq%z3J;ax z|Mcds)b{SuXiEnGgwBQrIaOn(cy|4qcAZ zUNcoY2PDO$$EhET?2up_DTa3KD1?Y9ico<$^{q$n_&VO*Lu(>=f;9sSD{@)HA7(O8 ztLZH=8^1^Mx9fNtf^RDgn(`Qf}eLoKS~YDL*=UGm1wSLy@O*w>85TR zu5{95%GblV?kF414}=pal{M?_qIREV$*j@~fC0%Kt!WzF$uo}%>*9lvE5HPCk~ z0FFAOidCqCH+7@62QlF2!b=>EPh~}yO-l2w#N#xYG=|$o>j7(5u z5YwG{17NCtZZH0czjsjk0D%(4`TG!xAYMNczM7VZi;vQ5iz^1<#9sV{zjsRXH$ACg z#2IMkxh*cmsXvE^RJos`pn*GraLD7A(7J-~DhZS$;Mtyhxz2llwLkEpU1atI=93=O zs4oo0r1y|RcL74}Ju#D6A4NJv?*v7sGe#KBxi0uAf6YUxZZYD^7Og z{w0Pi%U!oe1A`nF`+FcM1c83PjR$iR5*>}tH8G==Wco-lH9V02uf1=Ni>g}xUbEK> zj0ns~pj^BR3OXv_h@|9oKr~cTQZzKnQPD89IEv?|W)2?hgtrcrwLKj(I+1-NR#DFCRZ*9XFN?NtEI`#7u`8R@!|%{E!m3A|+(w<-hWB^B zicYqy{1*mv&At_WLuo%cbX?KEEf2nhq!CvQMAJ0Uon}g6~C53_-sTirkua=6ZG1eh>~!6VFJGM z+?~5(uU+jO#oM}vP-zsYnSsWmboz0_h!y?>%gXOCKfq;LR=z2?20R`_C=~W-5t*w{ z=l~SzZ~Ld;8~q==hQrAPI2>Gx!=q<#_~I8FaSrw}DCiMCA7tp8s&wbhW&bi(AZQ{9q;VlyL&58aFwT z9#qHhvOvVG^GVZ!0) z<73am;1d{}`x5I6mKfYdSsP>K-AcoBuIKWr*rK!f9hP6k%?f@CT#806znYHGTiD89 za!vdiBcw5A;;rhUXrA5W`6M~%hnZKD;G!#xMzRPV;i zV6kdo6)MN$eERBo)vz*bR32JKO*56?83Uc4E;@yjcG|Y zvKrm6Y8b7PYfOKJj8^Ps?0xI1VR-lI0}YKagQ)N|rj95P-Tl@&rdGu8Y~{0I>aiH! zx$h>pi7S8niU+(=rAa8Qt}$jebQ)Jq+%1Eq^~U-5mVe2m#>R8CsHcyb(w6s#daqj8 z)%XXU7fVLS&uVd7{-&~Xm}+mwA5i)YQ>)tXWy-FcUEN~&-wcsmhhmlRmwbP%@u>g# z57Yy3yl1ChQt2s%C%0$B=iumPp$G~}{e<|QsdcGpWITVSTPlfbj^Lt@01odm^WWB; zniUaF3D{!{K$108{WzYd4ErpLYB_*MDD-x8MD-e9LGK?(f#o`5C-LJ(Je%G|vN(xX znQDk%alm%he*X`+Z$fytSG_fX+Y?43VFbmAMT{pC;apF=04Q}}in=<1FOH>^3L)os zERJ2y`~GDiRB6n!J=KKvyj!;=NW~TQezA-lA-CV`CfuGz8tL}Tp6cxOaQjv#x!qfo zpt=1s+>Rqlo!bUc7Og$2OeW$rw7>K9%^MsrlX2O&#Ikt8^I=9zF|>Jlu=T2L@w3 zB}fnPs~qaSks}9@hZ#KB!#uLod6*%J)VeQ|c+JB*za|gWBRUUX#mS_3_zybGq=zc; zJyXlOsU2Pm6McwBKk)DskMpxb>%`^bzx^dG4`1{6nf^dR`BlVQM|hu|HU3FPM0C-H=X%H z#W+}<+=Wk6whdCZcj2>@tU+prBt9^C{LNH0u4?1JG{y`RV%_dmM&=Pt;FmSFo7H7W zyo-BI2V6(7*212iuCFqU>qu=TeualTKLrDvHSLoCs(S$`)2aigi^Jfkh3rKe@d0VQ%C8i-2)y$&3{ zXVR--o#Q8J|E*%pr;RalGRXH=u-jpHbqu`)Mnv}GzcP%#H%E99s)S{zJCgapUYBgx z!Tgv`U0~l|V>oxEsY@+8O7H|a5N2*#j#-quqOK89X{OOIKqpNEkVpt|D&QSccboclSKc-1 zw(Zv%7cR=35wQ{sE}mK2)!)1FN1`V-%@%FQ%La|=r2exT@2Pa{q`u#c$I$=C`mP%v ztK7X!3afn`>&x1{ws6{fetSK=tJ5!v2@|TL7My&H10pYNZoGdnacJ> z>UlfQ9{(ana>cI(%gQduhu4mdJZMs(qRxOL@2P3oX7@6LxP8~g3r*PZt;@Trjo^`{>EmbTXr0+O|&4zKPtT>yJ76kovk z6V$;yd2h$7P#iQJiO_1!Srt(S*0THiXv>On)C9#VP`r+&FkB-d4C>Q8c~AE;=vLI3 z51QtI!4iY*=p1lam-pLBd%eaO_Z~EjgTjQQ6?L|pE}yP4jf9*t;M0Yc6?M*49Wo)U zGWErg7Dzkh5Pow{Zz8r%-JiQ+niZ`#rSwH7tjaQjZ6jFB(!H3Bx$1}%ZdLYwuHKQt z6T=w_!MpbNuSk9-UM)}IW7=P)Z*12*wNEM^ zr-Y`c52f->5h0WV8w_V-3{O#CN#$MJ>|b!5)@PjlcG|zBq^M_8d4Y0oPt}>mOGfSp zgX^!S|MRQVzvHoI?tuLZOLJGuj72GHS60vyQxxbb<@$)!1vM%CyJ185ILr}!gqcw*8(3w7f z4n20>?(eo66MBU?$&W{F#3cuJ(Eh+~>KmW$(Raa=EsPl)3NaePu7H;UsXade2|Kk0Z|@@64y z5yxtAd|n*GQ^}zh1z#zS>EdVdfVOf<#)lsEXySSFnXR~jaUYiWkQ3+8dF*X zuJDY-{)=VG8Ox;Ovn=y3cd}SJPRWeO_&!eUK+Pm?~fO!^kN*-Vjk%rfa+l(2o4 zkUq$=*gpf+p_&Zft+cWv#z{3+RUr@Q`K@RPcGP z#oi(P4r<1PeHMH2-C!++7cBcs8<9K2V!v*ga>0`CvDj1BA_-k|rITgSmw1{n={w7$ zAJI)8p{$oh0aMT`??H1MMNYlbpxOrUPHlgOqn1f0ErlIkY2s#2Q6~)IUn%89 zW5sdnuE-&LC|Bl8P{(KURZ3-n`eimxk4q^)m06a#mo1at&q1|WmcmPz8OO(~-G}lT zWybC5=RTd&qtV>?yw+i4IYK^g1ACNCU`)lsTzcrl+H4qMK#fJ)F68LiA7> zmF3s?Skj+=rFpod!=fRjs1IekMd7u`K#BB$(np1C)(UALeuKt~?q7CHb{1m}{)E^Cu6Bv>KdK2%O7LiW z8Sy(bUUYA@#@k50QR6+tS7^LLSAno!ByC7PSL1~fE{*q*z5x6fcvMD0E(Fp4+7O7Y z&XC;}u!*LpYwK2v3jBCRrL%WZ8OC1f?p&S_e=8<0exZqnj*oAE-v0^Cu09{)>1?+8 zQ!bBl@95PuRKoGi&9dm(_06&<_dv5;N%fRMh98TFFP3Str?rmI(#4sU8=PK`Jnl0Y znt_;G_Fw~%DS9x*U(Q2waJq{sO_Dm;I7!|-NW6%hhF;`12GZB87WUDYn^;VV$MV`E z^Gs7B&y z051o~MTMRY6%{y%H~&*Bi}-8EADC3qKG(o*$NG6h42W39>>6J|8S;*a%nqu=squ?Q zpP}*f#QP76ye{I~Yx)z!`_!jKaa(A&1(>1zH>n3k@!p|7&4-|DQm>8T8Tj`Dz4Lfh zhi%^=|C-VE+*M}mtud(!&HhcKTNUenQT#a&%%3bk8y*$ z?kWZp4=S1@%_j_(-0WZhi)K;Tvexz=CPKUx{R{} z852ZCQ&Yxvx{U2)#t2=;Hi3-)iliDJKNhI*Eqp%_sPU~|wHhbTcNWssNxw>02Z)Tx zO&LRV8AD~p-y51U8j$gmc(n0I1l9N|UYMh`@g*1qYJ90d?KGAr42-{sjB9X*<-|>j ziN2sg1R8Dt@RM0c`RSO%hA>7Ft`tA<8}+5 zOA;f8YI2gq42kvvO&=+-VZ0`vl2|8khr|sMS4u3AI8I_;4c)A>RG1}R8mARJP*$8P zaiYX~B(9XWN#ah4?@2r@u^}MK28!0=uy!QXgKfk(!7$cd;;|8$18XG?ml!5-Q?8a? zEYU78eUzrJxK+b}60Z%{k677VjpM5q=GpLnVA@MGWJtRg-yp*Hae=Hp?mlf}j z_@TtJ62tN|d%HxZ#5^F?&sbqim^4~z*?ko?Vur+kqwmR{DVA6( z%RM0F7p473skdr+H;WA@BzBdCAyU333%DrpE{WqLu9TQ7ajir|E(qUZCHf@>93Cg; z5a!=DSy3QipOn{1EN+p$p@p0x7Zye0*(|MMuf%GJ>m@FgIE#?x|2V10kZ6+_BJne) zR^Sea8ze53I7?!GiCrZ|N&Iezmj9T<-4e^;usHuVO2r1*f^3ParM^_+T@ts+^uAJ_ zEM>ElFAml!JSuUw#LW^PmAGWEJpZRl#Yl<%TeJcqrF?miCi^A6BXNtwhb1nNSR^r5 zVy46>iHgKi1KrZofg0|XSS|4hiGPteU!qH5p2YqVI|fkp#C+K^on=E5nSODAR-ex; znWGZ7OMFt|Qi;V9$4JbS7%TC5f33jN61@_4O01B$Na9@*v&TrLzeJlvv&6tzk#`%X z9VugTB+7)!v1)oDA0B>UjHa&`%bn`pm-)bvi_U184I?yk6dOeeUWs_>8T2uql_j)c z!mdQ3@4Ol|iFZ|Meo)gV@rRY-^Xk4yJWaVPSG_oikLhgw;l}yM!5TW8-!*+Qe=pQs z{F7#Qexio;-L;A`>owUqP?Kx2G^~*J6)hafcucd;l<1V0C$V;)mhO>Qr{M(Vl?tE4 zdWkzEmK@SD)=IP<)@1s<0W~E5ydrw0OrjS^eH|U;lR1hdE;_WU#|-|E#ldE>1+0|W z5TJb@{^o)k&1SQESvL6l*bFv@4FxWQrj&)@ElXb)@o2R}5sztGa^HP(ZHa?y6Gu%Q zGa)Z;YHrq;oV;PGcPZ~UXXf4cNF84~t#m=!^tt!Vm^1Xgh4+@)1`V>M+q!nOP1mPS zn+t!yZ$=AdFPTZ%v-8Fd9W{0Qh{?ljJ#6XJXw9QH%6PnG!5y>jOq(|~ zd*Q5EGw0h9)rddwxb9M!)l|#B`%J~4ppsJFR^7Cao2RF@aJmoqL+uqUN>96i%h?l# zPaQgT!kB^cT*<#G? zg_!NrkT8?=r`e2;%{Fm#*3{9%MvomgY3hXWS+@?GI$_MHF=KBZ(_a|eApO?-2~)?8 z$(tk$Zje5-IUSeJKQJg5I~C=ih#RC+1xQCZH%_MthK|kuLkB2-Ue@Fhd6UAYX650G z$toC@(?6`~+>MRC(K(uGBe$B#pl41I2B*Tyz+*tmjWg;Q}pAv4U>$RhlF zW%j(gZ{YKYdDHHmX&akgFk*C8UULNW5-R+ zDk#Vrnmc;f7=*cs&o0YSeruF^*TcLMtx12LlRf+1BCUO+#l#mYmDG#E^=fsU$(Up$ z6Lo~i*il{jFmJuf^)N3qxQj2yOU1_qv9h~9(Xd1!`&^Tql@g_#FJ<3JO>g~LLv~t2 z&lwGEmo#+!BC$?G>lJ}+=4{XuB@)Yj)*PyMLmIxRp--YsR_u_N@6poBBvwky->c~> zC0h4sviBWne~=KTk4t(~BGGeLGq4@eutD}v{nMK4lNh*&|34w^e*bR^$i1lbP<^H5 z(En+EzszU5uI2Lp-L#|fHfo9zSzwt&FVn8}6;fsfdG(iAFR?G@Lcl2{@2B~mVXMt$;8{%q*9 zxh2KZ(t4}dCyj}ihW$qgE5>S_#(JwSJ;uB5@;$~&JKX->o1fo_UJ*Y|oC?gl#95w? zf)*GHq=kcz25m#ywiao4cE*e__aM#FoTmQkWqvPr8MO^lcx<^giZ&o^p<+~DEe}`k z+|Cz;%`mdcGn`@n`bc7&TCs~8`_)1YeCl*O={&Fxd}u>Uyc2{n9!ZP|p~Ma6)G@E{ zc3o#0v4`UfJ6$M)Klwj$R&tIr+d0ZL)CJRkk-pIS7L{khjwTU(^mcXUsTel}beurR zfsd>qAU0usk&y*jp)aPgg{L0a(Z?)vlH?@$r{+2+$q%>iq4O))FKWL2Q!fi_X_u*U zn$qmByHPuHe+Vuw9}bs8SC0G*XALxh35%dZx9Y1Eyw=sK^Hpvfo2zR8)k8N9)CB4n z(Fra5rUEwnfluZisqe+aQBIswUwoCf8;&`00&W%GpqShit_Av-s?d)G`k0Ef?dB%s z99Q4k&SP3rw@?@O&U4kdop)$W^8sVea8pE+m)gc1XSr(G$z#UW>PFKCk8aeVSWWUA3>wC&`^n{2w#v%?!3xgMwbUgxGLUHLBXXno); zb64nkhl&lO8=?U@ZQW_T0j;&wV}AUkjblG26m?MG9<<4m07Gdv8amjE z34#&mR)f5O4;3Ex=p93aP4m=MuP%Fyw{yePhbnPP9LUjx4J}-$g?yvas`wAwqjL41 za@5hX%tz9~RmUz&@Oo{^-sHX5oT>T(_)B8CkWGJGQvTgH?viqy4b^SOMZxv6JXh+F z$%-cZ{&(Ni7ItA_U5M3_2{O2*aki|T0YH%T6De@3hXw-X?2C0rc++|p(fvG z>QFZXeb7((549}t(N7_2Ek5elS9sguGcP&n^B%tRh+6XoU+S)y%voCL%tfV1 z^X{cm>+iwP0Ry@uhl5$?U|WGxT+=OL-UXbkz(S?Ti;E~9E8{GdY-SftE1i~v&|=20 z;b2x^n!_<;*4>zikZGkz8#)ee#U7dk*3BF(l%&lJ*5yIPoY2{UGV=t|6$jf*CS6I8 zZUhy_7PZikvP|f3wblw8ku?;`@?b+zU`3EFUlh0@SSRc%gLDPLt{S>nl&jTIAnZKQ z)w-aYkDhW*gLl~99K(&dP)tjj4|}l#T#9j)x+P1N6ir7Dvbrm>3+I>4NE(qPD)9#C zCW}f==ye5}oi9kI*}45tHXw2}Z4r$dW4<&a+hz#JNsGvtwGJc0Zz%#}D{lO1dmFWu zY2)38?7XCFo&$)$#x)aiE~@kI9}^kpJl!AnD!w>?6P;WFvs+8bF!MhuI%7*ew1cI>i| zG106rb5S&N&=Uw;CQ7`P{y{1zAg;c*uVWv_G^P(F~T`;kb zOY^;@4!x_hX=4dtmZETG$!N_i^IMC$?N@PX_QoOes_Nd)JH(Jf1*E(ahkHQAu=rf{ z<^6m}+9F7a46)j$G2;&)P`=d6^6?{hL3PjC*mx86_H?6OmW%a!SJpLvc z*v&{&P=);kFgt!ze>=c$776DeU&Pqje<6!&>d?3O&HbpMj%yg1n{iNzS(~eaXLkbm1X zwZ}WWW7Ia8?zinq}%=vedx5=@pyQ*n`~BiEF zTz`9=?B86-S1I8(FjE`Vr|bCQs7mnEMP4k5VOR<(8`U0%c)YUXc6In6-ck6_9$jHi z#vvU9Cx_$QPxmfX-G_Kq9JORA^w~6W4}w_-Qo`!*S3f<(`-$YE(43`)9tZOc$VkcE z5Az|(lsn0Q+?1RO#t8~RGG6|YP8Ip6qIHM)fT3i%5~)!%ch-T~3Nj1RM5RC3R>Ic6 z_HrR48l%28E2(DVBZ_%;XvpJSi7~0IkKku1Xj=9W-g%U33yKFdpd4+nh!=8fH8%K| zq0}uwHgr;5!je@QhZQVQpQgTa1ourkWA%L~=F#|UL`nANaQGKUiTn<#5IZYYXq}GB zj9}eL2eNKO16a3={;ZoJgT>aj^+kK5JoHO$YO)X6o}}J61LgviA)0L9VS_mPAxzn7 zWf6+fTVblKBYsLntPPnwShz8S?bRR!K@XQ z75A&Fj^aH8R8So>|D=LG0P|@e`S?*euCYcV+fGwH5lnZG5{BH#@A5v;l)H#DG%MzT zSz$D)bKm9pTDeesM%8`*<|~j94ywoB<>NCbV}=P$ri_EYxIkfI&Mnsl_G>QBCC3sB zw$dM`)RgzQQ_R%OFt)#d!)}lmT%?Mqmk0pCs4 zn|&eZXj;cAaJ^K0?{OPV5aoS*Hwf$@aoqcSWJmJtXo!)`C*O{P`5I)5bll5X54KU= z{XS0@Uc`pNi$omKKt}WlPHLLQpcVP;l?Wyc3v3zI}lT%D|{AM(_m zR7gD%Gk?b+1SQ0PLd;}kvtTn||RVlXqpSa3QP_hx%l{fH;_@s%4`+A0IvBMLy~Qd|Tx z%q&=sbHCY6J%^0_%2wkyVjyd4t(CztPX1C{QHxMmftl&j)S<_)H7QwZV7o!ZA~THX z>!kv%=HN8!p!K$iAuJIE$Dm*n3bsCMVB0gn@Na|9D0Or?b4^484r37iNG7 zGr+sSz&if@-)Ba!9v8!AJ9WXwXi*tf;1@v~BIKN;79D7AQE)nAdRf26G)Lk*i@-sN zVtT!e^vR@;)%4@EJ!vNC2Spl;YV0SxeK?&oE>g{mG^)-|c=X-0a5>O}+KGzp-E3g@ zfr?>8C#qhK>xhkIK?F9I*j&zU?V`Myy1X9b8}giiZI*d;vikZbJUO8PiEo2^(m*Gx zzkR~v5*$?qHWFmBXtnEPwbuzAH^hg;$Z7*CAOqSTV{=9FK#)sjYANgTs1Kds9TF;G z{0?ZF%%GFiw@`~%gN;_K!4WvbgF?b8p2k*;Hda5M;K{VG$A8KvTd6-QkzP#K=dD(w zy7E)LGNJ6CfxQN@w$WOllhrPt@d@sd4-Bjpw3G})D=b3p@gWxafUY2tk(>jnmIbwx zsf?yP;;zQZg387M7KR=&;daS$4E+wO`IWm_Vyh6=suU*{66sz_mncR(NEWvtq0D>S zz%GEqEtGINM9Aik@pD4#sc5!Pdb5nn5N-j2^1;S?ylZnoapWN!2ulwU_bIg~NOb1j zD5JXZbDomu{M^7wK-yLuMHYoHz0RP%;O7ad@g!eA1K%gI1)z;L$$rIIM)Fgj%>mtM zlaTjAS4TRyMCp1tC=b$g<*L7(EPbWlDTbwzmI1B*c3XU_!l{p-zPV`sYCeAGvS^Aqe{$ScsdJv0w2H z;+)z5y=claZH?+uWOGx&b(HM`98Q3gFfX!|8ILQN$lSYNu>BPG*J1BvxpSHHsZ}moOHc z5vwNncpEqE-=-k{bW~`c3Fd!5A;J+?I+ao~i%JZyWnU_J#{MBalzH@37i-fYjCC-? zu(tKlz9_HN6Il}B3eRutphi`r2>Z)8yaUo4+sk#1ea)j{I9sjc7{`ROJVf%Qm@|z& z>@;8Z@eX&`5*0SMGyZ)zGSf`f%WY!ASgfH9Yg2FWMR;3#T9uexq4^=A){I!xItYge zAk>O~|5qYfu$hm@4-iy}wN)()k6Emu)9WxfhGFvx=jRqAXuc)+HR@Zzj zA1-*QhEH+ufs`=M)9M>v^N608YeOX zJzSZulq7ZyV_k6qbi}FK_E-pOgUh=Kmv-mP3L6eephKJE^x@J$rBEUN2wgPkP#dK;%do{Fr_a}NonM4};sjp~Mk!L_ zl1(hy;A9~#lfx+Qr)mtCc4?97_|v#%DAIITq zkhbR138y~x9ZyRuR#+|QJd$WMT|qL9W~^SP{`4L1m^(*duYm@3)bdp7z3=-$cgzx!~L`w2g(ghrT6-l(dCn_Nkc)ny*9#LQYo_9*fU#YOu zAY&)3R-LT=^gZSYmE%I9eKrn%25DP2FEzEBAJd%-Hj=?}IJ^wf`l5skW&{jQkipkD z{Lo||Hh)k1d3W*Xw7m@m$vC8dsKeDS{JaxgaIgD$#~xHk37IU$;USO_3m`5J{po1n z<~tSThgR$jv+-+n_!-{WN#p2&S?4H>Bh8RQ5W+^Xc^S$?wpqamf#H8PoIP7)V(qYR zYgZ78MJa@}tB>*BtmJ6(?wBpWKi05@Ss@Kl)_HHk(N*C$U2(7kc zU^^S6!**6L_cXGe*z(a`iS1>DWrOs2gLPPL^ftP@&g}}DzFlz#WtK{*V=PG4Wp=%y zu)l!x6$k5Zg6nN`c`J4(Y&%HHi{+MX5Q3E~NWRfN)YC<-?T5M;)xz_5;g@Tt!q$Vl zND=Exv#j3tBaiDAY=EZ)mq576(<2*Qn%e0r9wRo0#Ys51=&JdrB;yl5aGSPk3@D#T zGOCEk(6n^{?FY~zwj-yPb+5vFpi4+0cY*G2clW9o(c=nsRPj71lJ)H25Rb%W?6PfvjQ%*=#b_#^`#&ALU;a2h5ZS%vMXFO zVsR{GLS6#hTGFA7l&+Wcc?>t1*-h!en?$j#xD>(azrY#wrNWNMa`dtxj=tcssL%d{ zJ9CduVc&uDPLSLHO6sOL(NfmsQGff1KPbL_xCY~W2CRc7yOCws)yL}jq-gBkuCOi$=f+L9{uekmdfSu)l-6(ym!npSZv~i-)Bd-LWOc(AWoo$p_(1V6pna1>SFPO*Ch3 zfpD{}t+-f)N&Y*w@^fKH?zWVh^Qglw^3J(*O*jqPeRu?D{{c)=4|WI3%SJ(VS&%iGvq7LhLBVoxIYDVH9I713*}FsC%>`+SfE-*li> zl1JiOsrl-gzwr3B0et~<_k+R_xN`qU^~Ya$=cqv1yU;g)<}6S{SQMK&mZ9DhEof}C1 z!FM^V1UiqFCL$HPY`B3TW%A+o?DWa(Wkl$jVx6UiH1KYQnQ9tAkvdV6mNoD+9xH5G z2eRZl-~*x{aupGKv zo$f>E7OkKlv;V$A;J>dB`0pzO{`(36_TN_sh~*cD|Gq*X8y8Oc{Pz_C|KGntApVbE zA+YNn#aON2rdRvLr0$oIY8#WWUrdNh(EpT@skfSpiRx05aqX^-A;wef9&_-DogIyP zd1ATtn=LW1a7Y`HHL(=GIG#EizgKlSSzWpMd>3Q9dM(kIYA9EGbT)PaK$W24K~oC& zCpFc+&c(YbpBJ0h|G%uYU2`0rnB- z8tL)4G9P4az}-1;9Z1*!-<3SO3D3DeWJ7o-h-_TIzk#gKR{(#Jdi;XU%?j}|I$;E? z0a0ay4N~767tBR`@JEOdPC`M1CqbFueZW`S;tf>bJ-{lwFS8JQ4R9rb@aBTo#}HF2 zaRUPLHZg$MPyzf2L_JXtOzJEP1=fLTVdDjwx@f_{ zghike&=WojIuD+(7Q_&o>j4f<((*ci_a|crpf3YbP_GlbyE(d-i>Tj?-4J(=1j2uU zHiIXu26@1Hfu}$;mi0izuJO&$zPLq(E)WS!cuRNOrz0=naF7`>yM%e&G5$6PE(p~i z2lyJ`4Rx>$F+~&~2gUvl=YVOW z@UQ|r;mwjK901CL-U+M$Q8|RafTloi&10-9i1bdN`^0$sa03ZG;E%WC{uX>aaKR)@ zLWB#K0e_o@%D}Vfn8~1};0Z6!z^@TVUxXo>g^32f9#}aWk4V82F2nCw+9Phb4ERh5 zh6a2MaPNHdZX@DTnuCeC2r53Z09^+o!cRa)!TW$;mZIy32Ojw|zNZ531%@p~H-fhU zk357~&5XU1V-h zh%bfuI=5nlQ*dJpoCeAOPj~>71D-JVdB$Ae^MN!E@Z}V03V!>7##2wz;_oL zSad7s7vm+WDND41C_?vNlBZbQp7%>VaINGiI`+KeDeU_m#L1Hr6fb{4@)Y%cKZx`c zBEJPxipq3hs3JVI(=vqUwQ?I7F@r$cVB`dz0?~3?4@__)vA*Wv05Z(jwgC{HjF+46M{Ik^S!cIk~>Lf&x+F(OC6*LgMo0yrPJjx6V zgryQ*T4!L3peOtdv>rU60imQd;0Z%Pq}PR)ijdUdh!XWcPdFNM5g|g9eBcPAU}B9Mx1&e znwW%pK@HH?Y%;K~Kvsle`hZ=ZhST63K=)c4oDe9a=~YlZ_q7*v1473O~gyq$4oPH3>A*=^&1g{Gb z6``XKZ-uAO6aEu)415i+?s)?{4c-g<_(eE@;7}j1$4)o_-T@r+8rB2wPT=z0n!W;f zZjZ*-yTLs420Vfh-gv^o-h@Not-y~#+rZ<^Cv1cVT?rmb`WC^UKful;#B+B;mksaDdBA(cP0e9`Gmc37_%2V-hRSjk6?z=ss~&o zc^{DCO^e7L7>H@r$EE6HRweg?^2oQAC~M%{bVtV19rn zeCrIx9z5QV!-l!f!cz$Oz@#6viXFh%OXzCo@%kJ#?iZ|X;B}#?L7}etkX8z9Ex3$% z0DHoFLG|DXuYp*!QDFELoK4`}cn=Tj-(bK70<8xILR|@O`4wFaJt2jy=7HCRuZpnN z%g`@^p77LFOkVK%=v9hrefoD?FQ6xEe;xY*@OTLgd;L1b-v&$T z5vQ~Z*e?=sOk@MR#iB6Q7Ci8KP>vfyJ(y~%!j^)s0sh(sGI$n+xP^GcFA$%gu%A09 zEEB<>tfRsb644^?`XEpW4mEc{>>TujJwQf;|2cpi5Vsi(ULVg%ah>iJ-O)-U5T^G) zE5SQ~52T}&;LCvNh@te89vBG1)W=ckV=O7wa#LT0%|&=5VGXDZJmJrv3h;!j`YEh3 z4(q=a%)(n>h=elWa|6%<$^fK5#uP+;=mQ${!HyL4*cBBoHQm!Vx>Di%t}gjOEa$Ku@TGoZtz60TqDP z1uKdm#%bfx8_*LT0IdhFk5{BP#)-FM{C6OMnA<_ez`KCfLO2ATuthTl_HZfU2aSmP1G?E`5Mm(^svtXf zeSjea9$uS^&=2Sde+LzTXY&;H+Y$u95`RAmU5da)y5a#1Wf*(tOO`8a>`L?icwP9Q z2rJBa5cPJ#`cKScP)a9w3XFaT=QVg6uw6OM4&s5QKzqQ~1Glfzcn>gj4I*ElcK|1> zML4nzB37qf@hJf@y`?H8#1uw$v+z=>+PalJ)kI$pHJ@aNbmxyy3*bd|b zPuLff51#NYkPEyEc;Y#XJ$N6muu9`yK#Ia!3%x!X&rM-^1D0spM5b3SJQHY@v8yVnVUc~qpBB27p zJ`nNxAUg`kJMa?57J9-Hp!MJhzXw%=uLnjUxQ+_d2iZ|TUWe__!-lXo$P1p3;^|I< zcW%e|kLWuQ1V`BS6$}Rw2uFhOY*yeT@HX)JU^)uCn}z^72lRvsLAl@wSAwR1*T>UQ zu-#u@#mWdh;gg`1ZV1F|1#JLd1EeUpYVf*fI1y4;3;hY`3Eu@>15Y@47aUD83fuzT z0iN(}5ZQQvo?4ti&=c0bhKmz;LU+OIs0@M&=z9Z~UGRj4z1k&GA23IObjkZrSu%ou zfJZJ2I|`mk!fW7*pbg*&UkAa6 zd4S^&Y0l~6=_szQ7PJjEgztj9;0Y%mMuWf;ZUq^;;%8gHH$i0M0b1X~_}h?ReGgZ- z_qA(wJuvGS)&S`9f#Xi#3<2)~{`wgz#IphRIj)2!F_vTl420zAL+>aAuiqEA%E5;4 ze$Wo^gcMqL0DQe0Od#ft@CA?`352u1!uWwN0lwlxweQA$Amcx8M}^2e2Vr z_YKAyJYo0Kn2g{Zz@gv5Y4G{Lj^APYmqM_C8TdUequ`yu{(kLrasr2+M++ze@J}GI z6$2gs(X{|?0A{uyut?GU0x;}HbT90!K-)!3SSlY__%j*UAu`;46Vuh`%#;$JwNd&C|!=QEc8f zpq1U-c*y{mH`^lg2^k2_fvUmR0}rL*?J(fI!0{9t*8}rF7b8dUbno=VOAVkWjOvFC zCV0a8L7Tx7Zj$;+U{WStWdXedILSSLvjY%Zz>Gnlp0s;`6Cmo|df+{SHNFIRR`U9= zxBf#oD@D{=KJpUY51I>}a5<qFTn z{OysUhy;Y5Pz4!Nuo(e91&Ri*k63#by2xR8m<>H)G$;=|Vf-*W|D6IsADTwtY!4$6 zZ4vZ@>xsY!3h7yhdlzy0KbuRqtLzJ37sIyOV}n4Wk4Sdd=OL#z8tt0 zL}$$bUSh;X^&R|4OZya)IRhzdOcd>HX>WRDl0 zvq})@315@^9$+To;f|qv!jT}d$p^aq}6mZra`bywM5M?k< zz`H;|;yeb1PsA@-VB-Le0+CHIa5IQ(2q|imc#8G>07N#&fV~Pi8<>XmpJHEM0_C6} z53tQ7&RkS6@WgZ!2;K+0?H;rWybI_BodAzl!7~Mv37%fDLvPrjI9z(m!kr-E*WQO= z1=+%IW+4WZ;!uev^v%ckli-6u;fR!ha1O|Y?jod+L(&scNa0cF3E!1^djD46Qmti9 z;1E6ExyGSx52g~n;49lwzNKQzhAov_s<+f^somn)Qn$ss<-``>7XOy|Ee%`n z%7-dzRcw{5%3kHD%B*r$bimOVh7FCs1l~+|%ZK$fOs;;W3s;%-=)m3?` zPE`4-{8jZ;4OOh#Ty3q6t+rL$s~y#u)z0eN>ip`$>WQxE;_8y>Mb%~1<<%9{8>%a- ztE+3OYpXrgb=BVL6V<+Ie|3FzLp9rK-fG<%yVbVUzSXfcbE|V}?$-RRg4aTMZb)Ip_BM$Tb0uM!@hX4Qo delta 92084 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

That string is also printed in JSON report created by vmaBuildStatsString().

-
VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
Definition: vk_mem_alloc.h:2357
-
VmaAllocationCreateInfo::pUserData
void * pUserData
Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
Definition: vk_mem_alloc.h:2451
+
VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
Definition: vk_mem_alloc.h:2384
+
VmaAllocationCreateInfo::pUserData
void * pUserData
Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
Definition: vk_mem_alloc.h:2478
vmaGetAllocationInfo
void vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
Returns current information about specified allocation and atomically marks it as used in current fra...
VmaAllocation
Represents single memory allocation.
-
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2254
+
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2281
vmaCreateImage
VkResult vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkImage *pImage, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
Function similar to vmaCreateBuffer().
-
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2420
-
VmaAllocationInfo::pUserData
void * pUserData
Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
Definition: vk_mem_alloc.h:2787
+
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2447
+
VmaAllocationInfo::pUserData
void * pUserData
Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
Definition: vk_mem_alloc.h:2814
vmaCreateBuffer
VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
-
VmaAllocationCreateInfo::flags
VmaAllocationCreateFlags flags
Use VmaAllocationCreateFlagBits enum.
Definition: vk_mem_alloc.h:2414
-
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2411
-
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2749
+
VmaAllocationCreateInfo::flags
VmaAllocationCreateFlags flags
Use VmaAllocationCreateFlagBits enum.
Definition: vk_mem_alloc.h:2441
+
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2438
+
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2776
Generated by   diff --git a/docs/html/choosing_memory_type.html b/docs/html/choosing_memory_type.html index 091ffe9..aa98f86 100644 --- a/docs/html/choosing_memory_type.html +++ b/docs/html/choosing_memory_type.html @@ -128,15 +128,15 @@ Dedicated allocations
VmaAllocation
Represents single memory allocation.
-
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2254
-
VmaAllocationCreateInfo::requiredFlags
VkMemoryPropertyFlags requiredFlags
Flags that must be set in a Memory Type chosen for an allocation.
Definition: vk_mem_alloc.h:2425
-
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2420
+
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2281
+
VmaAllocationCreateInfo::requiredFlags
VkMemoryPropertyFlags requiredFlags
Flags that must be set in a Memory Type chosen for an allocation.
Definition: vk_mem_alloc.h:2452
+
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2447
vmaCreateBuffer
VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
-
VMA_ALLOCATION_CREATE_MAPPED_BIT
Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
Definition: vk_mem_alloc.h:2331
-
VmaAllocationCreateInfo::flags
VmaAllocationCreateFlags flags
Use VmaAllocationCreateFlagBits enum.
Definition: vk_mem_alloc.h:2414
-
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2411
-
VmaAllocationCreateInfo::preferredFlags
VkMemoryPropertyFlags preferredFlags
Flags that preferably should be set in a memory type chosen for an allocation.
Definition: vk_mem_alloc.h:2430
-
VmaAllocationCreateInfo::memoryTypeBits
uint32_t memoryTypeBits
Bitmask containing one bit set for every memory type acceptable for this allocation.
Definition: vk_mem_alloc.h:2438
+
VMA_ALLOCATION_CREATE_MAPPED_BIT
Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
Definition: vk_mem_alloc.h:2358
+
VmaAllocationCreateInfo::flags
VmaAllocationCreateFlags flags
Use VmaAllocationCreateFlagBits enum.
Definition: vk_mem_alloc.h:2441
+
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2438
+
VmaAllocationCreateInfo::preferredFlags
VkMemoryPropertyFlags preferredFlags
Flags that preferably should be set in a memory type chosen for an allocation.
Definition: vk_mem_alloc.h:2457
+
VmaAllocationCreateInfo::memoryTypeBits
uint32_t memoryTypeBits
Bitmask containing one bit set for every memory type acceptable for this allocation.
Definition: vk_mem_alloc.h:2465
Generated by   diff --git a/docs/html/custom_memory_pools.html b/docs/html/custom_memory_pools.html index 619685f..919d1ce 100644 --- a/docs/html/custom_memory_pools.html +++ b/docs/html/custom_memory_pools.html @@ -176,21 +176,21 @@ Buddy allocation algorithm -
VmaPoolCreateInfo::memoryTypeIndex
uint32_t memoryTypeIndex
Vulkan memory type index to allocate this pool from.
Definition: vk_mem_alloc.h:2576
-
VmaAllocationCreateInfo::pool
VmaPool pool
Pool that this allocation should be created in.
Definition: vk_mem_alloc.h:2444
+
VmaPoolCreateInfo::memoryTypeIndex
uint32_t memoryTypeIndex
Vulkan memory type index to allocate this pool from.
Definition: vk_mem_alloc.h:2603
+
VmaAllocationCreateInfo::pool
VmaPool pool
Pool that this allocation should be created in.
Definition: vk_mem_alloc.h:2471
vmaDestroyPool
void vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
Destroys VmaPool object and frees Vulkan device memory.
VmaAllocation
Represents single memory allocation.
-
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2254
+
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2281
vmaCreatePool
VkResult vmaCreatePool(VmaAllocator allocator, const VmaPoolCreateInfo *pCreateInfo, VmaPool *pPool)
Allocates Vulkan device memory and creates VmaPool object.
-
VmaPoolCreateInfo::maxBlockCount
size_t maxBlockCount
Maximum number of blocks that can be allocated in this pool. Optional.
Definition: vk_mem_alloc.h:2601
-
VmaPoolCreateInfo
Describes parameter of created VmaPool.
Definition: vk_mem_alloc.h:2573
+
VmaPoolCreateInfo::maxBlockCount
size_t maxBlockCount
Maximum number of blocks that can be allocated in this pool. Optional.
Definition: vk_mem_alloc.h:2628
+
VmaPoolCreateInfo
Describes parameter of created VmaPool.
Definition: vk_mem_alloc.h:2600
VmaPool
Represents custom memory pool.
vmaFindMemoryTypeIndexForBufferInfo
VkResult vmaFindMemoryTypeIndexForBufferInfo(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.
-
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2420
+
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2447
vmaCreateBuffer
VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
vmaDestroyBuffer
void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
Destroys Vulkan buffer and frees allocated memory.
-
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2411
-
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2749
+
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2438
+
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2776
Generated by   diff --git a/docs/html/defragmentation.html b/docs/html/defragmentation.html index d2c9d61..3b541cd 100644 --- a/docs/html/defragmentation.html +++ b/docs/html/defragmentation.html @@ -210,22 +210,22 @@ Writing custom defragmentation algorithm -
VmaDefragmentationInfo2::allocationCount
uint32_t allocationCount
Number of allocations in pAllocations array.
Definition: vk_mem_alloc.h:3085
+
VmaDefragmentationInfo2::allocationCount
uint32_t allocationCount
Number of allocations in pAllocations array.
Definition: vk_mem_alloc.h:3112
VmaAllocator
Represents main object of this library initialized.
vmaGetAllocationInfo
void vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
Returns current information about specified allocation and atomically marks it as used in current fra...
vmaDefragmentationEnd
VkResult vmaDefragmentationEnd(VmaAllocator allocator, VmaDefragmentationContext context)
Ends defragmentation process.
-
VmaDefragmentationInfo2::maxGpuBytesToMove
VkDeviceSize maxGpuBytesToMove
Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
Definition: vk_mem_alloc.h:3134
-
VmaDefragmentationInfo2::commandBuffer
VkCommandBuffer commandBuffer
Optional. Command buffer where GPU copy commands will be posted.
Definition: vk_mem_alloc.h:3148
-
VmaDefragmentationInfo2
Parameters for defragmentation.
Definition: vk_mem_alloc.h:3079
+
VmaDefragmentationInfo2::maxGpuBytesToMove
VkDeviceSize maxGpuBytesToMove
Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
Definition: vk_mem_alloc.h:3161
+
VmaDefragmentationInfo2::commandBuffer
VkCommandBuffer commandBuffer
Optional. Command buffer where GPU copy commands will be posted.
Definition: vk_mem_alloc.h:3175
+
VmaDefragmentationInfo2
Parameters for defragmentation.
Definition: vk_mem_alloc.h:3106
vmaBindBufferMemory
VkResult vmaBindBufferMemory(VmaAllocator allocator, VmaAllocation allocation, VkBuffer buffer)
Binds buffer to allocation.
-
VmaDefragmentationInfo2::maxGpuAllocationsToMove
uint32_t maxGpuAllocationsToMove
Maximum number of allocations that can be moved to a different place using transfers on GPU side,...
Definition: vk_mem_alloc.h:3139
-
VmaDefragmentationInfo2::maxCpuBytesToMove
VkDeviceSize maxCpuBytesToMove
Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
Definition: vk_mem_alloc.h:3124
+
VmaDefragmentationInfo2::maxGpuAllocationsToMove
uint32_t maxGpuAllocationsToMove
Maximum number of allocations that can be moved to a different place using transfers on GPU side,...
Definition: vk_mem_alloc.h:3166
+
VmaDefragmentationInfo2::maxCpuBytesToMove
VkDeviceSize maxCpuBytesToMove
Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
Definition: vk_mem_alloc.h:3151
vmaDefragmentationBegin
VkResult vmaDefragmentationBegin(VmaAllocator allocator, const VmaDefragmentationInfo2 *pInfo, VmaDefragmentationStats *pStats, VmaDefragmentationContext *pContext)
Begins defragmentation process.
-
VmaDefragmentationInfo2::pAllocationsChanged
VkBool32 * pAllocationsChanged
Optional, output. Pointer to array that will be filled with information whether the allocation at cer...
Definition: vk_mem_alloc.h:3100
-
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2749
+
VmaDefragmentationInfo2::pAllocationsChanged
VkBool32 * pAllocationsChanged
Optional, output. Pointer to array that will be filled with information whether the allocation at cer...
Definition: vk_mem_alloc.h:3127
+
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2776
VmaDefragmentationContext
Represents Opaque object that represents started defragmentation process.
-
VmaDefragmentationInfo2::pAllocations
VmaAllocation * pAllocations
Pointer to array of allocations that can be defragmented.
Definition: vk_mem_alloc.h:3094
-
VmaDefragmentationInfo2::maxCpuAllocationsToMove
uint32_t maxCpuAllocationsToMove
Maximum number of allocations that can be moved to a different place using transfers on CPU side,...
Definition: vk_mem_alloc.h:3129
+
VmaDefragmentationInfo2::pAllocations
VmaAllocation * pAllocations
Pointer to array of allocations that can be defragmented.
Definition: vk_mem_alloc.h:3121
+
VmaDefragmentationInfo2::maxCpuAllocationsToMove
uint32_t maxCpuAllocationsToMove
Maximum number of allocations that can be moved to a different place using transfers on CPU side,...
Definition: vk_mem_alloc.h:3156
Generated by   diff --git a/docs/html/functions.html b/docs/html/functions.html index 51e062b..e431b8c 100644 --- a/docs/html/functions.html +++ b/docs/html/functions.html @@ -364,6 +364,9 @@ $(function() {
  • vkUnmapMemory : VmaVulkanFunctions
    • +
  • vulkanApiVersion +: VmaAllocatorCreateInfo +
    • diff --git a/docs/html/functions_vars.html b/docs/html/functions_vars.html index 3c4840d..c3050ea 100644 --- a/docs/html/functions_vars.html +++ b/docs/html/functions_vars.html @@ -364,6 +364,9 @@ $(function() {
  • vkUnmapMemory : VmaVulkanFunctions
    • +
  • vulkanApiVersion +: VmaAllocatorCreateInfo +
    • diff --git a/docs/html/globals.html b/docs/html/globals.html index bb4ea5c..e846b79 100644 --- a/docs/html/globals.html +++ b/docs/html/globals.html @@ -210,6 +210,9 @@ $(function() {
  • VMA_STATS_STRING_ENABLED : vk_mem_alloc.h
    • +
  • VMA_VULKAN_VERSION +: vk_mem_alloc.h +
  • vmaAllocateMemory() : vk_mem_alloc.h
    • @@ -295,7 +298,7 @@ $(function() { : vk_mem_alloc.h
  • VmaDefragmentationFlagBits -: vk_mem_alloc.h +: vk_mem_alloc.h
  • VmaDefragmentationFlags : vk_mem_alloc.h @@ -376,7 +379,7 @@ $(function() { : vk_mem_alloc.h
  • VmaMemoryUsage -: vk_mem_alloc.h +: vk_mem_alloc.h
  • VmaPoolCreateFlagBits : vk_mem_alloc.h @@ -391,7 +394,7 @@ $(function() { : vk_mem_alloc.h
  • VmaRecordFlagBits -: vk_mem_alloc.h +: vk_mem_alloc.h
  • VmaRecordFlags : vk_mem_alloc.h diff --git a/docs/html/globals_defs.html b/docs/html/globals_defs.html index 5522260..d81db77 100644 --- a/docs/html/globals_defs.html +++ b/docs/html/globals_defs.html @@ -80,6 +80,9 @@ $(function() {
  • VMA_STATS_STRING_ENABLED : vk_mem_alloc.h
    • +
  • VMA_VULKAN_VERSION +: vk_mem_alloc.h +
    • diff --git a/docs/html/index.html b/docs/html/index.html index 89d7954..a4e5d29 100644 --- a/docs/html/index.html +++ b/docs/html/index.html @@ -65,7 +65,7 @@ $(function() {
    Vulkan Memory Allocator
    -

    Version 2.3.0-development (2019-11-02)

    +

    Version 2.3.0-alpha.1 (2019-11-25)

    Copyright (c) 2017-2019 Advanced Micro Devices, Inc. All rights reserved.
    License: MIT

    Documentation of all members: vk_mem_alloc.h

    diff --git a/docs/html/lost_allocations.html b/docs/html/lost_allocations.html index 17a8564..afbb97b 100644 --- a/docs/html/lost_allocations.html +++ b/docs/html/lost_allocations.html @@ -121,15 +121,15 @@ $(function() {
    vmaTouchAllocation
    VkBool32 vmaTouchAllocation(VmaAllocator allocator, VmaAllocation allocation)
    Returns VK_TRUE if allocation is not lost and atomically marks it as used in current frame.
    -
    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
    Definition: vk_mem_alloc.h:2344
    +
    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
    Definition: vk_mem_alloc.h:2371
    VmaAllocation
    Represents single memory allocation.
    -
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2254
    -
    VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
    Definition: vk_mem_alloc.h:2351
    -
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2420
    +
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2281
    +
    VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
    Definition: vk_mem_alloc.h:2378
    +
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2447
    vmaCreateBuffer
    VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    vmaDestroyBuffer
    void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
    Destroys Vulkan buffer and frees allocated memory.
    -
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:2414
    -
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2411
    +
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:2441
    +
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2438
    Generated by   diff --git a/docs/html/memory_mapping.html b/docs/html/memory_mapping.html index 7c78557..9cbefc1 100644 --- a/docs/html/memory_mapping.html +++ b/docs/html/memory_mapping.html @@ -182,20 +182,20 @@ Finding out if memory is mappable
    vmaUnmapMemory
    void vmaUnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
    Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
    VmaAllocator
    Represents main object of this library initialized.
    vmaGetMemoryTypeProperties
    void vmaGetMemoryTypeProperties(VmaAllocator allocator, uint32_t memoryTypeIndex, VkMemoryPropertyFlags *pFlags)
    Given Memory Type Index, returns Property Flags of this memory type.
    -
    VMA_MEMORY_USAGE_CPU_ONLY
    Definition: vk_mem_alloc.h:2264
    +
    VMA_MEMORY_USAGE_CPU_ONLY
    Definition: vk_mem_alloc.h:2291
    VmaAllocation
    Represents single memory allocation.
    -
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2254
    +
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2281
    vmaMapMemory
    VkResult vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
    Maps memory represented by given allocation and returns pointer to it.
    -
    VmaAllocationInfo::pMappedData
    void * pMappedData
    Pointer to the beginning of this allocation as mapped data.
    Definition: vk_mem_alloc.h:2782
    -
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2420
    -
    VmaAllocationInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
    Definition: vk_mem_alloc.h:2787
    +
    VmaAllocationInfo::pMappedData
    void * pMappedData
    Pointer to the beginning of this allocation as mapped data.
    Definition: vk_mem_alloc.h:2809
    +
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2447
    +
    VmaAllocationInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
    Definition: vk_mem_alloc.h:2814
    vmaCreateBuffer
    VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    -
    VmaAllocationInfo::memoryType
    uint32_t memoryType
    Memory type index that this allocation was allocated from.
    Definition: vk_mem_alloc.h:2754
    -
    VMA_ALLOCATION_CREATE_MAPPED_BIT
    Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
    Definition: vk_mem_alloc.h:2331
    -
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:2414
    -
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2411
    -
    VmaAllocationCreateInfo::preferredFlags
    VkMemoryPropertyFlags preferredFlags
    Flags that preferably should be set in a memory type chosen for an allocation.
    Definition: vk_mem_alloc.h:2430
    -
    VmaAllocationInfo
    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
    Definition: vk_mem_alloc.h:2749
    +
    VmaAllocationInfo::memoryType
    uint32_t memoryType
    Memory type index that this allocation was allocated from.
    Definition: vk_mem_alloc.h:2781
    +
    VMA_ALLOCATION_CREATE_MAPPED_BIT
    Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
    Definition: vk_mem_alloc.h:2358
    +
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:2441
    +
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2438
    +
    VmaAllocationCreateInfo::preferredFlags
    VkMemoryPropertyFlags preferredFlags
    Flags that preferably should be set in a memory type chosen for an allocation.
    Definition: vk_mem_alloc.h:2457
    +
    VmaAllocationInfo
    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
    Definition: vk_mem_alloc.h:2776
    Generated by   diff --git a/docs/html/quick_start.html b/docs/html/quick_start.html index 927ab0d..bb753f7 100644 --- a/docs/html/quick_start.html +++ b/docs/html/quick_start.html @@ -115,18 +115,18 @@ Resource allocation
    vmaDestroyAllocator(allocator);
    -
    VmaAllocatorCreateInfo::physicalDevice
    VkPhysicalDevice physicalDevice
    Vulkan physical device.
    Definition: vk_mem_alloc.h:1982
    +
    VmaAllocatorCreateInfo::physicalDevice
    VkPhysicalDevice physicalDevice
    Vulkan physical device.
    Definition: vk_mem_alloc.h:1999
    VmaAllocator
    Represents main object of this library initialized.
    -
    VmaAllocatorCreateInfo
    Description of a Allocator to be created.
    Definition: vk_mem_alloc.h:1976
    +
    VmaAllocatorCreateInfo
    Description of a Allocator to be created.
    Definition: vk_mem_alloc.h:1993
    VmaAllocation
    Represents single memory allocation.
    -
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2254
    +
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2281
    vmaDestroyAllocator
    void vmaDestroyAllocator(VmaAllocator allocator)
    Destroys allocator object.
    -
    VmaAllocatorCreateInfo::device
    VkDevice device
    Vulkan device.
    Definition: vk_mem_alloc.h:1985
    -
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2420
    +
    VmaAllocatorCreateInfo::device
    VkDevice device
    Vulkan device.
    Definition: vk_mem_alloc.h:2002
    +
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2447
    vmaCreateBuffer
    VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    vmaCreateAllocator
    VkResult vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
    Creates Allocator object.
    vmaDestroyBuffer
    void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
    Destroys Vulkan buffer and frees allocated memory.
    -
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2411
    +
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2438
    Generated by   diff --git a/docs/html/search/all_11.js b/docs/html/search/all_11.js index 4f24839..4e93235 100644 --- a/docs/html/search/all_11.js +++ b/docs/html/search/all_11.js @@ -63,80 +63,82 @@ var searchData= ['vma_5frecord_5fflush_5fafter_5fcall_5fbit_139',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]], ['vma_5frecording_5fenabled_140',['VMA_RECORDING_ENABLED',['../vk__mem__alloc_8h.html#a1f0c126759fc96ccb6e2d23c101d770c',1,'vk_mem_alloc.h']]], ['vma_5fstats_5fstring_5fenabled_141',['VMA_STATS_STRING_ENABLED',['../vk__mem__alloc_8h.html#ae25f0d55fd91cb166f002b63244800e1',1,'vk_mem_alloc.h']]], - ['vmaallocatememory_142',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforbuffer_143',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforimage_144',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a0faa3f9e5fb233d29d1e00390650febb',1,'vk_mem_alloc.h']]], - ['vmaallocatememorypages_145',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#ad37e82e492b3de38fc3f4cffd9ad0ae1',1,'vk_mem_alloc.h']]], - ['vmaallocation_146',['VmaAllocation',['../struct_vma_allocation.html',1,'']]], - ['vmaallocationcreateflagbits_147',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597',1,'VmaAllocationCreateFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#abf6bf6748c7a9fe7ce5b7835c0f56af4',1,'VmaAllocationCreateFlagBits(): vk_mem_alloc.h']]], - ['vmaallocationcreateflags_148',['VmaAllocationCreateFlags',['../vk__mem__alloc_8h.html#a5225e5e11f8376f6a31a1791f3d6e817',1,'vk_mem_alloc.h']]], - ['vmaallocationcreateinfo_149',['VmaAllocationCreateInfo',['../struct_vma_allocation_create_info.html',1,'VmaAllocationCreateInfo'],['../vk__mem__alloc_8h.html#a86c44f9950b40d50088ed93a17870a7a',1,'VmaAllocationCreateInfo(): vk_mem_alloc.h']]], - ['vmaallocationinfo_150',['VmaAllocationInfo',['../struct_vma_allocation_info.html',1,'VmaAllocationInfo'],['../vk__mem__alloc_8h.html#a795e6ff02a21d5486c0565f403dd9255',1,'VmaAllocationInfo(): vk_mem_alloc.h']]], - ['vmaallocator_151',['VmaAllocator',['../struct_vma_allocator.html',1,'']]], - ['vmaallocatorcreateflagbits_152',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7c',1,'VmaAllocatorCreateFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#a4ddf381b6ce795bdfbc6c614640b9915',1,'VmaAllocatorCreateFlagBits(): vk_mem_alloc.h']]], - ['vmaallocatorcreateflags_153',['VmaAllocatorCreateFlags',['../vk__mem__alloc_8h.html#acfe6863e160722c2c1bbcf7573fddc4d',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateinfo_154',['VmaAllocatorCreateInfo',['../struct_vma_allocator_create_info.html',1,'VmaAllocatorCreateInfo'],['../vk__mem__alloc_8h.html#ae0f6d1d733dded220d28134da46b4283',1,'VmaAllocatorCreateInfo(): vk_mem_alloc.h']]], - ['vmabindbuffermemory_155',['vmaBindBufferMemory',['../vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470',1,'vk_mem_alloc.h']]], - ['vmabindbuffermemory2_156',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#a927c944f45e0f2941182abb6f608e64a',1,'vk_mem_alloc.h']]], - ['vmabindimagememory_157',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a3d3ca45799923aa5d138e9e5f9eb2da5',1,'vk_mem_alloc.h']]], - ['vmabindimagememory2_158',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#aa8251ee81b0045a443e35b8e8aa021bc',1,'vk_mem_alloc.h']]], - ['vmabudget_159',['VmaBudget',['../struct_vma_budget.html',1,'VmaBudget'],['../vk__mem__alloc_8h.html#ab79b48b6d25aada0de91a913896e1c38',1,'VmaBudget(): vk_mem_alloc.h']]], - ['vmabuildstatsstring_160',['vmaBuildStatsString',['../vk__mem__alloc_8h.html#aa4fee7eb5253377599ef4fd38c93c2a0',1,'vk_mem_alloc.h']]], - ['vmacalculatestats_161',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a333b61c1788cb23559177531e6a93ca3',1,'vk_mem_alloc.h']]], - ['vmacheckcorruption_162',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a49329a7f030dafcf82f7b73334c22e98',1,'vk_mem_alloc.h']]], - ['vmacheckpoolcorruption_163',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#ad535935619c7a549bf837e1bb0068f89',1,'vk_mem_alloc.h']]], - ['vmacreateallocator_164',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#a200692051ddb34240248234f5f4c17bb',1,'vk_mem_alloc.h']]], - ['vmacreatebuffer_165',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#ac72ee55598617e8eecca384e746bab51',1,'vk_mem_alloc.h']]], - ['vmacreateimage_166',['vmaCreateImage',['../vk__mem__alloc_8h.html#a02a94f25679275851a53e82eacbcfc73',1,'vk_mem_alloc.h']]], - ['vmacreatelostallocation_167',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#ae5c9657d9e94756269145b01c05d16f1',1,'vk_mem_alloc.h']]], - ['vmacreatepool_168',['vmaCreatePool',['../vk__mem__alloc_8h.html#a5c8770ded7c59c8caac6de0c2cb00b50',1,'vk_mem_alloc.h']]], - ['vmadefragment_169',['vmaDefragment',['../vk__mem__alloc_8h.html#a6aced90fcc7b39882b6654a740a0b9bb',1,'vk_mem_alloc.h']]], - ['vmadefragmentationbegin_170',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a',1,'vk_mem_alloc.h']]], - ['vmadefragmentationcontext_171',['VmaDefragmentationContext',['../struct_vma_defragmentation_context.html',1,'']]], - ['vmadefragmentationend_172',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a8774e20e91e245aae959ba63efa15dd2',1,'vk_mem_alloc.h']]], - ['vmadefragmentationflagbits_173',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50c',1,'VmaDefragmentationFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#a96df0eddab2e1735782fe4e7cd05ea7f',1,'VmaDefragmentationFlagBits(): vk_mem_alloc.h']]], - ['vmadefragmentationflags_174',['VmaDefragmentationFlags',['../vk__mem__alloc_8h.html#a88a77cef37e5d3c4fc9eb328885d048d',1,'vk_mem_alloc.h']]], - ['vmadefragmentationinfo_175',['VmaDefragmentationInfo',['../struct_vma_defragmentation_info.html',1,'VmaDefragmentationInfo'],['../vk__mem__alloc_8h.html#ae67f8573a0cf20f16f0a1eecbca566a0',1,'VmaDefragmentationInfo(): vk_mem_alloc.h']]], - ['vmadefragmentationinfo2_176',['VmaDefragmentationInfo2',['../struct_vma_defragmentation_info2.html',1,'VmaDefragmentationInfo2'],['../vk__mem__alloc_8h.html#abac0e85abaa6ea1ffd63bde29c5c3a29',1,'VmaDefragmentationInfo2(): vk_mem_alloc.h']]], - ['vmadefragmentationstats_177',['VmaDefragmentationStats',['../struct_vma_defragmentation_stats.html',1,'VmaDefragmentationStats'],['../vk__mem__alloc_8h.html#ab0f9b06441c840fee560de4a2967f8c9',1,'VmaDefragmentationStats(): vk_mem_alloc.h']]], - ['vmadestroyallocator_178',['vmaDestroyAllocator',['../vk__mem__alloc_8h.html#aa8d164061c88f22fb1fd3c8f3534bc1d',1,'vk_mem_alloc.h']]], - ['vmadestroybuffer_179',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a0d9f4e4ba5bf9aab1f1c746387753d77',1,'vk_mem_alloc.h']]], - ['vmadestroyimage_180',['vmaDestroyImage',['../vk__mem__alloc_8h.html#ae50d2cb3b4a3bfd4dd40987234e50e7e',1,'vk_mem_alloc.h']]], - ['vmadestroypool_181',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a5485779c8f1948238fc4e92232fa65e1',1,'vk_mem_alloc.h']]], - ['vmadevicememorycallbacks_182',['VmaDeviceMemoryCallbacks',['../struct_vma_device_memory_callbacks.html',1,'VmaDeviceMemoryCallbacks'],['../vk__mem__alloc_8h.html#a5e2eb68d727cfd4df25702b027b7aa31',1,'VmaDeviceMemoryCallbacks(): vk_mem_alloc.h']]], - ['vmafindmemorytypeindex_183',['vmaFindMemoryTypeIndex',['../vk__mem__alloc_8h.html#aef15a94b58fbcb0fe706d5720e84a74a',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforbufferinfo_184',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#ae790ab9ffaf7667fb8f62523e6897888',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforimageinfo_185',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a088da83d8eaf3ce9056d9ea0b981d472',1,'vk_mem_alloc.h']]], - ['vmaflushallocation_186',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#abc34ee6f021f459aff885f3758c435de',1,'vk_mem_alloc.h']]], - ['vmafreememory_187',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a11f0fbc034fa81a4efedd73d61ce7568',1,'vk_mem_alloc.h']]], - ['vmafreememorypages_188',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#ab9e709de044c5d8476bea77a4e755840',1,'vk_mem_alloc.h']]], - ['vmafreestatsstring_189',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#a3104eb30d8122c84dd8541063f145288',1,'vk_mem_alloc.h']]], - ['vmagetallocationinfo_190',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b',1,'vk_mem_alloc.h']]], - ['vmagetbudget_191',['vmaGetBudget',['../vk__mem__alloc_8h.html#aec0ed24ebea2d0099eed5f801daaefba',1,'vk_mem_alloc.h']]], - ['vmagetmemoryproperties_192',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ab88db292a17974f911182543fda52d19',1,'vk_mem_alloc.h']]], - ['vmagetmemorytypeproperties_193',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#a8701444752eb5de4464adb5a2b514bca',1,'vk_mem_alloc.h']]], - ['vmagetphysicaldeviceproperties_194',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#aecabf7b6e91ea87d0316fa0a9e014fe0',1,'vk_mem_alloc.h']]], - ['vmagetpoolname_195',['vmaGetPoolName',['../vk__mem__alloc_8h.html#af09b4e4eafdbee812e8d73ddf960f030',1,'vk_mem_alloc.h']]], - ['vmagetpoolstats_196',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#ae8bf76997b234ef68aad922616df4153',1,'vk_mem_alloc.h']]], - ['vmainvalidateallocation_197',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a0d0eb0c1102268fa9a476d12ecbe4006',1,'vk_mem_alloc.h']]], - ['vmamakepoolallocationslost_198',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#a736bd6cbda886f36c891727e73bd4024',1,'vk_mem_alloc.h']]], - ['vmamapmemory_199',['vmaMapMemory',['../vk__mem__alloc_8h.html#ad5bd1243512d099706de88168992f069',1,'vk_mem_alloc.h']]], - ['vmamemoryusage_200',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cc',1,'VmaMemoryUsage(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#ad63b2113c0bfdbeade1cb498f5a8580d',1,'VmaMemoryUsage(): vk_mem_alloc.h']]], - ['vmapool_201',['VmaPool',['../struct_vma_pool.html',1,'']]], - ['vmapoolcreateflagbits_202',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'VmaPoolCreateFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#a8f93195158e0e2ac80ca352064e71c1f',1,'VmaPoolCreateFlagBits(): vk_mem_alloc.h']]], - ['vmapoolcreateflags_203',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], - ['vmapoolcreateinfo_204',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'VmaPoolCreateInfo'],['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'VmaPoolCreateInfo(): vk_mem_alloc.h']]], - ['vmapoolstats_205',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'VmaPoolStats'],['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'VmaPoolStats(): vk_mem_alloc.h']]], - ['vmarecordflagbits_206',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2',1,'VmaRecordFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'VmaRecordFlagBits(): vk_mem_alloc.h']]], - ['vmarecordflags_207',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], - ['vmarecordsettings_208',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'VmaRecordSettings'],['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'VmaRecordSettings(): vk_mem_alloc.h']]], - ['vmaresizeallocation_209',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696',1,'vk_mem_alloc.h']]], - ['vmasetallocationuserdata_210',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f',1,'vk_mem_alloc.h']]], - ['vmasetcurrentframeindex_211',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#ade56bf8dc9f5a5eaddf5f119ed525236',1,'vk_mem_alloc.h']]], - ['vmasetpoolname_212',['vmaSetPoolName',['../vk__mem__alloc_8h.html#adbae3a0b4ab078024462fc85c37f3b58',1,'vk_mem_alloc.h']]], - ['vmastatinfo_213',['VmaStatInfo',['../struct_vma_stat_info.html',1,'VmaStatInfo'],['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'VmaStatInfo(): vk_mem_alloc.h']]], - ['vmastats_214',['VmaStats',['../struct_vma_stats.html',1,'VmaStats'],['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'VmaStats(): vk_mem_alloc.h']]], - ['vmatouchallocation_215',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a43d8ba9673c846f049089a5029d5c73a',1,'vk_mem_alloc.h']]], - ['vmaunmapmemory_216',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a9bc268595cb33f6ec4d519cfce81ff45',1,'vk_mem_alloc.h']]], - ['vmavulkanfunctions_217',['VmaVulkanFunctions',['../struct_vma_vulkan_functions.html',1,'VmaVulkanFunctions'],['../vk__mem__alloc_8h.html#a97064a1a271b0061ebfc3a079862d0c5',1,'VmaVulkanFunctions(): vk_mem_alloc.h']]] + ['vma_5fvulkan_5fversion_142',['VMA_VULKAN_VERSION',['../vk__mem__alloc_8h.html#a1a2407c283893638cc039bb31fcd74b6',1,'vk_mem_alloc.h']]], + ['vmaallocatememory_143',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforbuffer_144',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforimage_145',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a0faa3f9e5fb233d29d1e00390650febb',1,'vk_mem_alloc.h']]], + ['vmaallocatememorypages_146',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#ad37e82e492b3de38fc3f4cffd9ad0ae1',1,'vk_mem_alloc.h']]], + ['vmaallocation_147',['VmaAllocation',['../struct_vma_allocation.html',1,'']]], + ['vmaallocationcreateflagbits_148',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597',1,'VmaAllocationCreateFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#abf6bf6748c7a9fe7ce5b7835c0f56af4',1,'VmaAllocationCreateFlagBits(): vk_mem_alloc.h']]], + ['vmaallocationcreateflags_149',['VmaAllocationCreateFlags',['../vk__mem__alloc_8h.html#a5225e5e11f8376f6a31a1791f3d6e817',1,'vk_mem_alloc.h']]], + ['vmaallocationcreateinfo_150',['VmaAllocationCreateInfo',['../struct_vma_allocation_create_info.html',1,'VmaAllocationCreateInfo'],['../vk__mem__alloc_8h.html#a86c44f9950b40d50088ed93a17870a7a',1,'VmaAllocationCreateInfo(): vk_mem_alloc.h']]], + ['vmaallocationinfo_151',['VmaAllocationInfo',['../struct_vma_allocation_info.html',1,'VmaAllocationInfo'],['../vk__mem__alloc_8h.html#a795e6ff02a21d5486c0565f403dd9255',1,'VmaAllocationInfo(): vk_mem_alloc.h']]], + ['vmaallocator_152',['VmaAllocator',['../struct_vma_allocator.html',1,'']]], + ['vmaallocatorcreateflagbits_153',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7c',1,'VmaAllocatorCreateFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#a4ddf381b6ce795bdfbc6c614640b9915',1,'VmaAllocatorCreateFlagBits(): vk_mem_alloc.h']]], + ['vmaallocatorcreateflags_154',['VmaAllocatorCreateFlags',['../vk__mem__alloc_8h.html#acfe6863e160722c2c1bbcf7573fddc4d',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateinfo_155',['VmaAllocatorCreateInfo',['../struct_vma_allocator_create_info.html',1,'VmaAllocatorCreateInfo'],['../vk__mem__alloc_8h.html#ae0f6d1d733dded220d28134da46b4283',1,'VmaAllocatorCreateInfo(): vk_mem_alloc.h']]], + ['vmabindbuffermemory_156',['vmaBindBufferMemory',['../vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470',1,'vk_mem_alloc.h']]], + ['vmabindbuffermemory2_157',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#a927c944f45e0f2941182abb6f608e64a',1,'vk_mem_alloc.h']]], + ['vmabindimagememory_158',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a3d3ca45799923aa5d138e9e5f9eb2da5',1,'vk_mem_alloc.h']]], + ['vmabindimagememory2_159',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#aa8251ee81b0045a443e35b8e8aa021bc',1,'vk_mem_alloc.h']]], + ['vmabudget_160',['VmaBudget',['../struct_vma_budget.html',1,'VmaBudget'],['../vk__mem__alloc_8h.html#ab79b48b6d25aada0de91a913896e1c38',1,'VmaBudget(): vk_mem_alloc.h']]], + ['vmabuildstatsstring_161',['vmaBuildStatsString',['../vk__mem__alloc_8h.html#aa4fee7eb5253377599ef4fd38c93c2a0',1,'vk_mem_alloc.h']]], + ['vmacalculatestats_162',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a333b61c1788cb23559177531e6a93ca3',1,'vk_mem_alloc.h']]], + ['vmacheckcorruption_163',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a49329a7f030dafcf82f7b73334c22e98',1,'vk_mem_alloc.h']]], + ['vmacheckpoolcorruption_164',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#ad535935619c7a549bf837e1bb0068f89',1,'vk_mem_alloc.h']]], + ['vmacreateallocator_165',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#a200692051ddb34240248234f5f4c17bb',1,'vk_mem_alloc.h']]], + ['vmacreatebuffer_166',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#ac72ee55598617e8eecca384e746bab51',1,'vk_mem_alloc.h']]], + ['vmacreateimage_167',['vmaCreateImage',['../vk__mem__alloc_8h.html#a02a94f25679275851a53e82eacbcfc73',1,'vk_mem_alloc.h']]], + ['vmacreatelostallocation_168',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#ae5c9657d9e94756269145b01c05d16f1',1,'vk_mem_alloc.h']]], + ['vmacreatepool_169',['vmaCreatePool',['../vk__mem__alloc_8h.html#a5c8770ded7c59c8caac6de0c2cb00b50',1,'vk_mem_alloc.h']]], + ['vmadefragment_170',['vmaDefragment',['../vk__mem__alloc_8h.html#a6aced90fcc7b39882b6654a740a0b9bb',1,'vk_mem_alloc.h']]], + ['vmadefragmentationbegin_171',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a',1,'vk_mem_alloc.h']]], + ['vmadefragmentationcontext_172',['VmaDefragmentationContext',['../struct_vma_defragmentation_context.html',1,'']]], + ['vmadefragmentationend_173',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a8774e20e91e245aae959ba63efa15dd2',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflagbits_174',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50c',1,'VmaDefragmentationFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#a96df0eddab2e1735782fe4e7cd05ea7f',1,'VmaDefragmentationFlagBits(): vk_mem_alloc.h']]], + ['vmadefragmentationflags_175',['VmaDefragmentationFlags',['../vk__mem__alloc_8h.html#a88a77cef37e5d3c4fc9eb328885d048d',1,'vk_mem_alloc.h']]], + ['vmadefragmentationinfo_176',['VmaDefragmentationInfo',['../struct_vma_defragmentation_info.html',1,'VmaDefragmentationInfo'],['../vk__mem__alloc_8h.html#ae67f8573a0cf20f16f0a1eecbca566a0',1,'VmaDefragmentationInfo(): vk_mem_alloc.h']]], + ['vmadefragmentationinfo2_177',['VmaDefragmentationInfo2',['../struct_vma_defragmentation_info2.html',1,'VmaDefragmentationInfo2'],['../vk__mem__alloc_8h.html#abac0e85abaa6ea1ffd63bde29c5c3a29',1,'VmaDefragmentationInfo2(): vk_mem_alloc.h']]], + ['vmadefragmentationstats_178',['VmaDefragmentationStats',['../struct_vma_defragmentation_stats.html',1,'VmaDefragmentationStats'],['../vk__mem__alloc_8h.html#ab0f9b06441c840fee560de4a2967f8c9',1,'VmaDefragmentationStats(): vk_mem_alloc.h']]], + ['vmadestroyallocator_179',['vmaDestroyAllocator',['../vk__mem__alloc_8h.html#aa8d164061c88f22fb1fd3c8f3534bc1d',1,'vk_mem_alloc.h']]], + ['vmadestroybuffer_180',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a0d9f4e4ba5bf9aab1f1c746387753d77',1,'vk_mem_alloc.h']]], + ['vmadestroyimage_181',['vmaDestroyImage',['../vk__mem__alloc_8h.html#ae50d2cb3b4a3bfd4dd40987234e50e7e',1,'vk_mem_alloc.h']]], + ['vmadestroypool_182',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a5485779c8f1948238fc4e92232fa65e1',1,'vk_mem_alloc.h']]], + ['vmadevicememorycallbacks_183',['VmaDeviceMemoryCallbacks',['../struct_vma_device_memory_callbacks.html',1,'VmaDeviceMemoryCallbacks'],['../vk__mem__alloc_8h.html#a5e2eb68d727cfd4df25702b027b7aa31',1,'VmaDeviceMemoryCallbacks(): vk_mem_alloc.h']]], + ['vmafindmemorytypeindex_184',['vmaFindMemoryTypeIndex',['../vk__mem__alloc_8h.html#aef15a94b58fbcb0fe706d5720e84a74a',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforbufferinfo_185',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#ae790ab9ffaf7667fb8f62523e6897888',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforimageinfo_186',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a088da83d8eaf3ce9056d9ea0b981d472',1,'vk_mem_alloc.h']]], + ['vmaflushallocation_187',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#abc34ee6f021f459aff885f3758c435de',1,'vk_mem_alloc.h']]], + ['vmafreememory_188',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a11f0fbc034fa81a4efedd73d61ce7568',1,'vk_mem_alloc.h']]], + ['vmafreememorypages_189',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#ab9e709de044c5d8476bea77a4e755840',1,'vk_mem_alloc.h']]], + ['vmafreestatsstring_190',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#a3104eb30d8122c84dd8541063f145288',1,'vk_mem_alloc.h']]], + ['vmagetallocationinfo_191',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b',1,'vk_mem_alloc.h']]], + ['vmagetbudget_192',['vmaGetBudget',['../vk__mem__alloc_8h.html#aec0ed24ebea2d0099eed5f801daaefba',1,'vk_mem_alloc.h']]], + ['vmagetmemoryproperties_193',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ab88db292a17974f911182543fda52d19',1,'vk_mem_alloc.h']]], + ['vmagetmemorytypeproperties_194',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#a8701444752eb5de4464adb5a2b514bca',1,'vk_mem_alloc.h']]], + ['vmagetphysicaldeviceproperties_195',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#aecabf7b6e91ea87d0316fa0a9e014fe0',1,'vk_mem_alloc.h']]], + ['vmagetpoolname_196',['vmaGetPoolName',['../vk__mem__alloc_8h.html#af09b4e4eafdbee812e8d73ddf960f030',1,'vk_mem_alloc.h']]], + ['vmagetpoolstats_197',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#ae8bf76997b234ef68aad922616df4153',1,'vk_mem_alloc.h']]], + ['vmainvalidateallocation_198',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a0d0eb0c1102268fa9a476d12ecbe4006',1,'vk_mem_alloc.h']]], + ['vmamakepoolallocationslost_199',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#a736bd6cbda886f36c891727e73bd4024',1,'vk_mem_alloc.h']]], + ['vmamapmemory_200',['vmaMapMemory',['../vk__mem__alloc_8h.html#ad5bd1243512d099706de88168992f069',1,'vk_mem_alloc.h']]], + ['vmamemoryusage_201',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cc',1,'VmaMemoryUsage(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#ad63b2113c0bfdbeade1cb498f5a8580d',1,'VmaMemoryUsage(): vk_mem_alloc.h']]], + ['vmapool_202',['VmaPool',['../struct_vma_pool.html',1,'']]], + ['vmapoolcreateflagbits_203',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'VmaPoolCreateFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#a8f93195158e0e2ac80ca352064e71c1f',1,'VmaPoolCreateFlagBits(): vk_mem_alloc.h']]], + ['vmapoolcreateflags_204',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], + ['vmapoolcreateinfo_205',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'VmaPoolCreateInfo'],['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'VmaPoolCreateInfo(): vk_mem_alloc.h']]], + ['vmapoolstats_206',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'VmaPoolStats'],['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'VmaPoolStats(): vk_mem_alloc.h']]], + ['vmarecordflagbits_207',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2',1,'VmaRecordFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'VmaRecordFlagBits(): vk_mem_alloc.h']]], + ['vmarecordflags_208',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], + ['vmarecordsettings_209',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'VmaRecordSettings'],['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'VmaRecordSettings(): vk_mem_alloc.h']]], + ['vmaresizeallocation_210',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696',1,'vk_mem_alloc.h']]], + ['vmasetallocationuserdata_211',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f',1,'vk_mem_alloc.h']]], + ['vmasetcurrentframeindex_212',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#ade56bf8dc9f5a5eaddf5f119ed525236',1,'vk_mem_alloc.h']]], + ['vmasetpoolname_213',['vmaSetPoolName',['../vk__mem__alloc_8h.html#adbae3a0b4ab078024462fc85c37f3b58',1,'vk_mem_alloc.h']]], + ['vmastatinfo_214',['VmaStatInfo',['../struct_vma_stat_info.html',1,'VmaStatInfo'],['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'VmaStatInfo(): vk_mem_alloc.h']]], + ['vmastats_215',['VmaStats',['../struct_vma_stats.html',1,'VmaStats'],['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'VmaStats(): vk_mem_alloc.h']]], + ['vmatouchallocation_216',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a43d8ba9673c846f049089a5029d5c73a',1,'vk_mem_alloc.h']]], + ['vmaunmapmemory_217',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a9bc268595cb33f6ec4d519cfce81ff45',1,'vk_mem_alloc.h']]], + ['vmavulkanfunctions_218',['VmaVulkanFunctions',['../struct_vma_vulkan_functions.html',1,'VmaVulkanFunctions'],['../vk__mem__alloc_8h.html#a97064a1a271b0061ebfc3a079862d0c5',1,'VmaVulkanFunctions(): vk_mem_alloc.h']]], + ['vulkanapiversion_219',['vulkanApiVersion',['../struct_vma_allocator_create_info.html#ae0ffc55139b54520a6bb704b29ffc285',1,'VmaAllocatorCreateInfo']]] ]; diff --git a/docs/html/search/classes_0.js b/docs/html/search/classes_0.js index bcf5282..2d8575f 100644 --- a/docs/html/search/classes_0.js +++ b/docs/html/search/classes_0.js @@ -1,21 +1,21 @@ var searchData= [ - ['vmaallocation_218',['VmaAllocation',['../struct_vma_allocation.html',1,'']]], - ['vmaallocationcreateinfo_219',['VmaAllocationCreateInfo',['../struct_vma_allocation_create_info.html',1,'']]], - ['vmaallocationinfo_220',['VmaAllocationInfo',['../struct_vma_allocation_info.html',1,'']]], - ['vmaallocator_221',['VmaAllocator',['../struct_vma_allocator.html',1,'']]], - ['vmaallocatorcreateinfo_222',['VmaAllocatorCreateInfo',['../struct_vma_allocator_create_info.html',1,'']]], - ['vmabudget_223',['VmaBudget',['../struct_vma_budget.html',1,'']]], - ['vmadefragmentationcontext_224',['VmaDefragmentationContext',['../struct_vma_defragmentation_context.html',1,'']]], - ['vmadefragmentationinfo_225',['VmaDefragmentationInfo',['../struct_vma_defragmentation_info.html',1,'']]], - ['vmadefragmentationinfo2_226',['VmaDefragmentationInfo2',['../struct_vma_defragmentation_info2.html',1,'']]], - ['vmadefragmentationstats_227',['VmaDefragmentationStats',['../struct_vma_defragmentation_stats.html',1,'']]], - ['vmadevicememorycallbacks_228',['VmaDeviceMemoryCallbacks',['../struct_vma_device_memory_callbacks.html',1,'']]], - ['vmapool_229',['VmaPool',['../struct_vma_pool.html',1,'']]], - ['vmapoolcreateinfo_230',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'']]], - ['vmapoolstats_231',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'']]], - ['vmarecordsettings_232',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'']]], - ['vmastatinfo_233',['VmaStatInfo',['../struct_vma_stat_info.html',1,'']]], - ['vmastats_234',['VmaStats',['../struct_vma_stats.html',1,'']]], - ['vmavulkanfunctions_235',['VmaVulkanFunctions',['../struct_vma_vulkan_functions.html',1,'']]] + ['vmaallocation_220',['VmaAllocation',['../struct_vma_allocation.html',1,'']]], + ['vmaallocationcreateinfo_221',['VmaAllocationCreateInfo',['../struct_vma_allocation_create_info.html',1,'']]], + ['vmaallocationinfo_222',['VmaAllocationInfo',['../struct_vma_allocation_info.html',1,'']]], + ['vmaallocator_223',['VmaAllocator',['../struct_vma_allocator.html',1,'']]], + ['vmaallocatorcreateinfo_224',['VmaAllocatorCreateInfo',['../struct_vma_allocator_create_info.html',1,'']]], + ['vmabudget_225',['VmaBudget',['../struct_vma_budget.html',1,'']]], + ['vmadefragmentationcontext_226',['VmaDefragmentationContext',['../struct_vma_defragmentation_context.html',1,'']]], + ['vmadefragmentationinfo_227',['VmaDefragmentationInfo',['../struct_vma_defragmentation_info.html',1,'']]], + ['vmadefragmentationinfo2_228',['VmaDefragmentationInfo2',['../struct_vma_defragmentation_info2.html',1,'']]], + ['vmadefragmentationstats_229',['VmaDefragmentationStats',['../struct_vma_defragmentation_stats.html',1,'']]], + ['vmadevicememorycallbacks_230',['VmaDeviceMemoryCallbacks',['../struct_vma_device_memory_callbacks.html',1,'']]], + ['vmapool_231',['VmaPool',['../struct_vma_pool.html',1,'']]], + ['vmapoolcreateinfo_232',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'']]], + ['vmapoolstats_233',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'']]], + ['vmarecordsettings_234',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'']]], + ['vmastatinfo_235',['VmaStatInfo',['../struct_vma_stat_info.html',1,'']]], + ['vmastats_236',['VmaStats',['../struct_vma_stats.html',1,'']]], + ['vmavulkanfunctions_237',['VmaVulkanFunctions',['../struct_vma_vulkan_functions.html',1,'']]] ]; diff --git a/docs/html/search/defines_0.js b/docs/html/search/defines_0.js index 3f272ff..1fdc224 100644 --- a/docs/html/search/defines_0.js +++ b/docs/html/search/defines_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['nominmax_433',['NOMINMAX',['../vk__mem__alloc_8h.html#a9f918755b601cf4bffca775992e6fb90',1,'vk_mem_alloc.h']]] + ['nominmax_436',['NOMINMAX',['../vk__mem__alloc_8h.html#a9f918755b601cf4bffca775992e6fb90',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/defines_1.js b/docs/html/search/defines_1.js index 9bb8c9b..5ca4775 100644 --- a/docs/html/search/defines_1.js +++ b/docs/html/search/defines_1.js @@ -1,8 +1,9 @@ var searchData= [ - ['vma_5fbind_5fmemory2_434',['VMA_BIND_MEMORY2',['../vk__mem__alloc_8h.html#a88bef97f86d70a34a4c0746e09a2680d',1,'vk_mem_alloc.h']]], - ['vma_5fdedicated_5fallocation_435',['VMA_DEDICATED_ALLOCATION',['../vk__mem__alloc_8h.html#af7b860e63b96d11e44ae8587ba06bbf4',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fbudget_436',['VMA_MEMORY_BUDGET',['../vk__mem__alloc_8h.html#a05decf1cf4ebf767beba7acca6c1ec3a',1,'vk_mem_alloc.h']]], - ['vma_5frecording_5fenabled_437',['VMA_RECORDING_ENABLED',['../vk__mem__alloc_8h.html#a1f0c126759fc96ccb6e2d23c101d770c',1,'vk_mem_alloc.h']]], - ['vma_5fstats_5fstring_5fenabled_438',['VMA_STATS_STRING_ENABLED',['../vk__mem__alloc_8h.html#ae25f0d55fd91cb166f002b63244800e1',1,'vk_mem_alloc.h']]] + ['vma_5fbind_5fmemory2_437',['VMA_BIND_MEMORY2',['../vk__mem__alloc_8h.html#a88bef97f86d70a34a4c0746e09a2680d',1,'vk_mem_alloc.h']]], + ['vma_5fdedicated_5fallocation_438',['VMA_DEDICATED_ALLOCATION',['../vk__mem__alloc_8h.html#af7b860e63b96d11e44ae8587ba06bbf4',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fbudget_439',['VMA_MEMORY_BUDGET',['../vk__mem__alloc_8h.html#a05decf1cf4ebf767beba7acca6c1ec3a',1,'vk_mem_alloc.h']]], + ['vma_5frecording_5fenabled_440',['VMA_RECORDING_ENABLED',['../vk__mem__alloc_8h.html#a1f0c126759fc96ccb6e2d23c101d770c',1,'vk_mem_alloc.h']]], + ['vma_5fstats_5fstring_5fenabled_441',['VMA_STATS_STRING_ENABLED',['../vk__mem__alloc_8h.html#ae25f0d55fd91cb166f002b63244800e1',1,'vk_mem_alloc.h']]], + ['vma_5fvulkan_5fversion_442',['VMA_VULKAN_VERSION',['../vk__mem__alloc_8h.html#a1a2407c283893638cc039bb31fcd74b6',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/enums_0.js b/docs/html/search/enums_0.js index ce66ca0..9561daf 100644 --- a/docs/html/search/enums_0.js +++ b/docs/html/search/enums_0.js @@ -1,9 +1,9 @@ var searchData= [ - ['vmaallocationcreateflagbits_389',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateflagbits_390',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7c',1,'vk_mem_alloc.h']]], - ['vmadefragmentationflagbits_391',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50c',1,'vk_mem_alloc.h']]], - ['vmamemoryusage_392',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cc',1,'vk_mem_alloc.h']]], - ['vmapoolcreateflagbits_393',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'vk_mem_alloc.h']]], - ['vmarecordflagbits_394',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2',1,'vk_mem_alloc.h']]] + ['vmaallocationcreateflagbits_392',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateflagbits_393',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7c',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflagbits_394',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50c',1,'vk_mem_alloc.h']]], + ['vmamemoryusage_395',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cc',1,'vk_mem_alloc.h']]], + ['vmapoolcreateflagbits_396',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'vk_mem_alloc.h']]], + ['vmarecordflagbits_397',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/enumvalues_0.js b/docs/html/search/enumvalues_0.js index 3f2b41f..5a93deb 100644 --- a/docs/html/search/enumvalues_0.js +++ b/docs/html/search/enumvalues_0.js @@ -1,41 +1,41 @@ var searchData= [ - ['vma_5fallocation_5fcreate_5fcan_5fbecome_5flost_5fbit_395',['VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a5f436af6c8fe8540573a6d22627a6fd2',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fcan_5fmake_5fother_5flost_5fbit_396',['VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a68686d0ce9beb0d4d1b9f2b8b1389a7e',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fdedicated_5fmemory_5fbit_397',['VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a3fc311d855c2ff53f1090ef5c722b38f',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fdont_5fbind_5fbit_398',['VMA_ALLOCATION_CREATE_DONT_BIND_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a2310568c62208af432724305fe29ccea',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fflag_5fbits_5fmax_5fenum_399',['VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ae5633ec569f4899cf8f29e7385b2f882',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fmapped_5fbit_400',['VMA_ALLOCATION_CREATE_MAPPED_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a11da372cc3a82931c5e5d6146cd9dd1f',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fnever_5fallocate_5fbit_401',['VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a89759603401014eb325eb22a3839f2ff',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fbest_5ffit_5fbit_402',['VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a839826775c62319466441f86496f036d',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5ffirst_5ffit_5fbit_403',['VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a33eb2052674f3ad92386c714a65fb777',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fmask_404',['VMA_ALLOCATION_CREATE_STRATEGY_MASK',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a8e16845d81ae3d27c47106d4770d5c7e',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5ffragmentation_5fbit_405',['VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a621b704103eb3360230c860acf36e706',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5fmemory_5fbit_406',['VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a8af1210cf591784afa026d94998f735d',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5ftime_5fbit_407',['VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a0729e932b7ea170e3a128cad96c5cf6d',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fworst_5ffit_5fbit_408',['VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ad242a04f802e25fef0b880afe8bb0a62',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fupper_5faddress_5fbit_409',['VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a42ba3a2d2c7117953210b7c3ef8da0df',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fuser_5fdata_5fcopy_5fstring_5fbit_410',['VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597aa6f24f821cd6a7c5e4a443f7bf59c520',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fwithin_5fbudget_5fbit_411',['VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ab8b1764f3e9022368e440c057783b92d',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fext_5fmemory_5fbudget_5fbit_412',['VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4d4687863f7bd4b418c6006dc04400b0',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fexternally_5fsynchronized_5fbit_413',['VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4816ddaed324ba110172ca608a20f29d',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fflag_5fbits_5fmax_5fenum_414',['VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7cae4d5ad929caba5f23eb502b13bd5286c',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fkhr_5fbind_5fmemory2_5fbit_415',['VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca8fb75bf07cd184ab903596295e863dee',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fkhr_5fdedicated_5fallocation_5fbit_416',['VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7cace7da7cc6e71a625dfa763c55a597878',1,'vk_mem_alloc.h']]], - ['vma_5fdefragmentation_5fflag_5fbits_5fmax_5fenum_417',['VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50cab87ec33154803bfeb5ac2b379f1d6a97',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fcpu_5fcopy_418',['VMA_MEMORY_USAGE_CPU_COPY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca416a444d4d0fc20067c3f76f32ff2500',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fcpu_5fonly_419',['VMA_MEMORY_USAGE_CPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca40bdf4cddeffeb12f43d45ca1286e0a5',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fcpu_5fto_5fgpu_420',['VMA_MEMORY_USAGE_CPU_TO_GPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca9066b52c5a7079bb74a69aaf8b92ff67',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fgpu_5flazily_5fallocated_421',['VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca835333d9072db63a653818030e17614d',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fgpu_5fonly_422',['VMA_MEMORY_USAGE_GPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccac6b5dc1432d88647aa4cd456246eadf7',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fgpu_5fto_5fcpu_423',['VMA_MEMORY_USAGE_GPU_TO_CPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca7b586d2fdaf82a463b58f581ed72be27',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fmax_5fenum_424',['VMA_MEMORY_USAGE_MAX_ENUM',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca091e69437ef693e8d0d287f1c719ba6e',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5funknown_425',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5falgorithm_5fmask_426',['VMA_POOL_CREATE_ALGORITHM_MASK',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7af4d270f8f42517a0f70037ceb6ac1d9c',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fbuddy_5falgorithm_5fbit_427',['VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a97a0dc38e5161b780594d998d313d35e',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum_428',['VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a1c7312bea9ea246846b9054fd6bd6aec',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fignore_5fbuffer_5fimage_5fgranularity_5fbit_429',['VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a9f1a499508a8edb4e8ba40aa0290a3d2',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5flinear_5falgorithm_5fbit_430',['VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a13c8a444197c67866be9cb05599fc726',1,'vk_mem_alloc.h']]], - ['vma_5frecord_5fflag_5fbits_5fmax_5fenum_431',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], - ['vma_5frecord_5fflush_5fafter_5fcall_5fbit_432',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]] + ['vma_5fallocation_5fcreate_5fcan_5fbecome_5flost_5fbit_398',['VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a5f436af6c8fe8540573a6d22627a6fd2',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fcan_5fmake_5fother_5flost_5fbit_399',['VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a68686d0ce9beb0d4d1b9f2b8b1389a7e',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fdedicated_5fmemory_5fbit_400',['VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a3fc311d855c2ff53f1090ef5c722b38f',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fdont_5fbind_5fbit_401',['VMA_ALLOCATION_CREATE_DONT_BIND_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a2310568c62208af432724305fe29ccea',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fflag_5fbits_5fmax_5fenum_402',['VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ae5633ec569f4899cf8f29e7385b2f882',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fmapped_5fbit_403',['VMA_ALLOCATION_CREATE_MAPPED_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a11da372cc3a82931c5e5d6146cd9dd1f',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fnever_5fallocate_5fbit_404',['VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a89759603401014eb325eb22a3839f2ff',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fbest_5ffit_5fbit_405',['VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a839826775c62319466441f86496f036d',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5ffirst_5ffit_5fbit_406',['VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a33eb2052674f3ad92386c714a65fb777',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fmask_407',['VMA_ALLOCATION_CREATE_STRATEGY_MASK',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a8e16845d81ae3d27c47106d4770d5c7e',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5ffragmentation_5fbit_408',['VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a621b704103eb3360230c860acf36e706',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5fmemory_5fbit_409',['VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a8af1210cf591784afa026d94998f735d',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5ftime_5fbit_410',['VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a0729e932b7ea170e3a128cad96c5cf6d',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fworst_5ffit_5fbit_411',['VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ad242a04f802e25fef0b880afe8bb0a62',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fupper_5faddress_5fbit_412',['VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a42ba3a2d2c7117953210b7c3ef8da0df',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fuser_5fdata_5fcopy_5fstring_5fbit_413',['VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597aa6f24f821cd6a7c5e4a443f7bf59c520',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fwithin_5fbudget_5fbit_414',['VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ab8b1764f3e9022368e440c057783b92d',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fext_5fmemory_5fbudget_5fbit_415',['VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4d4687863f7bd4b418c6006dc04400b0',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fexternally_5fsynchronized_5fbit_416',['VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4816ddaed324ba110172ca608a20f29d',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fflag_5fbits_5fmax_5fenum_417',['VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7cae4d5ad929caba5f23eb502b13bd5286c',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fkhr_5fbind_5fmemory2_5fbit_418',['VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca8fb75bf07cd184ab903596295e863dee',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fkhr_5fdedicated_5fallocation_5fbit_419',['VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7cace7da7cc6e71a625dfa763c55a597878',1,'vk_mem_alloc.h']]], + ['vma_5fdefragmentation_5fflag_5fbits_5fmax_5fenum_420',['VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50cab87ec33154803bfeb5ac2b379f1d6a97',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fcpu_5fcopy_421',['VMA_MEMORY_USAGE_CPU_COPY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca416a444d4d0fc20067c3f76f32ff2500',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fcpu_5fonly_422',['VMA_MEMORY_USAGE_CPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca40bdf4cddeffeb12f43d45ca1286e0a5',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fcpu_5fto_5fgpu_423',['VMA_MEMORY_USAGE_CPU_TO_GPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca9066b52c5a7079bb74a69aaf8b92ff67',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fgpu_5flazily_5fallocated_424',['VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca835333d9072db63a653818030e17614d',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fgpu_5fonly_425',['VMA_MEMORY_USAGE_GPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccac6b5dc1432d88647aa4cd456246eadf7',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fgpu_5fto_5fcpu_426',['VMA_MEMORY_USAGE_GPU_TO_CPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca7b586d2fdaf82a463b58f581ed72be27',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fmax_5fenum_427',['VMA_MEMORY_USAGE_MAX_ENUM',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca091e69437ef693e8d0d287f1c719ba6e',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5funknown_428',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5falgorithm_5fmask_429',['VMA_POOL_CREATE_ALGORITHM_MASK',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7af4d270f8f42517a0f70037ceb6ac1d9c',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5fbuddy_5falgorithm_5fbit_430',['VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a97a0dc38e5161b780594d998d313d35e',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum_431',['VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a1c7312bea9ea246846b9054fd6bd6aec',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5fignore_5fbuffer_5fimage_5fgranularity_5fbit_432',['VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a9f1a499508a8edb4e8ba40aa0290a3d2',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5flinear_5falgorithm_5fbit_433',['VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a13c8a444197c67866be9cb05599fc726',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflag_5fbits_5fmax_5fenum_434',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflush_5fafter_5fcall_5fbit_435',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/files_0.js b/docs/html/search/files_0.js index cd7fb5a..3d1d93e 100644 --- a/docs/html/search/files_0.js +++ b/docs/html/search/files_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['vk_5fmem_5falloc_2eh_236',['vk_mem_alloc.h',['../vk__mem__alloc_8h.html',1,'']]] + ['vk_5fmem_5falloc_2eh_238',['vk_mem_alloc.h',['../vk__mem__alloc_8h.html',1,'']]] ]; diff --git a/docs/html/search/functions_0.js b/docs/html/search/functions_0.js index f3d9653..9e43030 100644 --- a/docs/html/search/functions_0.js +++ b/docs/html/search/functions_0.js @@ -1,50 +1,50 @@ var searchData= [ - ['vmaallocatememory_237',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforbuffer_238',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforimage_239',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a0faa3f9e5fb233d29d1e00390650febb',1,'vk_mem_alloc.h']]], - ['vmaallocatememorypages_240',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#ad37e82e492b3de38fc3f4cffd9ad0ae1',1,'vk_mem_alloc.h']]], - ['vmabindbuffermemory_241',['vmaBindBufferMemory',['../vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470',1,'vk_mem_alloc.h']]], - ['vmabindbuffermemory2_242',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#a927c944f45e0f2941182abb6f608e64a',1,'vk_mem_alloc.h']]], - ['vmabindimagememory_243',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a3d3ca45799923aa5d138e9e5f9eb2da5',1,'vk_mem_alloc.h']]], - ['vmabindimagememory2_244',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#aa8251ee81b0045a443e35b8e8aa021bc',1,'vk_mem_alloc.h']]], - ['vmabuildstatsstring_245',['vmaBuildStatsString',['../vk__mem__alloc_8h.html#aa4fee7eb5253377599ef4fd38c93c2a0',1,'vk_mem_alloc.h']]], - ['vmacalculatestats_246',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a333b61c1788cb23559177531e6a93ca3',1,'vk_mem_alloc.h']]], - ['vmacheckcorruption_247',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a49329a7f030dafcf82f7b73334c22e98',1,'vk_mem_alloc.h']]], - ['vmacheckpoolcorruption_248',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#ad535935619c7a549bf837e1bb0068f89',1,'vk_mem_alloc.h']]], - ['vmacreateallocator_249',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#a200692051ddb34240248234f5f4c17bb',1,'vk_mem_alloc.h']]], - ['vmacreatebuffer_250',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#ac72ee55598617e8eecca384e746bab51',1,'vk_mem_alloc.h']]], - ['vmacreateimage_251',['vmaCreateImage',['../vk__mem__alloc_8h.html#a02a94f25679275851a53e82eacbcfc73',1,'vk_mem_alloc.h']]], - ['vmacreatelostallocation_252',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#ae5c9657d9e94756269145b01c05d16f1',1,'vk_mem_alloc.h']]], - ['vmacreatepool_253',['vmaCreatePool',['../vk__mem__alloc_8h.html#a5c8770ded7c59c8caac6de0c2cb00b50',1,'vk_mem_alloc.h']]], - ['vmadefragment_254',['vmaDefragment',['../vk__mem__alloc_8h.html#a6aced90fcc7b39882b6654a740a0b9bb',1,'vk_mem_alloc.h']]], - ['vmadefragmentationbegin_255',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a',1,'vk_mem_alloc.h']]], - ['vmadefragmentationend_256',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a8774e20e91e245aae959ba63efa15dd2',1,'vk_mem_alloc.h']]], - ['vmadestroyallocator_257',['vmaDestroyAllocator',['../vk__mem__alloc_8h.html#aa8d164061c88f22fb1fd3c8f3534bc1d',1,'vk_mem_alloc.h']]], - ['vmadestroybuffer_258',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a0d9f4e4ba5bf9aab1f1c746387753d77',1,'vk_mem_alloc.h']]], - ['vmadestroyimage_259',['vmaDestroyImage',['../vk__mem__alloc_8h.html#ae50d2cb3b4a3bfd4dd40987234e50e7e',1,'vk_mem_alloc.h']]], - ['vmadestroypool_260',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a5485779c8f1948238fc4e92232fa65e1',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindex_261',['vmaFindMemoryTypeIndex',['../vk__mem__alloc_8h.html#aef15a94b58fbcb0fe706d5720e84a74a',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforbufferinfo_262',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#ae790ab9ffaf7667fb8f62523e6897888',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforimageinfo_263',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a088da83d8eaf3ce9056d9ea0b981d472',1,'vk_mem_alloc.h']]], - ['vmaflushallocation_264',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#abc34ee6f021f459aff885f3758c435de',1,'vk_mem_alloc.h']]], - ['vmafreememory_265',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a11f0fbc034fa81a4efedd73d61ce7568',1,'vk_mem_alloc.h']]], - ['vmafreememorypages_266',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#ab9e709de044c5d8476bea77a4e755840',1,'vk_mem_alloc.h']]], - ['vmafreestatsstring_267',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#a3104eb30d8122c84dd8541063f145288',1,'vk_mem_alloc.h']]], - ['vmagetallocationinfo_268',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b',1,'vk_mem_alloc.h']]], - ['vmagetbudget_269',['vmaGetBudget',['../vk__mem__alloc_8h.html#aec0ed24ebea2d0099eed5f801daaefba',1,'vk_mem_alloc.h']]], - ['vmagetmemoryproperties_270',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ab88db292a17974f911182543fda52d19',1,'vk_mem_alloc.h']]], - ['vmagetmemorytypeproperties_271',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#a8701444752eb5de4464adb5a2b514bca',1,'vk_mem_alloc.h']]], - ['vmagetphysicaldeviceproperties_272',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#aecabf7b6e91ea87d0316fa0a9e014fe0',1,'vk_mem_alloc.h']]], - ['vmagetpoolname_273',['vmaGetPoolName',['../vk__mem__alloc_8h.html#af09b4e4eafdbee812e8d73ddf960f030',1,'vk_mem_alloc.h']]], - ['vmagetpoolstats_274',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#ae8bf76997b234ef68aad922616df4153',1,'vk_mem_alloc.h']]], - ['vmainvalidateallocation_275',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a0d0eb0c1102268fa9a476d12ecbe4006',1,'vk_mem_alloc.h']]], - ['vmamakepoolallocationslost_276',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#a736bd6cbda886f36c891727e73bd4024',1,'vk_mem_alloc.h']]], - ['vmamapmemory_277',['vmaMapMemory',['../vk__mem__alloc_8h.html#ad5bd1243512d099706de88168992f069',1,'vk_mem_alloc.h']]], - ['vmaresizeallocation_278',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696',1,'vk_mem_alloc.h']]], - ['vmasetallocationuserdata_279',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f',1,'vk_mem_alloc.h']]], - ['vmasetcurrentframeindex_280',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#ade56bf8dc9f5a5eaddf5f119ed525236',1,'vk_mem_alloc.h']]], - ['vmasetpoolname_281',['vmaSetPoolName',['../vk__mem__alloc_8h.html#adbae3a0b4ab078024462fc85c37f3b58',1,'vk_mem_alloc.h']]], - ['vmatouchallocation_282',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a43d8ba9673c846f049089a5029d5c73a',1,'vk_mem_alloc.h']]], - ['vmaunmapmemory_283',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a9bc268595cb33f6ec4d519cfce81ff45',1,'vk_mem_alloc.h']]] + ['vmaallocatememory_239',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforbuffer_240',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforimage_241',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a0faa3f9e5fb233d29d1e00390650febb',1,'vk_mem_alloc.h']]], + ['vmaallocatememorypages_242',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#ad37e82e492b3de38fc3f4cffd9ad0ae1',1,'vk_mem_alloc.h']]], + ['vmabindbuffermemory_243',['vmaBindBufferMemory',['../vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470',1,'vk_mem_alloc.h']]], + ['vmabindbuffermemory2_244',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#a927c944f45e0f2941182abb6f608e64a',1,'vk_mem_alloc.h']]], + ['vmabindimagememory_245',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a3d3ca45799923aa5d138e9e5f9eb2da5',1,'vk_mem_alloc.h']]], + ['vmabindimagememory2_246',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#aa8251ee81b0045a443e35b8e8aa021bc',1,'vk_mem_alloc.h']]], + ['vmabuildstatsstring_247',['vmaBuildStatsString',['../vk__mem__alloc_8h.html#aa4fee7eb5253377599ef4fd38c93c2a0',1,'vk_mem_alloc.h']]], + ['vmacalculatestats_248',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a333b61c1788cb23559177531e6a93ca3',1,'vk_mem_alloc.h']]], + ['vmacheckcorruption_249',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a49329a7f030dafcf82f7b73334c22e98',1,'vk_mem_alloc.h']]], + ['vmacheckpoolcorruption_250',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#ad535935619c7a549bf837e1bb0068f89',1,'vk_mem_alloc.h']]], + ['vmacreateallocator_251',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#a200692051ddb34240248234f5f4c17bb',1,'vk_mem_alloc.h']]], + ['vmacreatebuffer_252',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#ac72ee55598617e8eecca384e746bab51',1,'vk_mem_alloc.h']]], + ['vmacreateimage_253',['vmaCreateImage',['../vk__mem__alloc_8h.html#a02a94f25679275851a53e82eacbcfc73',1,'vk_mem_alloc.h']]], + ['vmacreatelostallocation_254',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#ae5c9657d9e94756269145b01c05d16f1',1,'vk_mem_alloc.h']]], + ['vmacreatepool_255',['vmaCreatePool',['../vk__mem__alloc_8h.html#a5c8770ded7c59c8caac6de0c2cb00b50',1,'vk_mem_alloc.h']]], + ['vmadefragment_256',['vmaDefragment',['../vk__mem__alloc_8h.html#a6aced90fcc7b39882b6654a740a0b9bb',1,'vk_mem_alloc.h']]], + ['vmadefragmentationbegin_257',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a',1,'vk_mem_alloc.h']]], + ['vmadefragmentationend_258',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a8774e20e91e245aae959ba63efa15dd2',1,'vk_mem_alloc.h']]], + ['vmadestroyallocator_259',['vmaDestroyAllocator',['../vk__mem__alloc_8h.html#aa8d164061c88f22fb1fd3c8f3534bc1d',1,'vk_mem_alloc.h']]], + ['vmadestroybuffer_260',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a0d9f4e4ba5bf9aab1f1c746387753d77',1,'vk_mem_alloc.h']]], + ['vmadestroyimage_261',['vmaDestroyImage',['../vk__mem__alloc_8h.html#ae50d2cb3b4a3bfd4dd40987234e50e7e',1,'vk_mem_alloc.h']]], + ['vmadestroypool_262',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a5485779c8f1948238fc4e92232fa65e1',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindex_263',['vmaFindMemoryTypeIndex',['../vk__mem__alloc_8h.html#aef15a94b58fbcb0fe706d5720e84a74a',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforbufferinfo_264',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#ae790ab9ffaf7667fb8f62523e6897888',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforimageinfo_265',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a088da83d8eaf3ce9056d9ea0b981d472',1,'vk_mem_alloc.h']]], + ['vmaflushallocation_266',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#abc34ee6f021f459aff885f3758c435de',1,'vk_mem_alloc.h']]], + ['vmafreememory_267',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a11f0fbc034fa81a4efedd73d61ce7568',1,'vk_mem_alloc.h']]], + ['vmafreememorypages_268',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#ab9e709de044c5d8476bea77a4e755840',1,'vk_mem_alloc.h']]], + ['vmafreestatsstring_269',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#a3104eb30d8122c84dd8541063f145288',1,'vk_mem_alloc.h']]], + ['vmagetallocationinfo_270',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b',1,'vk_mem_alloc.h']]], + ['vmagetbudget_271',['vmaGetBudget',['../vk__mem__alloc_8h.html#aec0ed24ebea2d0099eed5f801daaefba',1,'vk_mem_alloc.h']]], + ['vmagetmemoryproperties_272',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ab88db292a17974f911182543fda52d19',1,'vk_mem_alloc.h']]], + ['vmagetmemorytypeproperties_273',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#a8701444752eb5de4464adb5a2b514bca',1,'vk_mem_alloc.h']]], + ['vmagetphysicaldeviceproperties_274',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#aecabf7b6e91ea87d0316fa0a9e014fe0',1,'vk_mem_alloc.h']]], + ['vmagetpoolname_275',['vmaGetPoolName',['../vk__mem__alloc_8h.html#af09b4e4eafdbee812e8d73ddf960f030',1,'vk_mem_alloc.h']]], + ['vmagetpoolstats_276',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#ae8bf76997b234ef68aad922616df4153',1,'vk_mem_alloc.h']]], + ['vmainvalidateallocation_277',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a0d0eb0c1102268fa9a476d12ecbe4006',1,'vk_mem_alloc.h']]], + ['vmamakepoolallocationslost_278',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#a736bd6cbda886f36c891727e73bd4024',1,'vk_mem_alloc.h']]], + ['vmamapmemory_279',['vmaMapMemory',['../vk__mem__alloc_8h.html#ad5bd1243512d099706de88168992f069',1,'vk_mem_alloc.h']]], + ['vmaresizeallocation_280',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696',1,'vk_mem_alloc.h']]], + ['vmasetallocationuserdata_281',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f',1,'vk_mem_alloc.h']]], + ['vmasetcurrentframeindex_282',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#ade56bf8dc9f5a5eaddf5f119ed525236',1,'vk_mem_alloc.h']]], + ['vmasetpoolname_283',['vmaSetPoolName',['../vk__mem__alloc_8h.html#adbae3a0b4ab078024462fc85c37f3b58',1,'vk_mem_alloc.h']]], + ['vmatouchallocation_284',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a43d8ba9673c846f049089a5029d5c73a',1,'vk_mem_alloc.h']]], + ['vmaunmapmemory_285',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a9bc268595cb33f6ec4d519cfce81ff45',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/pages_0.js b/docs/html/search/pages_0.js index 9d4a4ff..1d82fdb 100644 --- a/docs/html/search/pages_0.js +++ b/docs/html/search/pages_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['allocation_20names_20and_20user_20data_439',['Allocation names and user data',['../allocation_annotation.html',1,'']]] + ['allocation_20names_20and_20user_20data_443',['Allocation names and user data',['../allocation_annotation.html',1,'']]] ]; diff --git a/docs/html/search/pages_1.js b/docs/html/search/pages_1.js index fd9dfdb..21a2119 100644 --- a/docs/html/search/pages_1.js +++ b/docs/html/search/pages_1.js @@ -1,6 +1,6 @@ var searchData= [ - ['choosing_20memory_20type_440',['Choosing memory type',['../choosing_memory_type.html',1,'']]], - ['configuration_441',['Configuration',['../configuration.html',1,'']]], - ['custom_20memory_20pools_442',['Custom memory pools',['../custom_memory_pools.html',1,'']]] + ['choosing_20memory_20type_444',['Choosing memory type',['../choosing_memory_type.html',1,'']]], + ['configuration_445',['Configuration',['../configuration.html',1,'']]], + ['custom_20memory_20pools_446',['Custom memory pools',['../custom_memory_pools.html',1,'']]] ]; diff --git a/docs/html/search/pages_2.js b/docs/html/search/pages_2.js index afc7808..c973588 100644 --- a/docs/html/search/pages_2.js +++ b/docs/html/search/pages_2.js @@ -1,6 +1,6 @@ var searchData= [ - ['debugging_20incorrect_20memory_20usage_443',['Debugging incorrect memory usage',['../debugging_memory_usage.html',1,'']]], - ['defragmentation_444',['Defragmentation',['../defragmentation.html',1,'']]], - ['deprecated_20list_445',['Deprecated List',['../deprecated.html',1,'']]] + ['debugging_20incorrect_20memory_20usage_447',['Debugging incorrect memory usage',['../debugging_memory_usage.html',1,'']]], + ['defragmentation_448',['Defragmentation',['../defragmentation.html',1,'']]], + ['deprecated_20list_449',['Deprecated List',['../deprecated.html',1,'']]] ]; diff --git a/docs/html/search/pages_3.js b/docs/html/search/pages_3.js index 3c15760..174dd5e 100644 --- a/docs/html/search/pages_3.js +++ b/docs/html/search/pages_3.js @@ -1,4 +1,4 @@ var searchData= [ - ['general_20considerations_446',['General considerations',['../general_considerations.html',1,'']]] + ['general_20considerations_450',['General considerations',['../general_considerations.html',1,'']]] ]; diff --git a/docs/html/search/pages_4.js b/docs/html/search/pages_4.js index b67f83d..88bc63f 100644 --- a/docs/html/search/pages_4.js +++ b/docs/html/search/pages_4.js @@ -1,4 +1,4 @@ var searchData= [ - ['lost_20allocations_447',['Lost allocations',['../lost_allocations.html',1,'']]] + ['lost_20allocations_451',['Lost allocations',['../lost_allocations.html',1,'']]] ]; diff --git a/docs/html/search/pages_5.js b/docs/html/search/pages_5.js index ee83302..2721810 100644 --- a/docs/html/search/pages_5.js +++ b/docs/html/search/pages_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['memory_20mapping_448',['Memory mapping',['../memory_mapping.html',1,'']]] + ['memory_20mapping_452',['Memory mapping',['../memory_mapping.html',1,'']]] ]; diff --git a/docs/html/search/pages_6.js b/docs/html/search/pages_6.js index 49c8b1f..a208f81 100644 --- a/docs/html/search/pages_6.js +++ b/docs/html/search/pages_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['quick_20start_449',['Quick start',['../quick_start.html',1,'']]] + ['quick_20start_453',['Quick start',['../quick_start.html',1,'']]] ]; diff --git a/docs/html/search/pages_7.js b/docs/html/search/pages_7.js index eaeaf36..fd516c0 100644 --- a/docs/html/search/pages_7.js +++ b/docs/html/search/pages_7.js @@ -1,5 +1,5 @@ var searchData= [ - ['record_20and_20replay_450',['Record and replay',['../record_and_replay.html',1,'']]], - ['recommended_20usage_20patterns_451',['Recommended usage patterns',['../usage_patterns.html',1,'']]] + ['record_20and_20replay_454',['Record and replay',['../record_and_replay.html',1,'']]], + ['recommended_20usage_20patterns_455',['Recommended usage patterns',['../usage_patterns.html',1,'']]] ]; diff --git a/docs/html/search/pages_8.js b/docs/html/search/pages_8.js index bf7abe1..93ad4e8 100644 --- a/docs/html/search/pages_8.js +++ b/docs/html/search/pages_8.js @@ -1,5 +1,5 @@ var searchData= [ - ['statistics_452',['Statistics',['../statistics.html',1,'']]], - ['staying_20within_20budget_453',['Staying within budget',['../staying_within_budget.html',1,'']]] + ['statistics_456',['Statistics',['../statistics.html',1,'']]], + ['staying_20within_20budget_457',['Staying within budget',['../staying_within_budget.html',1,'']]] ]; diff --git a/docs/html/search/pages_9.js b/docs/html/search/pages_9.js index 46a3b63..9eeece3 100644 --- a/docs/html/search/pages_9.js +++ b/docs/html/search/pages_9.js @@ -1,5 +1,5 @@ var searchData= [ - ['vulkan_20memory_20allocator_454',['Vulkan Memory Allocator',['../index.html',1,'']]], - ['vk_5fkhr_5fdedicated_5fallocation_455',['VK_KHR_dedicated_allocation',['../vk_khr_dedicated_allocation.html',1,'']]] + ['vulkan_20memory_20allocator_458',['Vulkan Memory Allocator',['../index.html',1,'']]], + ['vk_5fkhr_5fdedicated_5fallocation_459',['VK_KHR_dedicated_allocation',['../vk_khr_dedicated_allocation.html',1,'']]] ]; diff --git a/docs/html/search/typedefs_0.js b/docs/html/search/typedefs_0.js index 7366a98..7b21d9a 100644 --- a/docs/html/search/typedefs_0.js +++ b/docs/html/search/typedefs_0.js @@ -1,5 +1,5 @@ var searchData= [ - ['pfn_5fvmaallocatedevicememoryfunction_362',['PFN_vmaAllocateDeviceMemoryFunction',['../vk__mem__alloc_8h.html#ab6a6477cda1ce775b30bde96d766203b',1,'vk_mem_alloc.h']]], - ['pfn_5fvmafreedevicememoryfunction_363',['PFN_vmaFreeDeviceMemoryFunction',['../vk__mem__alloc_8h.html#aef2545dc2e9dd4f29ab9ba6ac6fe2f49',1,'vk_mem_alloc.h']]] + ['pfn_5fvmaallocatedevicememoryfunction_365',['PFN_vmaAllocateDeviceMemoryFunction',['../vk__mem__alloc_8h.html#ab6a6477cda1ce775b30bde96d766203b',1,'vk_mem_alloc.h']]], + ['pfn_5fvmafreedevicememoryfunction_366',['PFN_vmaFreeDeviceMemoryFunction',['../vk__mem__alloc_8h.html#aef2545dc2e9dd4f29ab9ba6ac6fe2f49',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/typedefs_1.js b/docs/html/search/typedefs_1.js index a523948..7aad6a9 100644 --- a/docs/html/search/typedefs_1.js +++ b/docs/html/search/typedefs_1.js @@ -1,28 +1,28 @@ var searchData= [ - ['vmaallocationcreateflagbits_364',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#abf6bf6748c7a9fe7ce5b7835c0f56af4',1,'vk_mem_alloc.h']]], - ['vmaallocationcreateflags_365',['VmaAllocationCreateFlags',['../vk__mem__alloc_8h.html#a5225e5e11f8376f6a31a1791f3d6e817',1,'vk_mem_alloc.h']]], - ['vmaallocationcreateinfo_366',['VmaAllocationCreateInfo',['../vk__mem__alloc_8h.html#a86c44f9950b40d50088ed93a17870a7a',1,'vk_mem_alloc.h']]], - ['vmaallocationinfo_367',['VmaAllocationInfo',['../vk__mem__alloc_8h.html#a795e6ff02a21d5486c0565f403dd9255',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateflagbits_368',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4ddf381b6ce795bdfbc6c614640b9915',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateflags_369',['VmaAllocatorCreateFlags',['../vk__mem__alloc_8h.html#acfe6863e160722c2c1bbcf7573fddc4d',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateinfo_370',['VmaAllocatorCreateInfo',['../vk__mem__alloc_8h.html#ae0f6d1d733dded220d28134da46b4283',1,'vk_mem_alloc.h']]], - ['vmabudget_371',['VmaBudget',['../vk__mem__alloc_8h.html#ab79b48b6d25aada0de91a913896e1c38',1,'vk_mem_alloc.h']]], - ['vmadefragmentationflagbits_372',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a96df0eddab2e1735782fe4e7cd05ea7f',1,'vk_mem_alloc.h']]], - ['vmadefragmentationflags_373',['VmaDefragmentationFlags',['../vk__mem__alloc_8h.html#a88a77cef37e5d3c4fc9eb328885d048d',1,'vk_mem_alloc.h']]], - ['vmadefragmentationinfo_374',['VmaDefragmentationInfo',['../vk__mem__alloc_8h.html#ae67f8573a0cf20f16f0a1eecbca566a0',1,'vk_mem_alloc.h']]], - ['vmadefragmentationinfo2_375',['VmaDefragmentationInfo2',['../vk__mem__alloc_8h.html#abac0e85abaa6ea1ffd63bde29c5c3a29',1,'vk_mem_alloc.h']]], - ['vmadefragmentationstats_376',['VmaDefragmentationStats',['../vk__mem__alloc_8h.html#ab0f9b06441c840fee560de4a2967f8c9',1,'vk_mem_alloc.h']]], - ['vmadevicememorycallbacks_377',['VmaDeviceMemoryCallbacks',['../vk__mem__alloc_8h.html#a5e2eb68d727cfd4df25702b027b7aa31',1,'vk_mem_alloc.h']]], - ['vmamemoryusage_378',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#ad63b2113c0bfdbeade1cb498f5a8580d',1,'vk_mem_alloc.h']]], - ['vmapoolcreateflagbits_379',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a8f93195158e0e2ac80ca352064e71c1f',1,'vk_mem_alloc.h']]], - ['vmapoolcreateflags_380',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], - ['vmapoolcreateinfo_381',['VmaPoolCreateInfo',['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'vk_mem_alloc.h']]], - ['vmapoolstats_382',['VmaPoolStats',['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'vk_mem_alloc.h']]], - ['vmarecordflagbits_383',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'vk_mem_alloc.h']]], - ['vmarecordflags_384',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], - ['vmarecordsettings_385',['VmaRecordSettings',['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'vk_mem_alloc.h']]], - ['vmastatinfo_386',['VmaStatInfo',['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'vk_mem_alloc.h']]], - ['vmastats_387',['VmaStats',['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'vk_mem_alloc.h']]], - ['vmavulkanfunctions_388',['VmaVulkanFunctions',['../vk__mem__alloc_8h.html#a97064a1a271b0061ebfc3a079862d0c5',1,'vk_mem_alloc.h']]] + ['vmaallocationcreateflagbits_367',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#abf6bf6748c7a9fe7ce5b7835c0f56af4',1,'vk_mem_alloc.h']]], + ['vmaallocationcreateflags_368',['VmaAllocationCreateFlags',['../vk__mem__alloc_8h.html#a5225e5e11f8376f6a31a1791f3d6e817',1,'vk_mem_alloc.h']]], + ['vmaallocationcreateinfo_369',['VmaAllocationCreateInfo',['../vk__mem__alloc_8h.html#a86c44f9950b40d50088ed93a17870a7a',1,'vk_mem_alloc.h']]], + ['vmaallocationinfo_370',['VmaAllocationInfo',['../vk__mem__alloc_8h.html#a795e6ff02a21d5486c0565f403dd9255',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateflagbits_371',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4ddf381b6ce795bdfbc6c614640b9915',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateflags_372',['VmaAllocatorCreateFlags',['../vk__mem__alloc_8h.html#acfe6863e160722c2c1bbcf7573fddc4d',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateinfo_373',['VmaAllocatorCreateInfo',['../vk__mem__alloc_8h.html#ae0f6d1d733dded220d28134da46b4283',1,'vk_mem_alloc.h']]], + ['vmabudget_374',['VmaBudget',['../vk__mem__alloc_8h.html#ab79b48b6d25aada0de91a913896e1c38',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflagbits_375',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a96df0eddab2e1735782fe4e7cd05ea7f',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflags_376',['VmaDefragmentationFlags',['../vk__mem__alloc_8h.html#a88a77cef37e5d3c4fc9eb328885d048d',1,'vk_mem_alloc.h']]], + ['vmadefragmentationinfo_377',['VmaDefragmentationInfo',['../vk__mem__alloc_8h.html#ae67f8573a0cf20f16f0a1eecbca566a0',1,'vk_mem_alloc.h']]], + ['vmadefragmentationinfo2_378',['VmaDefragmentationInfo2',['../vk__mem__alloc_8h.html#abac0e85abaa6ea1ffd63bde29c5c3a29',1,'vk_mem_alloc.h']]], + ['vmadefragmentationstats_379',['VmaDefragmentationStats',['../vk__mem__alloc_8h.html#ab0f9b06441c840fee560de4a2967f8c9',1,'vk_mem_alloc.h']]], + ['vmadevicememorycallbacks_380',['VmaDeviceMemoryCallbacks',['../vk__mem__alloc_8h.html#a5e2eb68d727cfd4df25702b027b7aa31',1,'vk_mem_alloc.h']]], + ['vmamemoryusage_381',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#ad63b2113c0bfdbeade1cb498f5a8580d',1,'vk_mem_alloc.h']]], + ['vmapoolcreateflagbits_382',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a8f93195158e0e2ac80ca352064e71c1f',1,'vk_mem_alloc.h']]], + ['vmapoolcreateflags_383',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], + ['vmapoolcreateinfo_384',['VmaPoolCreateInfo',['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'vk_mem_alloc.h']]], + ['vmapoolstats_385',['VmaPoolStats',['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'vk_mem_alloc.h']]], + ['vmarecordflagbits_386',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'vk_mem_alloc.h']]], + ['vmarecordflags_387',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], + ['vmarecordsettings_388',['VmaRecordSettings',['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'vk_mem_alloc.h']]], + ['vmastatinfo_389',['VmaStatInfo',['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'vk_mem_alloc.h']]], + ['vmastats_390',['VmaStats',['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'vk_mem_alloc.h']]], + ['vmavulkanfunctions_391',['VmaVulkanFunctions',['../vk__mem__alloc_8h.html#a97064a1a271b0061ebfc3a079862d0c5',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/variables_0.js b/docs/html/search/variables_0.js index 71c840b..e789983 100644 --- a/docs/html/search/variables_0.js +++ b/docs/html/search/variables_0.js @@ -1,9 +1,9 @@ var searchData= [ - ['allocationbytes_284',['allocationBytes',['../struct_vma_budget.html#a7e2a6583ebd63e194951c542563804d8',1,'VmaBudget']]], - ['allocationcount_285',['allocationCount',['../struct_vma_stat_info.html#a537741e4d5cdddc1c0ab95ec650afaff',1,'VmaStatInfo::allocationCount()'],['../struct_vma_pool_stats.html#ad1924eb54fffa45e9e0e65670c8fe5eb',1,'VmaPoolStats::allocationCount()'],['../struct_vma_defragmentation_info2.html#a3cf86ab32c1da779b4923d301a3056ba',1,'VmaDefragmentationInfo2::allocationCount()']]], - ['allocationsizeavg_286',['allocationSizeAvg',['../struct_vma_stat_info.html#a1081a039964e566c672e7a2347f9e599',1,'VmaStatInfo']]], - ['allocationsizemax_287',['allocationSizeMax',['../struct_vma_stat_info.html#a17e9733a5ecd76287d4db6e66f71f50c',1,'VmaStatInfo']]], - ['allocationsizemin_288',['allocationSizeMin',['../struct_vma_stat_info.html#ade8b40bd3139c04aabd2fc538a356fea',1,'VmaStatInfo']]], - ['allocationsmoved_289',['allocationsMoved',['../struct_vma_defragmentation_stats.html#aefeabf130022008eadd75999478af3f9',1,'VmaDefragmentationStats']]] + ['allocationbytes_286',['allocationBytes',['../struct_vma_budget.html#a7e2a6583ebd63e194951c542563804d8',1,'VmaBudget']]], + ['allocationcount_287',['allocationCount',['../struct_vma_stat_info.html#a537741e4d5cdddc1c0ab95ec650afaff',1,'VmaStatInfo::allocationCount()'],['../struct_vma_pool_stats.html#ad1924eb54fffa45e9e0e65670c8fe5eb',1,'VmaPoolStats::allocationCount()'],['../struct_vma_defragmentation_info2.html#a3cf86ab32c1da779b4923d301a3056ba',1,'VmaDefragmentationInfo2::allocationCount()']]], + ['allocationsizeavg_288',['allocationSizeAvg',['../struct_vma_stat_info.html#a1081a039964e566c672e7a2347f9e599',1,'VmaStatInfo']]], + ['allocationsizemax_289',['allocationSizeMax',['../struct_vma_stat_info.html#a17e9733a5ecd76287d4db6e66f71f50c',1,'VmaStatInfo']]], + ['allocationsizemin_290',['allocationSizeMin',['../struct_vma_stat_info.html#ade8b40bd3139c04aabd2fc538a356fea',1,'VmaStatInfo']]], + ['allocationsmoved_291',['allocationsMoved',['../struct_vma_defragmentation_stats.html#aefeabf130022008eadd75999478af3f9',1,'VmaDefragmentationStats']]] ]; diff --git a/docs/html/search/variables_1.js b/docs/html/search/variables_1.js index e64dc7b..9b41635 100644 --- a/docs/html/search/variables_1.js +++ b/docs/html/search/variables_1.js @@ -1,9 +1,9 @@ var searchData= [ - ['blockbytes_290',['blockBytes',['../struct_vma_budget.html#a58b492901baab685f466199124e514a0',1,'VmaBudget']]], - ['blockcount_291',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo::blockCount()'],['../struct_vma_pool_stats.html#aa0b5cb45cef6f18571cefb03b9a230e7',1,'VmaPoolStats::blockCount()']]], - ['blocksize_292',['blockSize',['../struct_vma_pool_create_info.html#aa4265160536cdb9be821b7686c16c676',1,'VmaPoolCreateInfo']]], - ['budget_293',['budget',['../struct_vma_budget.html#ab82e1d1754c2d210d0bdf90220bc6cdd',1,'VmaBudget']]], - ['bytesfreed_294',['bytesFreed',['../struct_vma_defragmentation_stats.html#ab0cb9ac0dbc106c77e384ea676422f28',1,'VmaDefragmentationStats']]], - ['bytesmoved_295',['bytesMoved',['../struct_vma_defragmentation_stats.html#a36f9d5df2a10ba2a36b16e126d60572d',1,'VmaDefragmentationStats']]] + ['blockbytes_292',['blockBytes',['../struct_vma_budget.html#a58b492901baab685f466199124e514a0',1,'VmaBudget']]], + ['blockcount_293',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo::blockCount()'],['../struct_vma_pool_stats.html#aa0b5cb45cef6f18571cefb03b9a230e7',1,'VmaPoolStats::blockCount()']]], + ['blocksize_294',['blockSize',['../struct_vma_pool_create_info.html#aa4265160536cdb9be821b7686c16c676',1,'VmaPoolCreateInfo']]], + ['budget_295',['budget',['../struct_vma_budget.html#ab82e1d1754c2d210d0bdf90220bc6cdd',1,'VmaBudget']]], + ['bytesfreed_296',['bytesFreed',['../struct_vma_defragmentation_stats.html#ab0cb9ac0dbc106c77e384ea676422f28',1,'VmaDefragmentationStats']]], + ['bytesmoved_297',['bytesMoved',['../struct_vma_defragmentation_stats.html#a36f9d5df2a10ba2a36b16e126d60572d',1,'VmaDefragmentationStats']]] ]; diff --git a/docs/html/search/variables_2.js b/docs/html/search/variables_2.js index a88a86f..08a5c66 100644 --- a/docs/html/search/variables_2.js +++ b/docs/html/search/variables_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['commandbuffer_296',['commandBuffer',['../struct_vma_defragmentation_info2.html#a7f71f39590c5316771493d2333f9c1bd',1,'VmaDefragmentationInfo2']]] + ['commandbuffer_298',['commandBuffer',['../struct_vma_defragmentation_info2.html#a7f71f39590c5316771493d2333f9c1bd',1,'VmaDefragmentationInfo2']]] ]; diff --git a/docs/html/search/variables_3.js b/docs/html/search/variables_3.js index 0d56413..73f8cb8 100644 --- a/docs/html/search/variables_3.js +++ b/docs/html/search/variables_3.js @@ -1,6 +1,6 @@ var searchData= [ - ['device_297',['device',['../struct_vma_allocator_create_info.html#ad924ddd77b04039c88d0c09b0ffcd500',1,'VmaAllocatorCreateInfo']]], - ['devicememory_298',['deviceMemory',['../struct_vma_allocation_info.html#ae0bfb7dfdf79a76ffefc9a94677a2f67',1,'VmaAllocationInfo']]], - ['devicememoryblocksfreed_299',['deviceMemoryBlocksFreed',['../struct_vma_defragmentation_stats.html#a0113f1877904a5d1ee8f409216ff276b',1,'VmaDefragmentationStats']]] + ['device_299',['device',['../struct_vma_allocator_create_info.html#ad924ddd77b04039c88d0c09b0ffcd500',1,'VmaAllocatorCreateInfo']]], + ['devicememory_300',['deviceMemory',['../struct_vma_allocation_info.html#ae0bfb7dfdf79a76ffefc9a94677a2f67',1,'VmaAllocationInfo']]], + ['devicememoryblocksfreed_301',['deviceMemoryBlocksFreed',['../struct_vma_defragmentation_stats.html#a0113f1877904a5d1ee8f409216ff276b',1,'VmaDefragmentationStats']]] ]; diff --git a/docs/html/search/variables_4.js b/docs/html/search/variables_4.js index 2204e6c..befdc65 100644 --- a/docs/html/search/variables_4.js +++ b/docs/html/search/variables_4.js @@ -1,5 +1,5 @@ var searchData= [ - ['flags_300',['flags',['../struct_vma_record_settings.html#ad8fdcc92119ae7a8c08c1a564c01d63a',1,'VmaRecordSettings::flags()'],['../struct_vma_allocator_create_info.html#a392ea2ecbaff93f91a7c49f735ad4346',1,'VmaAllocatorCreateInfo::flags()'],['../struct_vma_allocation_create_info.html#add09658ac14fe290ace25470ddd6d41b',1,'VmaAllocationCreateInfo::flags()'],['../struct_vma_pool_create_info.html#a8405139f63d078340ae74513a59f5446',1,'VmaPoolCreateInfo::flags()'],['../struct_vma_defragmentation_info2.html#a53e844ee5633e229cf6daf14b2d9fff9',1,'VmaDefragmentationInfo2::flags()']]], - ['frameinusecount_301',['frameInUseCount',['../struct_vma_allocator_create_info.html#a21ea188dd212b8171cb9ecbed4a2a3a7',1,'VmaAllocatorCreateInfo::frameInUseCount()'],['../struct_vma_pool_create_info.html#a9437e43ffbb644dbbf7fc4e50cfad6aa',1,'VmaPoolCreateInfo::frameInUseCount()']]] + ['flags_302',['flags',['../struct_vma_record_settings.html#ad8fdcc92119ae7a8c08c1a564c01d63a',1,'VmaRecordSettings::flags()'],['../struct_vma_allocator_create_info.html#a392ea2ecbaff93f91a7c49f735ad4346',1,'VmaAllocatorCreateInfo::flags()'],['../struct_vma_allocation_create_info.html#add09658ac14fe290ace25470ddd6d41b',1,'VmaAllocationCreateInfo::flags()'],['../struct_vma_pool_create_info.html#a8405139f63d078340ae74513a59f5446',1,'VmaPoolCreateInfo::flags()'],['../struct_vma_defragmentation_info2.html#a53e844ee5633e229cf6daf14b2d9fff9',1,'VmaDefragmentationInfo2::flags()']]], + ['frameinusecount_303',['frameInUseCount',['../struct_vma_allocator_create_info.html#a21ea188dd212b8171cb9ecbed4a2a3a7',1,'VmaAllocatorCreateInfo::frameInUseCount()'],['../struct_vma_pool_create_info.html#a9437e43ffbb644dbbf7fc4e50cfad6aa',1,'VmaPoolCreateInfo::frameInUseCount()']]] ]; diff --git a/docs/html/search/variables_5.js b/docs/html/search/variables_5.js index 671e1d9..d5e147d 100644 --- a/docs/html/search/variables_5.js +++ b/docs/html/search/variables_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['instance_302',['instance',['../struct_vma_allocator_create_info.html#a70dd42e29b1df1d1b9b61532ae0b370b',1,'VmaAllocatorCreateInfo']]] + ['instance_304',['instance',['../struct_vma_allocator_create_info.html#a70dd42e29b1df1d1b9b61532ae0b370b',1,'VmaAllocatorCreateInfo']]] ]; diff --git a/docs/html/search/variables_6.js b/docs/html/search/variables_6.js index 1a0221e..6985d99 100644 --- a/docs/html/search/variables_6.js +++ b/docs/html/search/variables_6.js @@ -1,15 +1,15 @@ var searchData= [ - ['maxallocationstomove_303',['maxAllocationsToMove',['../struct_vma_defragmentation_info.html#aa7c7304e13c71f604c907196c4e28fbc',1,'VmaDefragmentationInfo']]], - ['maxblockcount_304',['maxBlockCount',['../struct_vma_pool_create_info.html#ae41142f2834fcdc82baa4883c187b75c',1,'VmaPoolCreateInfo']]], - ['maxbytestomove_305',['maxBytesToMove',['../struct_vma_defragmentation_info.html#acb311c940a777270e67e1b81c5ab6a1d',1,'VmaDefragmentationInfo']]], - ['maxcpuallocationstomove_306',['maxCpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a94c2c7223d52878445a8cccce396b671',1,'VmaDefragmentationInfo2']]], - ['maxcpubytestomove_307',['maxCpuBytesToMove',['../struct_vma_defragmentation_info2.html#af78e1ea40c22d85137b65f6b384a4d0a',1,'VmaDefragmentationInfo2']]], - ['maxgpuallocationstomove_308',['maxGpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a40d53d33e71ba0b66f844ed63c05a3f6',1,'VmaDefragmentationInfo2']]], - ['maxgpubytestomove_309',['maxGpuBytesToMove',['../struct_vma_defragmentation_info2.html#a4ddbc898d0afe1518f863a3763628f08',1,'VmaDefragmentationInfo2']]], - ['memoryheap_310',['memoryHeap',['../struct_vma_stats.html#a0e6611508c29a187f0fd14ff1a0329c0',1,'VmaStats']]], - ['memorytype_311',['memoryType',['../struct_vma_stats.html#a13e3caf754be79352c42408756309331',1,'VmaStats::memoryType()'],['../struct_vma_allocation_info.html#a7f6b0aa58c135e488e6b40a388dad9d5',1,'VmaAllocationInfo::memoryType()']]], - ['memorytypebits_312',['memoryTypeBits',['../struct_vma_allocation_create_info.html#a3bf940c0271d85d6ba32a4d820075055',1,'VmaAllocationCreateInfo']]], - ['memorytypeindex_313',['memoryTypeIndex',['../struct_vma_pool_create_info.html#a596fa76b685d3f1f688f84a709a5b319',1,'VmaPoolCreateInfo']]], - ['minblockcount_314',['minBlockCount',['../struct_vma_pool_create_info.html#ad8006fb803185c0a699d30f3e9a865ae',1,'VmaPoolCreateInfo']]] + ['maxallocationstomove_305',['maxAllocationsToMove',['../struct_vma_defragmentation_info.html#aa7c7304e13c71f604c907196c4e28fbc',1,'VmaDefragmentationInfo']]], + ['maxblockcount_306',['maxBlockCount',['../struct_vma_pool_create_info.html#ae41142f2834fcdc82baa4883c187b75c',1,'VmaPoolCreateInfo']]], + ['maxbytestomove_307',['maxBytesToMove',['../struct_vma_defragmentation_info.html#acb311c940a777270e67e1b81c5ab6a1d',1,'VmaDefragmentationInfo']]], + ['maxcpuallocationstomove_308',['maxCpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a94c2c7223d52878445a8cccce396b671',1,'VmaDefragmentationInfo2']]], + ['maxcpubytestomove_309',['maxCpuBytesToMove',['../struct_vma_defragmentation_info2.html#af78e1ea40c22d85137b65f6b384a4d0a',1,'VmaDefragmentationInfo2']]], + ['maxgpuallocationstomove_310',['maxGpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a40d53d33e71ba0b66f844ed63c05a3f6',1,'VmaDefragmentationInfo2']]], + ['maxgpubytestomove_311',['maxGpuBytesToMove',['../struct_vma_defragmentation_info2.html#a4ddbc898d0afe1518f863a3763628f08',1,'VmaDefragmentationInfo2']]], + ['memoryheap_312',['memoryHeap',['../struct_vma_stats.html#a0e6611508c29a187f0fd14ff1a0329c0',1,'VmaStats']]], + ['memorytype_313',['memoryType',['../struct_vma_stats.html#a13e3caf754be79352c42408756309331',1,'VmaStats::memoryType()'],['../struct_vma_allocation_info.html#a7f6b0aa58c135e488e6b40a388dad9d5',1,'VmaAllocationInfo::memoryType()']]], + ['memorytypebits_314',['memoryTypeBits',['../struct_vma_allocation_create_info.html#a3bf940c0271d85d6ba32a4d820075055',1,'VmaAllocationCreateInfo']]], + ['memorytypeindex_315',['memoryTypeIndex',['../struct_vma_pool_create_info.html#a596fa76b685d3f1f688f84a709a5b319',1,'VmaPoolCreateInfo']]], + ['minblockcount_316',['minBlockCount',['../struct_vma_pool_create_info.html#ad8006fb803185c0a699d30f3e9a865ae',1,'VmaPoolCreateInfo']]] ]; diff --git a/docs/html/search/variables_7.js b/docs/html/search/variables_7.js index 9a10bf5..13493b2 100644 --- a/docs/html/search/variables_7.js +++ b/docs/html/search/variables_7.js @@ -1,4 +1,4 @@ var searchData= [ - ['offset_315',['offset',['../struct_vma_allocation_info.html#a4a3c732388dbdc7a23f9365b00825268',1,'VmaAllocationInfo']]] + ['offset_317',['offset',['../struct_vma_allocation_info.html#a4a3c732388dbdc7a23f9365b00825268',1,'VmaAllocationInfo']]] ]; diff --git a/docs/html/search/variables_8.js b/docs/html/search/variables_8.js index c695c84..5aa5010 100644 --- a/docs/html/search/variables_8.js +++ b/docs/html/search/variables_8.js @@ -1,21 +1,21 @@ var searchData= [ - ['pallocationcallbacks_316',['pAllocationCallbacks',['../struct_vma_allocator_create_info.html#a6e409087e3be55400d0e4ccbe43c608d',1,'VmaAllocatorCreateInfo']]], - ['pallocations_317',['pAllocations',['../struct_vma_defragmentation_info2.html#a8943f8d65969ce8e2189a1cdf3205e96',1,'VmaDefragmentationInfo2']]], - ['pallocationschanged_318',['pAllocationsChanged',['../struct_vma_defragmentation_info2.html#a76d51a644dc7f5405d0cdd0025ecd0cc',1,'VmaDefragmentationInfo2']]], - ['pdevicememorycallbacks_319',['pDeviceMemoryCallbacks',['../struct_vma_allocator_create_info.html#af1380969b5e1ea4c3184a877892d260e',1,'VmaAllocatorCreateInfo']]], - ['pfilepath_320',['pFilePath',['../struct_vma_record_settings.html#a6cb1fdbf6bcb610b68f2010dd629e89d',1,'VmaRecordSettings']]], - ['pfnallocate_321',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], - ['pfnfree_322',['pfnFree',['../struct_vma_device_memory_callbacks.html#abe8a3328bbc916f6f712fdb6b299444c',1,'VmaDeviceMemoryCallbacks']]], - ['pheapsizelimit_323',['pHeapSizeLimit',['../struct_vma_allocator_create_info.html#a31c192aa6cbffa33279f6d9f0c47c44b',1,'VmaAllocatorCreateInfo']]], - ['physicaldevice_324',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], - ['pmappeddata_325',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], - ['pool_326',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], - ['poolcount_327',['poolCount',['../struct_vma_defragmentation_info2.html#a7e70aa2a1081d849dcc7829b19d3ec9d',1,'VmaDefragmentationInfo2']]], - ['ppools_328',['pPools',['../struct_vma_defragmentation_info2.html#a0b3effd57f3fcdeb2ed62210b4ef20e1',1,'VmaDefragmentationInfo2']]], - ['precordsettings_329',['pRecordSettings',['../struct_vma_allocator_create_info.html#ace2aa4877b16a42b0b7673d4e26000ee',1,'VmaAllocatorCreateInfo']]], - ['preferredflags_330',['preferredFlags',['../struct_vma_allocation_create_info.html#a7fe8d81a1ad10b2a2faacacee5b15d6d',1,'VmaAllocationCreateInfo']]], - ['preferredlargeheapblocksize_331',['preferredLargeHeapBlockSize',['../struct_vma_allocator_create_info.html#a8e4714298e3121cdd8b214a1ae7a637a',1,'VmaAllocatorCreateInfo']]], - ['puserdata_332',['pUserData',['../struct_vma_allocation_create_info.html#a8259e85c272683434f4abb4ddddffe19',1,'VmaAllocationCreateInfo::pUserData()'],['../struct_vma_allocation_info.html#adc507656149c04de7ed95d0042ba2a13',1,'VmaAllocationInfo::pUserData()']]], - ['pvulkanfunctions_333',['pVulkanFunctions',['../struct_vma_allocator_create_info.html#a3dc197be3227da7338b1643f70db36bd',1,'VmaAllocatorCreateInfo']]] + ['pallocationcallbacks_318',['pAllocationCallbacks',['../struct_vma_allocator_create_info.html#a6e409087e3be55400d0e4ccbe43c608d',1,'VmaAllocatorCreateInfo']]], + ['pallocations_319',['pAllocations',['../struct_vma_defragmentation_info2.html#a8943f8d65969ce8e2189a1cdf3205e96',1,'VmaDefragmentationInfo2']]], + ['pallocationschanged_320',['pAllocationsChanged',['../struct_vma_defragmentation_info2.html#a76d51a644dc7f5405d0cdd0025ecd0cc',1,'VmaDefragmentationInfo2']]], + ['pdevicememorycallbacks_321',['pDeviceMemoryCallbacks',['../struct_vma_allocator_create_info.html#af1380969b5e1ea4c3184a877892d260e',1,'VmaAllocatorCreateInfo']]], + ['pfilepath_322',['pFilePath',['../struct_vma_record_settings.html#a6cb1fdbf6bcb610b68f2010dd629e89d',1,'VmaRecordSettings']]], + ['pfnallocate_323',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], + ['pfnfree_324',['pfnFree',['../struct_vma_device_memory_callbacks.html#abe8a3328bbc916f6f712fdb6b299444c',1,'VmaDeviceMemoryCallbacks']]], + ['pheapsizelimit_325',['pHeapSizeLimit',['../struct_vma_allocator_create_info.html#a31c192aa6cbffa33279f6d9f0c47c44b',1,'VmaAllocatorCreateInfo']]], + ['physicaldevice_326',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], + ['pmappeddata_327',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], + ['pool_328',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], + ['poolcount_329',['poolCount',['../struct_vma_defragmentation_info2.html#a7e70aa2a1081d849dcc7829b19d3ec9d',1,'VmaDefragmentationInfo2']]], + ['ppools_330',['pPools',['../struct_vma_defragmentation_info2.html#a0b3effd57f3fcdeb2ed62210b4ef20e1',1,'VmaDefragmentationInfo2']]], + ['precordsettings_331',['pRecordSettings',['../struct_vma_allocator_create_info.html#ace2aa4877b16a42b0b7673d4e26000ee',1,'VmaAllocatorCreateInfo']]], + ['preferredflags_332',['preferredFlags',['../struct_vma_allocation_create_info.html#a7fe8d81a1ad10b2a2faacacee5b15d6d',1,'VmaAllocationCreateInfo']]], + ['preferredlargeheapblocksize_333',['preferredLargeHeapBlockSize',['../struct_vma_allocator_create_info.html#a8e4714298e3121cdd8b214a1ae7a637a',1,'VmaAllocatorCreateInfo']]], + ['puserdata_334',['pUserData',['../struct_vma_allocation_create_info.html#a8259e85c272683434f4abb4ddddffe19',1,'VmaAllocationCreateInfo::pUserData()'],['../struct_vma_allocation_info.html#adc507656149c04de7ed95d0042ba2a13',1,'VmaAllocationInfo::pUserData()']]], + ['pvulkanfunctions_335',['pVulkanFunctions',['../struct_vma_allocator_create_info.html#a3dc197be3227da7338b1643f70db36bd',1,'VmaAllocatorCreateInfo']]] ]; diff --git a/docs/html/search/variables_9.js b/docs/html/search/variables_9.js index 3f2cadc..cbb1d9d 100644 --- a/docs/html/search/variables_9.js +++ b/docs/html/search/variables_9.js @@ -1,4 +1,4 @@ var searchData= [ - ['requiredflags_334',['requiredFlags',['../struct_vma_allocation_create_info.html#a9166390303ff42d783305bc31c2b6b90',1,'VmaAllocationCreateInfo']]] + ['requiredflags_336',['requiredFlags',['../struct_vma_allocation_create_info.html#a9166390303ff42d783305bc31c2b6b90',1,'VmaAllocationCreateInfo']]] ]; diff --git a/docs/html/search/variables_a.js b/docs/html/search/variables_a.js index 7eee9cc..cb9c51a 100644 --- a/docs/html/search/variables_a.js +++ b/docs/html/search/variables_a.js @@ -1,4 +1,4 @@ var searchData= [ - ['size_335',['size',['../struct_vma_pool_stats.html#a326807b2de2b0931cee4ed9a5f2e420c',1,'VmaPoolStats::size()'],['../struct_vma_allocation_info.html#aac76d113a6a5ccbb09fea00fb25fd18f',1,'VmaAllocationInfo::size()']]] + ['size_337',['size',['../struct_vma_pool_stats.html#a326807b2de2b0931cee4ed9a5f2e420c',1,'VmaPoolStats::size()'],['../struct_vma_allocation_info.html#aac76d113a6a5ccbb09fea00fb25fd18f',1,'VmaAllocationInfo::size()']]] ]; diff --git a/docs/html/search/variables_b.js b/docs/html/search/variables_b.js index 589772a..1a0b424 100644 --- a/docs/html/search/variables_b.js +++ b/docs/html/search/variables_b.js @@ -1,4 +1,4 @@ var searchData= [ - ['total_336',['total',['../struct_vma_stats.html#a2e8f5b3353f2fefef3c27f29e245a1f9',1,'VmaStats']]] + ['total_338',['total',['../struct_vma_stats.html#a2e8f5b3353f2fefef3c27f29e245a1f9',1,'VmaStats']]] ]; diff --git a/docs/html/search/variables_c.js b/docs/html/search/variables_c.js index b931651..1a98383 100644 --- a/docs/html/search/variables_c.js +++ b/docs/html/search/variables_c.js @@ -1,11 +1,11 @@ var searchData= [ - ['unusedbytes_337',['unusedBytes',['../struct_vma_stat_info.html#a1859d290aca2cd582d8dc25922092669',1,'VmaStatInfo']]], - ['unusedrangecount_338',['unusedRangeCount',['../struct_vma_stat_info.html#ae06129c771bfebfd6468a7f4276502a9',1,'VmaStatInfo::unusedRangeCount()'],['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()']]], - ['unusedrangesizeavg_339',['unusedRangeSizeAvg',['../struct_vma_stat_info.html#a2f9b3452af90c9768a30b7fb6ae194fc',1,'VmaStatInfo']]], - ['unusedrangesizemax_340',['unusedRangeSizeMax',['../struct_vma_stat_info.html#a5ba1a2476c4d39b10f7e2f7ebbb72ac4',1,'VmaStatInfo::unusedRangeSizeMax()'],['../struct_vma_pool_stats.html#ab4c8f52dd42ab01998f60f0b6acc722b',1,'VmaPoolStats::unusedRangeSizeMax()']]], - ['unusedrangesizemin_341',['unusedRangeSizeMin',['../struct_vma_stat_info.html#aedeba931324f16589cd2416c0d2dd0d4',1,'VmaStatInfo']]], - ['unusedsize_342',['unusedSize',['../struct_vma_pool_stats.html#ad7c54874724fce7b06aba526202d82a8',1,'VmaPoolStats']]], - ['usage_343',['usage',['../struct_vma_budget.html#a84dd1ecca8b0110259eb206dbadb11f6',1,'VmaBudget::usage()'],['../struct_vma_allocation_create_info.html#accb8b06b1f677d858cb9af20705fa910',1,'VmaAllocationCreateInfo::usage()']]], - ['usedbytes_344',['usedBytes',['../struct_vma_stat_info.html#ab0c6c73837e5a70c749fbd4f6064895a',1,'VmaStatInfo']]] + ['unusedbytes_339',['unusedBytes',['../struct_vma_stat_info.html#a1859d290aca2cd582d8dc25922092669',1,'VmaStatInfo']]], + ['unusedrangecount_340',['unusedRangeCount',['../struct_vma_stat_info.html#ae06129c771bfebfd6468a7f4276502a9',1,'VmaStatInfo::unusedRangeCount()'],['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()']]], + ['unusedrangesizeavg_341',['unusedRangeSizeAvg',['../struct_vma_stat_info.html#a2f9b3452af90c9768a30b7fb6ae194fc',1,'VmaStatInfo']]], + ['unusedrangesizemax_342',['unusedRangeSizeMax',['../struct_vma_stat_info.html#a5ba1a2476c4d39b10f7e2f7ebbb72ac4',1,'VmaStatInfo::unusedRangeSizeMax()'],['../struct_vma_pool_stats.html#ab4c8f52dd42ab01998f60f0b6acc722b',1,'VmaPoolStats::unusedRangeSizeMax()']]], + ['unusedrangesizemin_343',['unusedRangeSizeMin',['../struct_vma_stat_info.html#aedeba931324f16589cd2416c0d2dd0d4',1,'VmaStatInfo']]], + ['unusedsize_344',['unusedSize',['../struct_vma_pool_stats.html#ad7c54874724fce7b06aba526202d82a8',1,'VmaPoolStats']]], + ['usage_345',['usage',['../struct_vma_budget.html#a84dd1ecca8b0110259eb206dbadb11f6',1,'VmaBudget::usage()'],['../struct_vma_allocation_create_info.html#accb8b06b1f677d858cb9af20705fa910',1,'VmaAllocationCreateInfo::usage()']]], + ['usedbytes_346',['usedBytes',['../struct_vma_stat_info.html#ab0c6c73837e5a70c749fbd4f6064895a',1,'VmaStatInfo']]] ]; diff --git a/docs/html/search/variables_d.js b/docs/html/search/variables_d.js index 2101d9f..ecaf14b 100644 --- a/docs/html/search/variables_d.js +++ b/docs/html/search/variables_d.js @@ -1,20 +1,21 @@ var searchData= [ - ['vkallocatememory_345',['vkAllocateMemory',['../struct_vma_vulkan_functions.html#a2943bf99dfd784a0e8f599d987e22e6c',1,'VmaVulkanFunctions']]], - ['vkbindbuffermemory_346',['vkBindBufferMemory',['../struct_vma_vulkan_functions.html#a94fc4f3a605d9880bb3c0ba2c2fc80b2',1,'VmaVulkanFunctions']]], - ['vkbindimagememory_347',['vkBindImageMemory',['../struct_vma_vulkan_functions.html#a1338d96a128a5ade648b8d934907c637',1,'VmaVulkanFunctions']]], - ['vkcmdcopybuffer_348',['vkCmdCopyBuffer',['../struct_vma_vulkan_functions.html#ae5c0db8c89a3b82593dc16aa6a49fa3a',1,'VmaVulkanFunctions']]], - ['vkcreatebuffer_349',['vkCreateBuffer',['../struct_vma_vulkan_functions.html#ae8084315a25006271a2edfc3a447519f',1,'VmaVulkanFunctions']]], - ['vkcreateimage_350',['vkCreateImage',['../struct_vma_vulkan_functions.html#a23ebe70be515b9b5010a1d691200e325',1,'VmaVulkanFunctions']]], - ['vkdestroybuffer_351',['vkDestroyBuffer',['../struct_vma_vulkan_functions.html#a7e054606faddb07f0e8556f3ed317d45',1,'VmaVulkanFunctions']]], - ['vkdestroyimage_352',['vkDestroyImage',['../struct_vma_vulkan_functions.html#a90b898227039b1dcb3520f6e91f09ffa',1,'VmaVulkanFunctions']]], - ['vkflushmappedmemoryranges_353',['vkFlushMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a33c322f4c4ad2810f8a9c97a277572f9',1,'VmaVulkanFunctions']]], - ['vkfreememory_354',['vkFreeMemory',['../struct_vma_vulkan_functions.html#a4c658701778564d62034255b5dda91b4',1,'VmaVulkanFunctions']]], - ['vkgetbuffermemoryrequirements_355',['vkGetBufferMemoryRequirements',['../struct_vma_vulkan_functions.html#a5b92901df89a4194b0d12f6071d4d143',1,'VmaVulkanFunctions']]], - ['vkgetimagememoryrequirements_356',['vkGetImageMemoryRequirements',['../struct_vma_vulkan_functions.html#a475f6f49f8debe4d10800592606d53f4',1,'VmaVulkanFunctions']]], - ['vkgetphysicaldevicememoryproperties_357',['vkGetPhysicalDeviceMemoryProperties',['../struct_vma_vulkan_functions.html#a60d25c33bba06bb8592e6875cbaa9830',1,'VmaVulkanFunctions']]], - ['vkgetphysicaldeviceproperties_358',['vkGetPhysicalDeviceProperties',['../struct_vma_vulkan_functions.html#a77b7a74082823e865dd6546623468f96',1,'VmaVulkanFunctions']]], - ['vkinvalidatemappedmemoryranges_359',['vkInvalidateMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a5c1093bc32386a8060c37c9f282078a1',1,'VmaVulkanFunctions']]], - ['vkmapmemory_360',['vkMapMemory',['../struct_vma_vulkan_functions.html#ab5c1f38dea3a2cf00dc9eb4f57218c49',1,'VmaVulkanFunctions']]], - ['vkunmapmemory_361',['vkUnmapMemory',['../struct_vma_vulkan_functions.html#acc798589736f0becb317fc2196c1d8b9',1,'VmaVulkanFunctions']]] + ['vkallocatememory_347',['vkAllocateMemory',['../struct_vma_vulkan_functions.html#a2943bf99dfd784a0e8f599d987e22e6c',1,'VmaVulkanFunctions']]], + ['vkbindbuffermemory_348',['vkBindBufferMemory',['../struct_vma_vulkan_functions.html#a94fc4f3a605d9880bb3c0ba2c2fc80b2',1,'VmaVulkanFunctions']]], + ['vkbindimagememory_349',['vkBindImageMemory',['../struct_vma_vulkan_functions.html#a1338d96a128a5ade648b8d934907c637',1,'VmaVulkanFunctions']]], + ['vkcmdcopybuffer_350',['vkCmdCopyBuffer',['../struct_vma_vulkan_functions.html#ae5c0db8c89a3b82593dc16aa6a49fa3a',1,'VmaVulkanFunctions']]], + ['vkcreatebuffer_351',['vkCreateBuffer',['../struct_vma_vulkan_functions.html#ae8084315a25006271a2edfc3a447519f',1,'VmaVulkanFunctions']]], + ['vkcreateimage_352',['vkCreateImage',['../struct_vma_vulkan_functions.html#a23ebe70be515b9b5010a1d691200e325',1,'VmaVulkanFunctions']]], + ['vkdestroybuffer_353',['vkDestroyBuffer',['../struct_vma_vulkan_functions.html#a7e054606faddb07f0e8556f3ed317d45',1,'VmaVulkanFunctions']]], + ['vkdestroyimage_354',['vkDestroyImage',['../struct_vma_vulkan_functions.html#a90b898227039b1dcb3520f6e91f09ffa',1,'VmaVulkanFunctions']]], + ['vkflushmappedmemoryranges_355',['vkFlushMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a33c322f4c4ad2810f8a9c97a277572f9',1,'VmaVulkanFunctions']]], + ['vkfreememory_356',['vkFreeMemory',['../struct_vma_vulkan_functions.html#a4c658701778564d62034255b5dda91b4',1,'VmaVulkanFunctions']]], + ['vkgetbuffermemoryrequirements_357',['vkGetBufferMemoryRequirements',['../struct_vma_vulkan_functions.html#a5b92901df89a4194b0d12f6071d4d143',1,'VmaVulkanFunctions']]], + ['vkgetimagememoryrequirements_358',['vkGetImageMemoryRequirements',['../struct_vma_vulkan_functions.html#a475f6f49f8debe4d10800592606d53f4',1,'VmaVulkanFunctions']]], + ['vkgetphysicaldevicememoryproperties_359',['vkGetPhysicalDeviceMemoryProperties',['../struct_vma_vulkan_functions.html#a60d25c33bba06bb8592e6875cbaa9830',1,'VmaVulkanFunctions']]], + ['vkgetphysicaldeviceproperties_360',['vkGetPhysicalDeviceProperties',['../struct_vma_vulkan_functions.html#a77b7a74082823e865dd6546623468f96',1,'VmaVulkanFunctions']]], + ['vkinvalidatemappedmemoryranges_361',['vkInvalidateMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a5c1093bc32386a8060c37c9f282078a1',1,'VmaVulkanFunctions']]], + ['vkmapmemory_362',['vkMapMemory',['../struct_vma_vulkan_functions.html#ab5c1f38dea3a2cf00dc9eb4f57218c49',1,'VmaVulkanFunctions']]], + ['vkunmapmemory_363',['vkUnmapMemory',['../struct_vma_vulkan_functions.html#acc798589736f0becb317fc2196c1d8b9',1,'VmaVulkanFunctions']]], + ['vulkanapiversion_364',['vulkanApiVersion',['../struct_vma_allocator_create_info.html#ae0ffc55139b54520a6bb704b29ffc285',1,'VmaAllocatorCreateInfo']]] ]; diff --git a/docs/html/struct_vma_allocator_create_info-members.html b/docs/html/struct_vma_allocator_create_info-members.html index ea055d3..cb1f1a0 100644 --- a/docs/html/struct_vma_allocator_create_info-members.html +++ b/docs/html/struct_vma_allocator_create_info-members.html @@ -79,6 +79,7 @@ $(function() { pRecordSettingsVmaAllocatorCreateInfo preferredLargeHeapBlockSizeVmaAllocatorCreateInfo pVulkanFunctionsVmaAllocatorCreateInfo + vulkanApiVersionVmaAllocatorCreateInfo
    diff --git a/docs/html/struct_vma_allocator_create_info.html b/docs/html/struct_vma_allocator_create_info.html index 76832fe..6a5b5ed 100644 --- a/docs/html/struct_vma_allocator_create_info.html +++ b/docs/html/struct_vma_allocator_create_info.html @@ -109,6 +109,9 @@ Public Attributes VkInstance instance  Optional handle to Vulkan instance object. More...
      +uint32_t vulkanApiVersion + Optional. The highest version of Vulkan that the application is designed to use. More...
    + 

    Detailed Description

    Description of a Allocator to be created.

    @@ -178,7 +181,7 @@ Public Attributes

    Optional handle to Vulkan instance object.

    -

    Optional, can be null. Must be set if VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT flas is used.

    +

    Optional, can be null. Must be set if VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT flas is used or if vulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0).

    @@ -307,6 +310,23 @@ Public Attributes

    If you leave define VMA_STATIC_VULKAN_FUNCTIONS 1 in configuration section, you can pass null as this member, because the library will fetch pointers to Vulkan functions internally in a static way, like: 

    vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;

    Fill this member if you want to provide your own pointers to Vulkan functions, e.g. fetched using vkGetInstanceProcAddr() and vkGetDeviceProcAddr().

    + + + +

    ◆ vulkanApiVersion

    + +
    +
    + + + + +
    uint32_t VmaAllocatorCreateInfo::vulkanApiVersion
    +
    + +

    Optional. The highest version of Vulkan that the application is designed to use.

    +

    It must be a value in the format as created by macro VK_MAKE_VERSION or a constant like: VK_API_VERSION_1_1, VK_API_VERSION_1_0. The patch version number specified is ignored. Only the major and minor versions are considered. It must be less or euqal (preferably equal) to value as passed to vkCreateInstance as VkApplicationInfo::apiVersion. Only versions 1.0 and 1.1 are supported by the current implementation. Leaving it initialized to zero is equivalent to VK_API_VERSION_1_0.

    +
    The documentation for this struct was generated from the following file:
      diff --git a/docs/html/vk__mem__alloc_8h.html b/docs/html/vk__mem__alloc_8h.html index e9be079..3ad9243 100644 --- a/docs/html/vk__mem__alloc_8h.html +++ b/docs/html/vk__mem__alloc_8h.html @@ -125,6 +125,8 @@ Macros   #define NOMINMAX   +#define VMA_VULKAN_VERSION   1000000 +  #define VMA_DEDICATED_ALLOCATION   0   #define VMA_BIND_MEMORY2   0 @@ -506,6 +508,20 @@ Functions
      +
      + + +

      ◆ VMA_VULKAN_VERSION

      + +
      +
      + + + + +
      #define VMA_VULKAN_VERSION   1000000
      +
      +

      Typedef Documentation

      @@ -1016,6 +1032,7 @@ Functions

      Using this flag may increase performance because internal mutexes are not used.

      VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT 

      Enables usage of VK_KHR_dedicated_allocation extension.

      +

      The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion == VK_API_VERSION_1_0. When it's VK_API_VERSION_1_1, the flag is ignored because the extension has been promoted to Vulkan 1.1.

      Using this extenion will automatically allocate dedicated blocks of memory for some buffers and images instead of suballocating place for them out of bigger memory blocks (as if you explicitly used VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT flag) when it is recommended by the driver. It may improve performance on some GPUs.

      You may set this flag only if you found out that following device extensions are supported, you enabled them while creating Vulkan device passed as VmaAllocatorCreateInfo::device, and you want them to be used internally by this library:

        @@ -1028,11 +1045,12 @@ Functions VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT 

        Enables usage of VK_KHR_bind_memory2 extension.

        +

        The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion == VK_API_VERSION_1_0. When it's VK_API_VERSION_1_1, the flag is ignored because the extension has been promoted to Vulkan 1.1.

        You may set this flag only if you found out that this device extension is supported, you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device, and you want it to be used internally by this library.

        The extension provides functions vkBindBufferMemory2KHR and vkBindImageMemory2KHR, which allow to pass a chain of pNext structures while binding. This flag is required if you use pNext parameter in vmaBindBufferMemory2() or vmaBindImageMemory2().

        VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT 

        Enables usage of VK_EXT_memory_budget extension.

        -

        You may set this flag only if you found out that this device extension is supported, you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device, and you want it to be used internally by this library, along with another instance extension VK_KHR_get_physical_device_properties2, which is required by it.

        +

        You may set this flag only if you found out that this device extension is supported, you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device, and you want it to be used internally by this library, along with another instance extension VK_KHR_get_physical_device_properties2, which is required by it (or Vulkan 1.1, where this extension is promoted).

        The extension provides query for current memory usage and budget, which will probably be more accurate than an estimation used by the library otherwise.

        VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM  @@ -1483,7 +1501,7 @@ Functions

        This function is similar to vmaBindBufferMemory(), but it provides additional parameters.

        -

        If pNext is not null, VmaAllocator object must have been created with VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag. Otherwise the call fails.

        +

        If pNext is not null, VmaAllocator object must have been created with VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag or with VmaAllocatorCreateInfo::vulkanApiVersion == VK_API_VERSION_1_1. Otherwise the call fails.

        @@ -1578,7 +1596,7 @@ Functions

        This function is similar to vmaBindImageMemory(), but it provides additional parameters.

        -

        If pNext is not null, VmaAllocator object must have been created with VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag. Otherwise the call fails.

        +

        If pNext is not null, VmaAllocator object must have been created with VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag or with VmaAllocatorCreateInfo::vulkanApiVersion == VK_API_VERSION_1_1. Otherwise the call fails.

        diff --git a/docs/html/vk__mem__alloc_8h_source.html b/docs/html/vk__mem__alloc_8h_source.html index 6b7a35d..0b76afb 100644 --- a/docs/html/vk__mem__alloc_8h_source.html +++ b/docs/html/vk__mem__alloc_8h_source.html @@ -114,14974 +114,15032 @@ $(function() {
        1777  #include <windows.h>
        1778 #endif
        1779 
        -
        1780 #if !defined(VMA_DEDICATED_ALLOCATION)
        -
        1781  #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
        -
        1782  #define VMA_DEDICATED_ALLOCATION 1
        -
        1783  #else
        -
        1784  #define VMA_DEDICATED_ALLOCATION 0
        -
        1785  #endif
        -
        1786 #endif
        -
        1787 
        -
        1788 #if !defined(VMA_BIND_MEMORY2)
        -
        1789  #if VK_KHR_bind_memory2
        -
        1790  #define VMA_BIND_MEMORY2 1
        -
        1791  #else
        -
        1792  #define VMA_BIND_MEMORY2 0
        -
        1793  #endif
        -
        1794 #endif
        -
        1795 
        -
        1796 #if !defined(VMA_MEMORY_BUDGET)
        -
        1797  #if VK_EXT_memory_budget && VK_KHR_get_physical_device_properties2
        -
        1798  #define VMA_MEMORY_BUDGET 1
        -
        1799  #else
        -
        1800  #define VMA_MEMORY_BUDGET 0
        -
        1801  #endif
        -
        1802 #endif
        -
        1803 
        -
        1804 // Define these macros to decorate all public functions with additional code,
        -
        1805 // before and after returned type, appropriately. This may be useful for
        -
        1806 // exporing the functions when compiling VMA as a separate library. Example:
        -
        1807 // #define VMA_CALL_PRE __declspec(dllexport)
        -
        1808 // #define VMA_CALL_POST __cdecl
        -
        1809 #ifndef VMA_CALL_PRE
        -
        1810  #define VMA_CALL_PRE
        -
        1811 #endif
        -
        1812 #ifndef VMA_CALL_POST
        -
        1813  #define VMA_CALL_POST
        -
        1814 #endif
        -
        1815 
        -
        1825 VK_DEFINE_HANDLE(VmaAllocator)
        +
        1780 // Define this macro to declare maximum supported Vulkan version in format AAABBBCCC,
        +
        1781 // where AAA = major, BBB = minor, CCC = patch.
        +
        1782 // If you want to use version > 1.0, it still needs to be enabled via VmaAllocatorCreateInfo::vulkanApiVersion.
        +
        1783 #if !defined(VMA_VULKAN_VERSION)
        +
        1784  #if defined(VK_VERSION_1_1)
        +
        1785  #define VMA_VULKAN_VERSION 1001000
        +
        1786  #else
        +
        1787  #define VMA_VULKAN_VERSION 1000000
        +
        1788  #endif
        +
        1789 #endif
        +
        1790 
        +
        1791 #if !defined(VMA_DEDICATED_ALLOCATION)
        +
        1792  #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
        +
        1793  #define VMA_DEDICATED_ALLOCATION 1
        +
        1794  #else
        +
        1795  #define VMA_DEDICATED_ALLOCATION 0
        +
        1796  #endif
        +
        1797 #endif
        +
        1798 
        +
        1799 #if !defined(VMA_BIND_MEMORY2)
        +
        1800  #if VK_KHR_bind_memory2
        +
        1801  #define VMA_BIND_MEMORY2 1
        +
        1802  #else
        +
        1803  #define VMA_BIND_MEMORY2 0
        +
        1804  #endif
        +
        1805 #endif
        +
        1806 
        +
        1807 #if !defined(VMA_MEMORY_BUDGET)
        +
        1808  #if VK_EXT_memory_budget && (VK_KHR_get_physical_device_properties2 || VMA_VULKAN_VERSION >= 1001000)
        +
        1809  #define VMA_MEMORY_BUDGET 1
        +
        1810  #else
        +
        1811  #define VMA_MEMORY_BUDGET 0
        +
        1812  #endif
        +
        1813 #endif
        +
        1814 
        +
        1815 // Define these macros to decorate all public functions with additional code,
        +
        1816 // before and after returned type, appropriately. This may be useful for
        +
        1817 // exporing the functions when compiling VMA as a separate library. Example:
        +
        1818 // #define VMA_CALL_PRE __declspec(dllexport)
        +
        1819 // #define VMA_CALL_POST __cdecl
        +
        1820 #ifndef VMA_CALL_PRE
        +
        1821  #define VMA_CALL_PRE
        +
        1822 #endif
        +
        1823 #ifndef VMA_CALL_POST
        +
        1824  #define VMA_CALL_POST
        +
        1825 #endif
        1826 
        -
        1827 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
        -
        1829  VmaAllocator allocator,
        -
        1830  uint32_t memoryType,
        -
        1831  VkDeviceMemory memory,
        -
        1832  VkDeviceSize size);
        -
        1834 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
        -
        1835  VmaAllocator allocator,
        -
        1836  uint32_t memoryType,
        -
        1837  VkDeviceMemory memory,
        -
        1838  VkDeviceSize size);
        -
        1839 
        -
        1847 typedef struct VmaDeviceMemoryCallbacks {
        -
        1849  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
        -
        1851  PFN_vmaFreeDeviceMemoryFunction pfnFree;
        -
        1852 } VmaDeviceMemoryCallbacks;
        -
        1853 
        -
        1855 typedef enum VmaAllocatorCreateFlagBits {
        -
        1860  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
        -
        1882  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
        -
        1894  VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT = 0x00000004,
        -
        1906  VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT = 0x00000008,
        -
        1907 
        -
        1908  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        -
        1909 } VmaAllocatorCreateFlagBits;
        -
        1910 typedef VkFlags VmaAllocatorCreateFlags;
        -
        1911 
        -
        1916 typedef struct VmaVulkanFunctions {
        -
        1917  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
        -
        1918  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
        -
        1919  PFN_vkAllocateMemory vkAllocateMemory;
        -
        1920  PFN_vkFreeMemory vkFreeMemory;
        -
        1921  PFN_vkMapMemory vkMapMemory;
        -
        1922  PFN_vkUnmapMemory vkUnmapMemory;
        -
        1923  PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
        -
        1924  PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
        -
        1925  PFN_vkBindBufferMemory vkBindBufferMemory;
        -
        1926  PFN_vkBindImageMemory vkBindImageMemory;
        -
        1927  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
        -
        1928  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
        -
        1929  PFN_vkCreateBuffer vkCreateBuffer;
        -
        1930  PFN_vkDestroyBuffer vkDestroyBuffer;
        -
        1931  PFN_vkCreateImage vkCreateImage;
        -
        1932  PFN_vkDestroyImage vkDestroyImage;
        -
        1933  PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
        -
        1934 #if VMA_DEDICATED_ALLOCATION
        -
        1935  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
        -
        1936  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
        -
        1937 #endif
        -
        1938 #if VMA_BIND_MEMORY2
        -
        1939  PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR;
        -
        1940  PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR;
        -
        1941 #endif
        -
        1942 #if VMA_MEMORY_BUDGET
        -
        1943  PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR;
        -
        1944 #endif
        -
        1945 } VmaVulkanFunctions;
        -
        1946 
        -
        1948 typedef enum VmaRecordFlagBits {
        -
        1954  VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001,
        -
        1955 
        -
        1956  VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        -
        1957 } VmaRecordFlagBits;
        -
        1958 typedef VkFlags VmaRecordFlags;
        -
        1959 
        -
        1961 typedef struct VmaRecordSettings
        -
        1962 {
        -
        1964  VmaRecordFlags flags;
        -
        1972  const char* pFilePath;
        -
        1973 } VmaRecordSettings;
        -
        1974 
        -
        1976 typedef struct VmaAllocatorCreateInfo
        -
        1977 {
        -
        1979  VmaAllocatorCreateFlags flags;
        -
        1981 
        -
        1982  VkPhysicalDevice physicalDevice;
        -
        1984 
        -
        1985  VkDevice device;
        -
        1987 
        -
        1988  VkDeviceSize preferredLargeHeapBlockSize;
        -
        1990 
        -
        1991  const VkAllocationCallbacks* pAllocationCallbacks;
        -
        1993 
        -
        1994  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
        -
        2008  uint32_t frameInUseCount;
        -
        2033  const VkDeviceSize* pHeapSizeLimit;
        -
        2045  const VmaVulkanFunctions* pVulkanFunctions;
        -
        2052  const VmaRecordSettings* pRecordSettings;
        -
        2057  VkInstance instance;
        -
        2058 } VmaAllocatorCreateInfo;
        -
        2059 
        -
        2061 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
        -
        2062  const VmaAllocatorCreateInfo* pCreateInfo,
        -
        2063  VmaAllocator* pAllocator);
        -
        2064 
        -
        2066 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
        -
        2067  VmaAllocator allocator);
        -
        2068 
        -
        2073 VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
        -
        2074  VmaAllocator allocator,
        -
        2075  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
        -
        2076 
        -
        2081 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
        -
        2082  VmaAllocator allocator,
        -
        2083  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
        -
        2084 
        -
        2091 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
        -
        2092  VmaAllocator allocator,
        -
        2093  uint32_t memoryTypeIndex,
        -
        2094  VkMemoryPropertyFlags* pFlags);
        +
        1836 VK_DEFINE_HANDLE(VmaAllocator)
        +
        1837 
        +
        1838 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
        +
        1840  VmaAllocator allocator,
        +
        1841  uint32_t memoryType,
        +
        1842  VkDeviceMemory memory,
        +
        1843  VkDeviceSize size);
        +
        1845 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
        +
        1846  VmaAllocator allocator,
        +
        1847  uint32_t memoryType,
        +
        1848  VkDeviceMemory memory,
        +
        1849  VkDeviceSize size);
        +
        1850 
        +
        1858 typedef struct VmaDeviceMemoryCallbacks {
        +
        1860  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
        +
        1862  PFN_vmaFreeDeviceMemoryFunction pfnFree;
        +
        1863 } VmaDeviceMemoryCallbacks;
        +
        1864 
        +
        1866 typedef enum VmaAllocatorCreateFlagBits {
        +
        1871  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
        +
        1896  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
        +
        1911  VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT = 0x00000004,
        +
        1923  VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT = 0x00000008,
        +
        1924 
        +
        1925  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        +
        1926 } VmaAllocatorCreateFlagBits;
        +
        1927 typedef VkFlags VmaAllocatorCreateFlags;
        +
        1928 
        +
        1933 typedef struct VmaVulkanFunctions {
        +
        1934  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
        +
        1935  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
        +
        1936  PFN_vkAllocateMemory vkAllocateMemory;
        +
        1937  PFN_vkFreeMemory vkFreeMemory;
        +
        1938  PFN_vkMapMemory vkMapMemory;
        +
        1939  PFN_vkUnmapMemory vkUnmapMemory;
        +
        1940  PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
        +
        1941  PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
        +
        1942  PFN_vkBindBufferMemory vkBindBufferMemory;
        +
        1943  PFN_vkBindImageMemory vkBindImageMemory;
        +
        1944  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
        +
        1945  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
        +
        1946  PFN_vkCreateBuffer vkCreateBuffer;
        +
        1947  PFN_vkDestroyBuffer vkDestroyBuffer;
        +
        1948  PFN_vkCreateImage vkCreateImage;
        +
        1949  PFN_vkDestroyImage vkDestroyImage;
        +
        1950  PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
        +
        1951 #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        1952  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
        +
        1953  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
        +
        1954 #endif
        +
        1955 #if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
        +
        1956  PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR;
        +
        1957  PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR;
        +
        1958 #endif
        +
        1959 #if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
        +
        1960  PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR;
        +
        1961 #endif
        +
        1962 } VmaVulkanFunctions;
        +
        1963 
        +
        1965 typedef enum VmaRecordFlagBits {
        +
        1971  VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001,
        +
        1972 
        +
        1973  VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        +
        1974 } VmaRecordFlagBits;
        +
        1975 typedef VkFlags VmaRecordFlags;
        +
        1976 
        +
        1978 typedef struct VmaRecordSettings
        +
        1979 {
        +
        1981  VmaRecordFlags flags;
        +
        1989  const char* pFilePath;
        +
        1990 } VmaRecordSettings;
        +
        1991 
        +
        1993 typedef struct VmaAllocatorCreateInfo
        +
        1994 {
        +
        1996  VmaAllocatorCreateFlags flags;
        +
        1998 
        +
        1999  VkPhysicalDevice physicalDevice;
        +
        2001 
        +
        2002  VkDevice device;
        +
        2004 
        +
        2005  VkDeviceSize preferredLargeHeapBlockSize;
        +
        2007 
        +
        2008  const VkAllocationCallbacks* pAllocationCallbacks;
        +
        2010 
        +
        2011  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
        +
        2025  uint32_t frameInUseCount;
        +
        2050  const VkDeviceSize* pHeapSizeLimit;
        +
        2062  const VmaVulkanFunctions* pVulkanFunctions;
        +
        2069  const VmaRecordSettings* pRecordSettings;
        +
        2075  VkInstance instance;
        +
        2084  uint32_t vulkanApiVersion;
        +
        2085 } VmaAllocatorCreateInfo;
        +
        2086 
        +
        2088 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
        +
        2089  const VmaAllocatorCreateInfo* pCreateInfo,
        +
        2090  VmaAllocator* pAllocator);
        +
        2091 
        +
        2093 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
        +
        2094  VmaAllocator allocator);
        2095 
        -
        2104 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
        -
        2105  VmaAllocator allocator,
        -
        2106  uint32_t frameIndex);
        -
        2107 
        -
        2110 typedef struct VmaStatInfo
        -
        2111 {
        -
        2113  uint32_t blockCount;
        -
        2115  uint32_t allocationCount;
        -
        2117  uint32_t unusedRangeCount;
        -
        2119  VkDeviceSize usedBytes;
        -
        2121  VkDeviceSize unusedBytes;
        -
        2122  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
        -
        2123  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
        -
        2124 } VmaStatInfo;
        -
        2125 
        -
        2127 typedef struct VmaStats
        -
        2128 {
        -
        2129  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
        -
        2130  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
        -
        2131  VmaStatInfo total;
        -
        2132 } VmaStats;
        -
        2133 
        -
        2143 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
        -
        2144  VmaAllocator allocator,
        -
        2145  VmaStats* pStats);
        -
        2146 
        -
        2149 typedef struct VmaBudget
        -
        2150 {
        -
        2153  VkDeviceSize blockBytes;
        -
        2154 
        -
        2164  VkDeviceSize allocationBytes;
        -
        2165 
        -
        2174  VkDeviceSize usage;
        -
        2175 
        -
        2185  VkDeviceSize budget;
        -
        2186 } VmaBudget;
        -
        2187 
        -
        2198 VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
        -
        2199  VmaAllocator allocator,
        -
        2200  VmaBudget* pBudget);
        -
        2201 
        -
        2202 #ifndef VMA_STATS_STRING_ENABLED
        -
        2203 #define VMA_STATS_STRING_ENABLED 1
        -
        2204 #endif
        -
        2205 
        -
        2206 #if VMA_STATS_STRING_ENABLED
        -
        2207 
        -
        2209 
        -
        2211 VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
        -
        2212  VmaAllocator allocator,
        -
        2213  char** ppStatsString,
        -
        2214  VkBool32 detailedMap);
        -
        2215 
        -
        2216 VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
        -
        2217  VmaAllocator allocator,
        -
        2218  char* pStatsString);
        -
        2219 
        -
        2220 #endif // #if VMA_STATS_STRING_ENABLED
        -
        2221 
        -
        2230 VK_DEFINE_HANDLE(VmaPool)
        -
        2231 
        -
        2232 typedef enum VmaMemoryUsage
        -
        2233 {
        -
        2237  VMA_MEMORY_USAGE_UNKNOWN = 0,
        -
        2254  VMA_MEMORY_USAGE_GPU_ONLY = 1,
        -
        2264  VMA_MEMORY_USAGE_CPU_ONLY = 2,
        -
        2271  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
        -
        2280  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
        -
        2286  VMA_MEMORY_USAGE_CPU_COPY = 5,
        -
        2294  VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED = 6,
        -
        2295 
        -
        2296  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
        -
        2297 } VmaMemoryUsage;
        -
        2298 
        -
        2300 typedef enum VmaAllocationCreateFlagBits {
        -
        2307  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
        -
        2308 
        -
        2318  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
        -
        2331  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
        -
        2344  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
        -
        2351  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
        -
        2357  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
        -
        2362  VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
        -
        2368  VMA_ALLOCATION_CREATE_DONT_BIND_BIT = 0x00000080,
        -
        2372  VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = 0x00000100,
        -
        2373 
        -
        2377  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT = 0x00010000,
        -
        2381  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT = 0x00020000,
        -
        2388  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = 0x00040000,
        -
        2389 
        -
        2392  VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
        -
        2395  VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
        -
        2398  VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT = VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT,
        -
        2399 
        -
        2402  VMA_ALLOCATION_CREATE_STRATEGY_MASK =
        -
        2403  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT |
        -
        2404  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT |
        -
        2405  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
        -
        2406 
        -
        2407  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        -
        2408 } VmaAllocationCreateFlagBits;
        -
        2409 typedef VkFlags VmaAllocationCreateFlags;
        -
        2410 
        -
        2411 typedef struct VmaAllocationCreateInfo
        -
        2412 {
        -
        2414  VmaAllocationCreateFlags flags;
        -
        2420  VmaMemoryUsage usage;
        -
        2425  VkMemoryPropertyFlags requiredFlags;
        -
        2430  VkMemoryPropertyFlags preferredFlags;
        -
        2438  uint32_t memoryTypeBits;
        -
        2444  VmaPool pool;
        -
        2451  void* pUserData;
        -
        2452 } VmaAllocationCreateInfo;
        -
        2453 
        -
        2470 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
        -
        2471  VmaAllocator allocator,
        -
        2472  uint32_t memoryTypeBits,
        -
        2473  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        2474  uint32_t* pMemoryTypeIndex);
        -
        2475 
        -
        2488 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
        -
        2489  VmaAllocator allocator,
        -
        2490  const VkBufferCreateInfo* pBufferCreateInfo,
        -
        2491  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        2492  uint32_t* pMemoryTypeIndex);
        -
        2493 
        -
        2506 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
        -
        2507  VmaAllocator allocator,
        -
        2508  const VkImageCreateInfo* pImageCreateInfo,
        -
        2509  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        2510  uint32_t* pMemoryTypeIndex);
        -
        2511 
        -
        2513 typedef enum VmaPoolCreateFlagBits {
        -
        2531  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
        -
        2532 
        -
        2548  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
        -
        2549 
        -
        2559  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT = 0x00000008,
        -
        2560 
        -
        2563  VMA_POOL_CREATE_ALGORITHM_MASK =
        -
        2564  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT |
        -
        2565  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT,
        -
        2566 
        -
        2567  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        -
        2568 } VmaPoolCreateFlagBits;
        -
        2569 typedef VkFlags VmaPoolCreateFlags;
        -
        2570 
        -
        2573 typedef struct VmaPoolCreateInfo {
        -
        2576  uint32_t memoryTypeIndex;
        -
        2579  VmaPoolCreateFlags flags;
        -
        2588  VkDeviceSize blockSize;
        -
        2593  size_t minBlockCount;
        -
        2601  size_t maxBlockCount;
        -
        2615  uint32_t frameInUseCount;
        -
        2616 } VmaPoolCreateInfo;
        -
        2617 
        -
        2620 typedef struct VmaPoolStats {
        -
        2623  VkDeviceSize size;
        -
        2626  VkDeviceSize unusedSize;
        -
        2629  size_t allocationCount;
        -
        2632  size_t unusedRangeCount;
        -
        2639  VkDeviceSize unusedRangeSizeMax;
        -
        2642  size_t blockCount;
        -
        2643 } VmaPoolStats;
        +
        2100 VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
        +
        2101  VmaAllocator allocator,
        +
        2102  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
        +
        2103 
        +
        2108 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
        +
        2109  VmaAllocator allocator,
        +
        2110  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
        +
        2111 
        +
        2118 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
        +
        2119  VmaAllocator allocator,
        +
        2120  uint32_t memoryTypeIndex,
        +
        2121  VkMemoryPropertyFlags* pFlags);
        +
        2122 
        +
        2131 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
        +
        2132  VmaAllocator allocator,
        +
        2133  uint32_t frameIndex);
        +
        2134 
        +
        2137 typedef struct VmaStatInfo
        +
        2138 {
        +
        2140  uint32_t blockCount;
        +
        2142  uint32_t allocationCount;
        +
        2144  uint32_t unusedRangeCount;
        +
        2146  VkDeviceSize usedBytes;
        +
        2148  VkDeviceSize unusedBytes;
        +
        2149  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
        +
        2150  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
        +
        2151 } VmaStatInfo;
        +
        2152 
        +
        2154 typedef struct VmaStats
        +
        2155 {
        +
        2156  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
        +
        2157  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
        +
        2158  VmaStatInfo total;
        +
        2159 } VmaStats;
        +
        2160 
        +
        2170 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
        +
        2171  VmaAllocator allocator,
        +
        2172  VmaStats* pStats);
        +
        2173 
        +
        2176 typedef struct VmaBudget
        +
        2177 {
        +
        2180  VkDeviceSize blockBytes;
        +
        2181 
        +
        2191  VkDeviceSize allocationBytes;
        +
        2192 
        +
        2201  VkDeviceSize usage;
        +
        2202 
        +
        2212  VkDeviceSize budget;
        +
        2213 } VmaBudget;
        +
        2214 
        +
        2225 VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
        +
        2226  VmaAllocator allocator,
        +
        2227  VmaBudget* pBudget);
        +
        2228 
        +
        2229 #ifndef VMA_STATS_STRING_ENABLED
        +
        2230 #define VMA_STATS_STRING_ENABLED 1
        +
        2231 #endif
        +
        2232 
        +
        2233 #if VMA_STATS_STRING_ENABLED
        +
        2234 
        +
        2236 
        +
        2238 VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
        +
        2239  VmaAllocator allocator,
        +
        2240  char** ppStatsString,
        +
        2241  VkBool32 detailedMap);
        +
        2242 
        +
        2243 VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
        +
        2244  VmaAllocator allocator,
        +
        2245  char* pStatsString);
        +
        2246 
        +
        2247 #endif // #if VMA_STATS_STRING_ENABLED
        +
        2248 
        +
        2257 VK_DEFINE_HANDLE(VmaPool)
        +
        2258 
        +
        2259 typedef enum VmaMemoryUsage
        +
        2260 {
        +
        2264  VMA_MEMORY_USAGE_UNKNOWN = 0,
        +
        2281  VMA_MEMORY_USAGE_GPU_ONLY = 1,
        +
        2291  VMA_MEMORY_USAGE_CPU_ONLY = 2,
        +
        2298  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
        +
        2307  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
        +
        2313  VMA_MEMORY_USAGE_CPU_COPY = 5,
        +
        2321  VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED = 6,
        +
        2322 
        +
        2323  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
        +
        2324 } VmaMemoryUsage;
        +
        2325 
        +
        2327 typedef enum VmaAllocationCreateFlagBits {
        +
        2334  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
        +
        2335 
        +
        2345  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
        +
        2358  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
        +
        2371  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
        +
        2378  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
        +
        2384  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
        +
        2389  VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
        +
        2395  VMA_ALLOCATION_CREATE_DONT_BIND_BIT = 0x00000080,
        +
        2399  VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = 0x00000100,
        +
        2400 
        +
        2404  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT = 0x00010000,
        +
        2408  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT = 0x00020000,
        +
        2415  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = 0x00040000,
        +
        2416 
        +
        2419  VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
        +
        2422  VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
        +
        2425  VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT = VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT,
        +
        2426 
        +
        2429  VMA_ALLOCATION_CREATE_STRATEGY_MASK =
        +
        2430  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT |
        +
        2431  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT |
        +
        2432  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
        +
        2433 
        +
        2434  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        +
        2435 } VmaAllocationCreateFlagBits;
        +
        2436 typedef VkFlags VmaAllocationCreateFlags;
        +
        2437 
        +
        2438 typedef struct VmaAllocationCreateInfo
        +
        2439 {
        +
        2441  VmaAllocationCreateFlags flags;
        +
        2447  VmaMemoryUsage usage;
        +
        2452  VkMemoryPropertyFlags requiredFlags;
        +
        2457  VkMemoryPropertyFlags preferredFlags;
        +
        2465  uint32_t memoryTypeBits;
        +
        2471  VmaPool pool;
        +
        2478  void* pUserData;
        +
        2479 } VmaAllocationCreateInfo;
        +
        2480 
        +
        2497 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
        +
        2498  VmaAllocator allocator,
        +
        2499  uint32_t memoryTypeBits,
        +
        2500  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        2501  uint32_t* pMemoryTypeIndex);
        +
        2502 
        +
        2515 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
        +
        2516  VmaAllocator allocator,
        +
        2517  const VkBufferCreateInfo* pBufferCreateInfo,
        +
        2518  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        2519  uint32_t* pMemoryTypeIndex);
        +
        2520 
        +
        2533 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
        +
        2534  VmaAllocator allocator,
        +
        2535  const VkImageCreateInfo* pImageCreateInfo,
        +
        2536  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        2537  uint32_t* pMemoryTypeIndex);
        +
        2538 
        +
        2540 typedef enum VmaPoolCreateFlagBits {
        +
        2558  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
        +
        2559 
        +
        2575  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
        +
        2576 
        +
        2586  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT = 0x00000008,
        +
        2587 
        +
        2590  VMA_POOL_CREATE_ALGORITHM_MASK =
        +
        2591  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT |
        +
        2592  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT,
        +
        2593 
        +
        2594  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        +
        2595 } VmaPoolCreateFlagBits;
        +
        2596 typedef VkFlags VmaPoolCreateFlags;
        +
        2597 
        +
        2600 typedef struct VmaPoolCreateInfo {
        +
        2603  uint32_t memoryTypeIndex;
        +
        2606  VmaPoolCreateFlags flags;
        +
        2615  VkDeviceSize blockSize;
        +
        2620  size_t minBlockCount;
        +
        2628  size_t maxBlockCount;
        +
        2642  uint32_t frameInUseCount;
        +
        2643 } VmaPoolCreateInfo;
        2644 
        -
        2651 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
        -
        2652  VmaAllocator allocator,
        -
        2653  const VmaPoolCreateInfo* pCreateInfo,
        -
        2654  VmaPool* pPool);
        -
        2655 
        -
        2658 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
        -
        2659  VmaAllocator allocator,
        -
        2660  VmaPool pool);
        -
        2661 
        -
        2668 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
        -
        2669  VmaAllocator allocator,
        -
        2670  VmaPool pool,
        -
        2671  VmaPoolStats* pPoolStats);
        -
        2672 
        -
        2679 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
        -
        2680  VmaAllocator allocator,
        -
        2681  VmaPool pool,
        -
        2682  size_t* pLostAllocationCount);
        -
        2683 
        -
        2698 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
        +
        2647 typedef struct VmaPoolStats {
        +
        2650  VkDeviceSize size;
        +
        2653  VkDeviceSize unusedSize;
        +
        2656  size_t allocationCount;
        +
        2659  size_t unusedRangeCount;
        +
        2666  VkDeviceSize unusedRangeSizeMax;
        +
        2669  size_t blockCount;
        +
        2670 } VmaPoolStats;
        +
        2671 
        +
        2678 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
        +
        2679  VmaAllocator allocator,
        +
        2680  const VmaPoolCreateInfo* pCreateInfo,
        +
        2681  VmaPool* pPool);
        +
        2682 
        +
        2685 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
        +
        2686  VmaAllocator allocator,
        +
        2687  VmaPool pool);
        +
        2688 
        +
        2695 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
        +
        2696  VmaAllocator allocator,
        +
        2697  VmaPool pool,
        +
        2698  VmaPoolStats* pPoolStats);
        2699 
        -
        2706 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
        +
        2706 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
        2707  VmaAllocator allocator,
        2708  VmaPool pool,
        -
        2709  const char** ppName);
        +
        2709  size_t* pLostAllocationCount);
        2710 
        -
        2716 VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
        -
        2717  VmaAllocator allocator,
        -
        2718  VmaPool pool,
        -
        2719  const char* pName);
        -
        2720 
        -
        2745 VK_DEFINE_HANDLE(VmaAllocation)
        -
        2746 
        +
        2725 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
        +
        2726 
        +
        2733 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
        +
        2734  VmaAllocator allocator,
        +
        2735  VmaPool pool,
        +
        2736  const char** ppName);
        +
        2737 
        +
        2743 VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
        +
        2744  VmaAllocator allocator,
        +
        2745  VmaPool pool,
        +
        2746  const char* pName);
        2747 
        -
        2749 typedef struct VmaAllocationInfo {
        -
        2754  uint32_t memoryType;
        -
        2763  VkDeviceMemory deviceMemory;
        -
        2768  VkDeviceSize offset;
        -
        2773  VkDeviceSize size;
        -
        2782  void* pMappedData;
        -
        2787  void* pUserData;
        -
        2788 } VmaAllocationInfo;
        -
        2789 
        -
        2800 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
        -
        2801  VmaAllocator allocator,
        -
        2802  const VkMemoryRequirements* pVkMemoryRequirements,
        -
        2803  const VmaAllocationCreateInfo* pCreateInfo,
        -
        2804  VmaAllocation* pAllocation,
        -
        2805  VmaAllocationInfo* pAllocationInfo);
        -
        2806 
        -
        2826 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
        -
        2827  VmaAllocator allocator,
        -
        2828  const VkMemoryRequirements* pVkMemoryRequirements,
        -
        2829  const VmaAllocationCreateInfo* pCreateInfo,
        -
        2830  size_t allocationCount,
        -
        2831  VmaAllocation* pAllocations,
        +
        2772 VK_DEFINE_HANDLE(VmaAllocation)
        +
        2773 
        +
        2774 
        +
        2776 typedef struct VmaAllocationInfo {
        +
        2781  uint32_t memoryType;
        +
        2790  VkDeviceMemory deviceMemory;
        +
        2795  VkDeviceSize offset;
        +
        2800  VkDeviceSize size;
        +
        2809  void* pMappedData;
        +
        2814  void* pUserData;
        +
        2815 } VmaAllocationInfo;
        +
        2816 
        +
        2827 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
        +
        2828  VmaAllocator allocator,
        +
        2829  const VkMemoryRequirements* pVkMemoryRequirements,
        +
        2830  const VmaAllocationCreateInfo* pCreateInfo,
        +
        2831  VmaAllocation* pAllocation,
        2832  VmaAllocationInfo* pAllocationInfo);
        2833 
        -
        2840 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
        -
        2841  VmaAllocator allocator,
        -
        2842  VkBuffer buffer,
        -
        2843  const VmaAllocationCreateInfo* pCreateInfo,
        -
        2844  VmaAllocation* pAllocation,
        -
        2845  VmaAllocationInfo* pAllocationInfo);
        -
        2846 
        -
        2848 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
        -
        2849  VmaAllocator allocator,
        -
        2850  VkImage image,
        -
        2851  const VmaAllocationCreateInfo* pCreateInfo,
        -
        2852  VmaAllocation* pAllocation,
        -
        2853  VmaAllocationInfo* pAllocationInfo);
        -
        2854 
        -
        2859 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
        -
        2860  VmaAllocator allocator,
        -
        2861  VmaAllocation allocation);
        -
        2862 
        -
        2873 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
        -
        2874  VmaAllocator allocator,
        -
        2875  size_t allocationCount,
        -
        2876  VmaAllocation* pAllocations);
        -
        2877 
        -
        2884 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
        -
        2885  VmaAllocator allocator,
        -
        2886  VmaAllocation allocation,
        -
        2887  VkDeviceSize newSize);
        -
        2888 
        -
        2905 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
        -
        2906  VmaAllocator allocator,
        -
        2907  VmaAllocation allocation,
        -
        2908  VmaAllocationInfo* pAllocationInfo);
        -
        2909 
        -
        2924 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
        -
        2925  VmaAllocator allocator,
        -
        2926  VmaAllocation allocation);
        -
        2927 
        -
        2941 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
        -
        2942  VmaAllocator allocator,
        -
        2943  VmaAllocation allocation,
        -
        2944  void* pUserData);
        -
        2945 
        -
        2956 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
        -
        2957  VmaAllocator allocator,
        -
        2958  VmaAllocation* pAllocation);
        -
        2959 
        -
        2994 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
        -
        2995  VmaAllocator allocator,
        -
        2996  VmaAllocation allocation,
        -
        2997  void** ppData);
        -
        2998 
        -
        3003 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
        -
        3004  VmaAllocator allocator,
        -
        3005  VmaAllocation allocation);
        -
        3006 
        -
        3023 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        -
        3024 
        -
        3041 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        -
        3042 
        -
        3059 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
        -
        3060 
        -
        3067 VK_DEFINE_HANDLE(VmaDefragmentationContext)
        -
        3068 
        -
        3069 typedef enum VmaDefragmentationFlagBits {
        -
        3071  VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        -
        3072 } VmaDefragmentationFlagBits;
        -
        3073 typedef VkFlags VmaDefragmentationFlags;
        -
        3074 
        -
        3079 typedef struct VmaDefragmentationInfo2 {
        -
        3082  VmaDefragmentationFlags flags;
        -
        3085  uint32_t allocationCount;
        -
        3094  VmaAllocation* pAllocations;
        -
        3100  VkBool32* pAllocationsChanged;
        -
        3103  uint32_t poolCount;
        -
        3119  VmaPool* pPools;
        -
        3124  VkDeviceSize maxCpuBytesToMove;
        -
        3129  uint32_t maxCpuAllocationsToMove;
        -
        3134  VkDeviceSize maxGpuBytesToMove;
        -
        3139  uint32_t maxGpuAllocationsToMove;
        -
        3148  VkCommandBuffer commandBuffer;
        -
        3149 } VmaDefragmentationInfo2;
        -
        3150 
        -
        3155 typedef struct VmaDefragmentationInfo {
        -
        3160  VkDeviceSize maxBytesToMove;
        -
        3165  uint32_t maxAllocationsToMove;
        -
        3166 } VmaDefragmentationInfo;
        -
        3167 
        -
        3169 typedef struct VmaDefragmentationStats {
        -
        3171  VkDeviceSize bytesMoved;
        -
        3173  VkDeviceSize bytesFreed;
        -
        3175  uint32_t allocationsMoved;
        -
        3177  uint32_t deviceMemoryBlocksFreed;
        -
        3178 } VmaDefragmentationStats;
        -
        3179 
        -
        3209 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
        -
        3210  VmaAllocator allocator,
        -
        3211  const VmaDefragmentationInfo2* pInfo,
        -
        3212  VmaDefragmentationStats* pStats,
        -
        3213  VmaDefragmentationContext *pContext);
        -
        3214 
        -
        3220 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
        -
        3221  VmaAllocator allocator,
        -
        3222  VmaDefragmentationContext context);
        -
        3223 
        -
        3264 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
        -
        3265  VmaAllocator allocator,
        -
        3266  VmaAllocation* pAllocations,
        -
        3267  size_t allocationCount,
        -
        3268  VkBool32* pAllocationsChanged,
        -
        3269  const VmaDefragmentationInfo *pDefragmentationInfo,
        -
        3270  VmaDefragmentationStats* pDefragmentationStats);
        -
        3271 
        -
        3284 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
        -
        3285  VmaAllocator allocator,
        -
        3286  VmaAllocation allocation,
        -
        3287  VkBuffer buffer);
        -
        3288 
        -
        3299 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
        -
        3300  VmaAllocator allocator,
        -
        3301  VmaAllocation allocation,
        -
        3302  VkDeviceSize allocationLocalOffset,
        -
        3303  VkBuffer buffer,
        -
        3304  const void* pNext);
        -
        3305 
        -
        3318 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
        -
        3319  VmaAllocator allocator,
        -
        3320  VmaAllocation allocation,
        -
        3321  VkImage image);
        -
        3322 
        -
        3333 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
        -
        3334  VmaAllocator allocator,
        -
        3335  VmaAllocation allocation,
        -
        3336  VkDeviceSize allocationLocalOffset,
        -
        3337  VkImage image,
        -
        3338  const void* pNext);
        -
        3339 
        -
        3366 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
        -
        3367  VmaAllocator allocator,
        -
        3368  const VkBufferCreateInfo* pBufferCreateInfo,
        -
        3369  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        3370  VkBuffer* pBuffer,
        -
        3371  VmaAllocation* pAllocation,
        -
        3372  VmaAllocationInfo* pAllocationInfo);
        -
        3373 
        -
        3385 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
        -
        3386  VmaAllocator allocator,
        -
        3387  VkBuffer buffer,
        -
        3388  VmaAllocation allocation);
        -
        3389 
        -
        3391 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
        -
        3392  VmaAllocator allocator,
        -
        3393  const VkImageCreateInfo* pImageCreateInfo,
        -
        3394  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        3395  VkImage* pImage,
        -
        3396  VmaAllocation* pAllocation,
        -
        3397  VmaAllocationInfo* pAllocationInfo);
        -
        3398 
        -
        3410 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
        -
        3411  VmaAllocator allocator,
        -
        3412  VkImage image,
        -
        3413  VmaAllocation allocation);
        -
        3414 
        -
        3415 #ifdef __cplusplus
        -
        3416 }
        -
        3417 #endif
        -
        3418 
        -
        3419 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
        -
        3420 
        -
        3421 // For Visual Studio IntelliSense.
        -
        3422 #if defined(__cplusplus) && defined(__INTELLISENSE__)
        -
        3423 #define VMA_IMPLEMENTATION
        -
        3424 #endif
        +
        2853 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
        +
        2854  VmaAllocator allocator,
        +
        2855  const VkMemoryRequirements* pVkMemoryRequirements,
        +
        2856  const VmaAllocationCreateInfo* pCreateInfo,
        +
        2857  size_t allocationCount,
        +
        2858  VmaAllocation* pAllocations,
        +
        2859  VmaAllocationInfo* pAllocationInfo);
        +
        2860 
        +
        2867 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
        +
        2868  VmaAllocator allocator,
        +
        2869  VkBuffer buffer,
        +
        2870  const VmaAllocationCreateInfo* pCreateInfo,
        +
        2871  VmaAllocation* pAllocation,
        +
        2872  VmaAllocationInfo* pAllocationInfo);
        +
        2873 
        +
        2875 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
        +
        2876  VmaAllocator allocator,
        +
        2877  VkImage image,
        +
        2878  const VmaAllocationCreateInfo* pCreateInfo,
        +
        2879  VmaAllocation* pAllocation,
        +
        2880  VmaAllocationInfo* pAllocationInfo);
        +
        2881 
        +
        2886 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
        +
        2887  VmaAllocator allocator,
        +
        2888  VmaAllocation allocation);
        +
        2889 
        +
        2900 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
        +
        2901  VmaAllocator allocator,
        +
        2902  size_t allocationCount,
        +
        2903  VmaAllocation* pAllocations);
        +
        2904 
        +
        2911 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
        +
        2912  VmaAllocator allocator,
        +
        2913  VmaAllocation allocation,
        +
        2914  VkDeviceSize newSize);
        +
        2915 
        +
        2932 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
        +
        2933  VmaAllocator allocator,
        +
        2934  VmaAllocation allocation,
        +
        2935  VmaAllocationInfo* pAllocationInfo);
        +
        2936 
        +
        2951 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
        +
        2952  VmaAllocator allocator,
        +
        2953  VmaAllocation allocation);
        +
        2954 
        +
        2968 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
        +
        2969  VmaAllocator allocator,
        +
        2970  VmaAllocation allocation,
        +
        2971  void* pUserData);
        +
        2972 
        +
        2983 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
        +
        2984  VmaAllocator allocator,
        +
        2985  VmaAllocation* pAllocation);
        +
        2986 
        +
        3021 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
        +
        3022  VmaAllocator allocator,
        +
        3023  VmaAllocation allocation,
        +
        3024  void** ppData);
        +
        3025 
        +
        3030 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
        +
        3031  VmaAllocator allocator,
        +
        3032  VmaAllocation allocation);
        +
        3033 
        +
        3050 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        +
        3051 
        +
        3068 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        +
        3069 
        +
        3086 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
        +
        3087 
        +
        3094 VK_DEFINE_HANDLE(VmaDefragmentationContext)
        +
        3095 
        +
        3096 typedef enum VmaDefragmentationFlagBits {
        +
        3098  VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        +
        3099 } VmaDefragmentationFlagBits;
        +
        3100 typedef VkFlags VmaDefragmentationFlags;
        +
        3101 
        +
        3106 typedef struct VmaDefragmentationInfo2 {
        +
        3109  VmaDefragmentationFlags flags;
        +
        3112  uint32_t allocationCount;
        +
        3121  VmaAllocation* pAllocations;
        +
        3127  VkBool32* pAllocationsChanged;
        +
        3130  uint32_t poolCount;
        +
        3146  VmaPool* pPools;
        +
        3151  VkDeviceSize maxCpuBytesToMove;
        +
        3156  uint32_t maxCpuAllocationsToMove;
        +
        3161  VkDeviceSize maxGpuBytesToMove;
        +
        3166  uint32_t maxGpuAllocationsToMove;
        +
        3175  VkCommandBuffer commandBuffer;
        +
        3176 } VmaDefragmentationInfo2;
        +
        3177 
        +
        3182 typedef struct VmaDefragmentationInfo {
        +
        3187  VkDeviceSize maxBytesToMove;
        +
        3192  uint32_t maxAllocationsToMove;
        +
        3193 } VmaDefragmentationInfo;
        +
        3194 
        +
        3196 typedef struct VmaDefragmentationStats {
        +
        3198  VkDeviceSize bytesMoved;
        +
        3200  VkDeviceSize bytesFreed;
        +
        3202  uint32_t allocationsMoved;
        +
        3204  uint32_t deviceMemoryBlocksFreed;
        +
        3205 } VmaDefragmentationStats;
        +
        3206 
        +
        3236 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
        +
        3237  VmaAllocator allocator,
        +
        3238  const VmaDefragmentationInfo2* pInfo,
        +
        3239  VmaDefragmentationStats* pStats,
        +
        3240  VmaDefragmentationContext *pContext);
        +
        3241 
        +
        3247 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
        +
        3248  VmaAllocator allocator,
        +
        3249  VmaDefragmentationContext context);
        +
        3250 
        +
        3291 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
        +
        3292  VmaAllocator allocator,
        +
        3293  VmaAllocation* pAllocations,
        +
        3294  size_t allocationCount,
        +
        3295  VkBool32* pAllocationsChanged,
        +
        3296  const VmaDefragmentationInfo *pDefragmentationInfo,
        +
        3297  VmaDefragmentationStats* pDefragmentationStats);
        +
        3298 
        +
        3311 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
        +
        3312  VmaAllocator allocator,
        +
        3313  VmaAllocation allocation,
        +
        3314  VkBuffer buffer);
        +
        3315 
        +
        3326 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
        +
        3327  VmaAllocator allocator,
        +
        3328  VmaAllocation allocation,
        +
        3329  VkDeviceSize allocationLocalOffset,
        +
        3330  VkBuffer buffer,
        +
        3331  const void* pNext);
        +
        3332 
        +
        3345 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
        +
        3346  VmaAllocator allocator,
        +
        3347  VmaAllocation allocation,
        +
        3348  VkImage image);
        +
        3349 
        +
        3360 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
        +
        3361  VmaAllocator allocator,
        +
        3362  VmaAllocation allocation,
        +
        3363  VkDeviceSize allocationLocalOffset,
        +
        3364  VkImage image,
        +
        3365  const void* pNext);
        +
        3366 
        +
        3393 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
        +
        3394  VmaAllocator allocator,
        +
        3395  const VkBufferCreateInfo* pBufferCreateInfo,
        +
        3396  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        3397  VkBuffer* pBuffer,
        +
        3398  VmaAllocation* pAllocation,
        +
        3399  VmaAllocationInfo* pAllocationInfo);
        +
        3400 
        +
        3412 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
        +
        3413  VmaAllocator allocator,
        +
        3414  VkBuffer buffer,
        +
        3415  VmaAllocation allocation);
        +
        3416 
        +
        3418 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
        +
        3419  VmaAllocator allocator,
        +
        3420  const VkImageCreateInfo* pImageCreateInfo,
        +
        3421  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        3422  VkImage* pImage,
        +
        3423  VmaAllocation* pAllocation,
        +
        3424  VmaAllocationInfo* pAllocationInfo);
        3425 
        -
        3426 #ifdef VMA_IMPLEMENTATION
        -
        3427 #undef VMA_IMPLEMENTATION
        -
        3428 
        -
        3429 #include <cstdint>
        -
        3430 #include <cstdlib>
        -
        3431 #include <cstring>
        -
        3432 
        -
        3433 /*******************************************************************************
        -
        3434 CONFIGURATION SECTION
        -
        3435 
        -
        3436 Define some of these macros before each #include of this header or change them
        -
        3437 here if you need other then default behavior depending on your environment.
        -
        3438 */
        -
        3439 
        -
        3440 /*
        -
        3441 Define this macro to 1 to make the library fetch pointers to Vulkan functions
        -
        3442 internally, like:
        -
        3443 
        -
        3444  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
        -
        3445 
        -
        3446 Define to 0 if you are going to provide you own pointers to Vulkan functions via
        -
        3447 VmaAllocatorCreateInfo::pVulkanFunctions.
        -
        3448 */
        -
        3449 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
        -
        3450 #define VMA_STATIC_VULKAN_FUNCTIONS 1
        +
        3437 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
        +
        3438  VmaAllocator allocator,
        +
        3439  VkImage image,
        +
        3440  VmaAllocation allocation);
        +
        3441 
        +
        3442 #ifdef __cplusplus
        +
        3443 }
        +
        3444 #endif
        +
        3445 
        +
        3446 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
        +
        3447 
        +
        3448 // For Visual Studio IntelliSense.
        +
        3449 #if defined(__cplusplus) && defined(__INTELLISENSE__)
        +
        3450 #define VMA_IMPLEMENTATION
        3451 #endif
        3452 
        -
        3453 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
        -
        3454 //#define VMA_USE_STL_CONTAINERS 1
        +
        3453 #ifdef VMA_IMPLEMENTATION
        +
        3454 #undef VMA_IMPLEMENTATION
        3455 
        -
        3456 /* Set this macro to 1 to make the library including and using STL containers:
        -
        3457 std::pair, std::vector, std::list, std::unordered_map.
        -
        3458 
        -
        3459 Set it to 0 or undefined to make the library using its own implementation of
        -
        3460 the containers.
        -
        3461 */
        -
        3462 #if VMA_USE_STL_CONTAINERS
        -
        3463  #define VMA_USE_STL_VECTOR 1
        -
        3464  #define VMA_USE_STL_UNORDERED_MAP 1
        -
        3465  #define VMA_USE_STL_LIST 1
        -
        3466 #endif
        -
        3467 
        -
        3468 #ifndef VMA_USE_STL_SHARED_MUTEX
        -
        3469  // Compiler conforms to C++17.
        -
        3470  #if __cplusplus >= 201703L
        -
        3471  #define VMA_USE_STL_SHARED_MUTEX 1
        -
        3472  // Visual studio defines __cplusplus properly only when passed additional parameter: /Zc:__cplusplus
        -
        3473  // Otherwise it's always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.
        -
        3474  // See: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
        -
        3475  #elif defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && __cplusplus == 199711L && _MSVC_LANG >= 201703L
        -
        3476  #define VMA_USE_STL_SHARED_MUTEX 1
        -
        3477  #else
        -
        3478  #define VMA_USE_STL_SHARED_MUTEX 0
        -
        3479  #endif
        -
        3480 #endif
        -
        3481 
        -
        3482 /*
        -
        3483 THESE INCLUDES ARE NOT ENABLED BY DEFAULT.
        -
        3484 Library has its own container implementation.
        -
        3485 */
        -
        3486 #if VMA_USE_STL_VECTOR
        -
        3487  #include <vector>
        -
        3488 #endif
        -
        3489 
        -
        3490 #if VMA_USE_STL_UNORDERED_MAP
        -
        3491  #include <unordered_map>
        -
        3492 #endif
        -
        3493 
        -
        3494 #if VMA_USE_STL_LIST
        -
        3495  #include <list>
        -
        3496 #endif
        -
        3497 
        -
        3498 /*
        -
        3499 Following headers are used in this CONFIGURATION section only, so feel free to
        -
        3500 remove them if not needed.
        -
        3501 */
        -
        3502 #include <cassert> // for assert
        -
        3503 #include <algorithm> // for min, max
        -
        3504 #include <mutex>
        -
        3505 
        -
        3506 #ifndef VMA_NULL
        -
        3507  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
        -
        3508  #define VMA_NULL nullptr
        -
        3509 #endif
        -
        3510 
        -
        3511 #if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
        -
        3512 #include <cstdlib>
        -
        3513 void *aligned_alloc(size_t alignment, size_t size)
        -
        3514 {
        -
        3515  // alignment must be >= sizeof(void*)
        -
        3516  if(alignment < sizeof(void*))
        -
        3517  {
        -
        3518  alignment = sizeof(void*);
        -
        3519  }
        +
        3456 #include <cstdint>
        +
        3457 #include <cstdlib>
        +
        3458 #include <cstring>
        +
        3459 
        +
        3460 /*******************************************************************************
        +
        3461 CONFIGURATION SECTION
        +
        3462 
        +
        3463 Define some of these macros before each #include of this header or change them
        +
        3464 here if you need other then default behavior depending on your environment.
        +
        3465 */
        +
        3466 
        +
        3467 /*
        +
        3468 Define this macro to 1 to make the library fetch pointers to Vulkan functions
        +
        3469 internally, like:
        +
        3470 
        +
        3471  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
        +
        3472 
        +
        3473 Define to 0 if you are going to provide you own pointers to Vulkan functions via
        +
        3474 VmaAllocatorCreateInfo::pVulkanFunctions.
        +
        3475 */
        +
        3476 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
        +
        3477 #define VMA_STATIC_VULKAN_FUNCTIONS 1
        +
        3478 #endif
        +
        3479 
        +
        3480 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
        +
        3481 //#define VMA_USE_STL_CONTAINERS 1
        +
        3482 
        +
        3483 /* Set this macro to 1 to make the library including and using STL containers:
        +
        3484 std::pair, std::vector, std::list, std::unordered_map.
        +
        3485 
        +
        3486 Set it to 0 or undefined to make the library using its own implementation of
        +
        3487 the containers.
        +
        3488 */
        +
        3489 #if VMA_USE_STL_CONTAINERS
        +
        3490  #define VMA_USE_STL_VECTOR 1
        +
        3491  #define VMA_USE_STL_UNORDERED_MAP 1
        +
        3492  #define VMA_USE_STL_LIST 1
        +
        3493 #endif
        +
        3494 
        +
        3495 #ifndef VMA_USE_STL_SHARED_MUTEX
        +
        3496  // Compiler conforms to C++17.
        +
        3497  #if __cplusplus >= 201703L
        +
        3498  #define VMA_USE_STL_SHARED_MUTEX 1
        +
        3499  // Visual studio defines __cplusplus properly only when passed additional parameter: /Zc:__cplusplus
        +
        3500  // Otherwise it's always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.
        +
        3501  // See: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
        +
        3502  #elif defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && __cplusplus == 199711L && _MSVC_LANG >= 201703L
        +
        3503  #define VMA_USE_STL_SHARED_MUTEX 1
        +
        3504  #else
        +
        3505  #define VMA_USE_STL_SHARED_MUTEX 0
        +
        3506  #endif
        +
        3507 #endif
        +
        3508 
        +
        3509 /*
        +
        3510 THESE INCLUDES ARE NOT ENABLED BY DEFAULT.
        +
        3511 Library has its own container implementation.
        +
        3512 */
        +
        3513 #if VMA_USE_STL_VECTOR
        +
        3514  #include <vector>
        +
        3515 #endif
        +
        3516 
        +
        3517 #if VMA_USE_STL_UNORDERED_MAP
        +
        3518  #include <unordered_map>
        +
        3519 #endif
        3520 
        -
        3521  return memalign(alignment, size);
        -
        3522 }
        -
        3523 #elif defined(__APPLE__) || defined(__ANDROID__) || (defined(__linux__) && defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC))
        -
        3524 #include <cstdlib>
        -
        3525 void *aligned_alloc(size_t alignment, size_t size)
        -
        3526 {
        -
        3527  // alignment must be >= sizeof(void*)
        -
        3528  if(alignment < sizeof(void*))
        -
        3529  {
        -
        3530  alignment = sizeof(void*);
        -
        3531  }
        +
        3521 #if VMA_USE_STL_LIST
        +
        3522  #include <list>
        +
        3523 #endif
        +
        3524 
        +
        3525 /*
        +
        3526 Following headers are used in this CONFIGURATION section only, so feel free to
        +
        3527 remove them if not needed.
        +
        3528 */
        +
        3529 #include <cassert> // for assert
        +
        3530 #include <algorithm> // for min, max
        +
        3531 #include <mutex>
        3532 
        -
        3533  void *pointer;
        -
        3534  if(posix_memalign(&pointer, alignment, size) == 0)
        -
        3535  return pointer;
        -
        3536  return VMA_NULL;
        -
        3537 }
        -
        3538 #endif
        -
        3539 
        -
        3540 // If your compiler is not compatible with C++11 and definition of
        -
        3541 // aligned_alloc() function is missing, uncommeting following line may help:
        -
        3542 
        -
        3543 //#include <malloc.h>
        -
        3544 
        -
        3545 // Normal assert to check for programmer's errors, especially in Debug configuration.
        -
        3546 #ifndef VMA_ASSERT
        -
        3547  #ifdef _DEBUG
        -
        3548  #define VMA_ASSERT(expr) assert(expr)
        -
        3549  #else
        -
        3550  #define VMA_ASSERT(expr)
        -
        3551  #endif
        -
        3552 #endif
        -
        3553 
        -
        3554 // Assert that will be called very often, like inside data structures e.g. operator[].
        -
        3555 // Making it non-empty can make program slow.
        -
        3556 #ifndef VMA_HEAVY_ASSERT
        -
        3557  #ifdef _DEBUG
        -
        3558  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
        -
        3559  #else
        -
        3560  #define VMA_HEAVY_ASSERT(expr)
        -
        3561  #endif
        -
        3562 #endif
        -
        3563 
        -
        3564 #ifndef VMA_ALIGN_OF
        -
        3565  #define VMA_ALIGN_OF(type) (__alignof(type))
        -
        3566 #endif
        -
        3567 
        -
        3568 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
        -
        3569  #if defined(_WIN32)
        -
        3570  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
        -
        3571  #else
        -
        3572  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
        -
        3573  #endif
        -
        3574 #endif
        -
        3575 
        -
        3576 #ifndef VMA_SYSTEM_FREE
        -
        3577  #if defined(_WIN32)
        -
        3578  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
        -
        3579  #else
        -
        3580  #define VMA_SYSTEM_FREE(ptr) free(ptr)
        -
        3581  #endif
        -
        3582 #endif
        -
        3583 
        -
        3584 #ifndef VMA_MIN
        -
        3585  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
        -
        3586 #endif
        -
        3587 
        -
        3588 #ifndef VMA_MAX
        -
        3589  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
        -
        3590 #endif
        -
        3591 
        -
        3592 #ifndef VMA_SWAP
        -
        3593  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
        -
        3594 #endif
        -
        3595 
        -
        3596 #ifndef VMA_SORT
        -
        3597  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
        -
        3598 #endif
        -
        3599 
        -
        3600 #ifndef VMA_DEBUG_LOG
        -
        3601  #define VMA_DEBUG_LOG(format, ...)
        -
        3602  /*
        -
        3603  #define VMA_DEBUG_LOG(format, ...) do { \
        -
        3604  printf(format, __VA_ARGS__); \
        -
        3605  printf("\n"); \
        -
        3606  } while(false)
        -
        3607  */
        -
        3608 #endif
        -
        3609 
        -
        3610 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
        -
        3611 #if VMA_STATS_STRING_ENABLED
        -
        3612  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
        -
        3613  {
        -
        3614  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
        -
        3615  }
        -
        3616  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
        -
        3617  {
        -
        3618  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
        -
        3619  }
        -
        3620  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
        -
        3621  {
        -
        3622  snprintf(outStr, strLen, "%p", ptr);
        -
        3623  }
        -
        3624 #endif
        -
        3625 
        -
        3626 #ifndef VMA_MUTEX
        -
        3627  class VmaMutex
        -
        3628  {
        -
        3629  public:
        -
        3630  void Lock() { m_Mutex.lock(); }
        -
        3631  void Unlock() { m_Mutex.unlock(); }
        -
        3632  private:
        -
        3633  std::mutex m_Mutex;
        -
        3634  };
        -
        3635  #define VMA_MUTEX VmaMutex
        -
        3636 #endif
        -
        3637 
        -
        3638 // Read-write mutex, where "read" is shared access, "write" is exclusive access.
        -
        3639 #ifndef VMA_RW_MUTEX
        -
        3640  #if VMA_USE_STL_SHARED_MUTEX
        -
        3641  // Use std::shared_mutex from C++17.
        -
        3642  #include <shared_mutex>
        -
        3643  class VmaRWMutex
        -
        3644  {
        -
        3645  public:
        -
        3646  void LockRead() { m_Mutex.lock_shared(); }
        -
        3647  void UnlockRead() { m_Mutex.unlock_shared(); }
        -
        3648  void LockWrite() { m_Mutex.lock(); }
        -
        3649  void UnlockWrite() { m_Mutex.unlock(); }
        -
        3650  private:
        -
        3651  std::shared_mutex m_Mutex;
        -
        3652  };
        -
        3653  #define VMA_RW_MUTEX VmaRWMutex
        -
        3654  #elif defined(_WIN32) && defined(WINVER) && WINVER >= 0x0600
        -
        3655  // Use SRWLOCK from WinAPI.
        -
        3656  // Minimum supported client = Windows Vista, server = Windows Server 2008.
        -
        3657  class VmaRWMutex
        -
        3658  {
        -
        3659  public:
        -
        3660  VmaRWMutex() { InitializeSRWLock(&m_Lock); }
        -
        3661  void LockRead() { AcquireSRWLockShared(&m_Lock); }
        -
        3662  void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
        -
        3663  void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
        -
        3664  void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
        -
        3665  private:
        -
        3666  SRWLOCK m_Lock;
        -
        3667  };
        -
        3668  #define VMA_RW_MUTEX VmaRWMutex
        -
        3669  #else
        -
        3670  // Less efficient fallback: Use normal mutex.
        -
        3671  class VmaRWMutex
        -
        3672  {
        -
        3673  public:
        -
        3674  void LockRead() { m_Mutex.Lock(); }
        -
        3675  void UnlockRead() { m_Mutex.Unlock(); }
        -
        3676  void LockWrite() { m_Mutex.Lock(); }
        -
        3677  void UnlockWrite() { m_Mutex.Unlock(); }
        -
        3678  private:
        -
        3679  VMA_MUTEX m_Mutex;
        -
        3680  };
        -
        3681  #define VMA_RW_MUTEX VmaRWMutex
        -
        3682  #endif // #if VMA_USE_STL_SHARED_MUTEX
        -
        3683 #endif // #ifndef VMA_RW_MUTEX
        -
        3684 
        -
        3685 /*
        -
        3686 If providing your own implementation, you need to implement a subset of std::atomic.
        -
        3687 */
        -
        3688 #ifndef VMA_ATOMIC_UINT32
        -
        3689  #include <atomic>
        -
        3690  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
        -
        3691 #endif
        -
        3692 
        -
        3693 #ifndef VMA_ATOMIC_UINT64
        -
        3694  #include <atomic>
        -
        3695  #define VMA_ATOMIC_UINT64 std::atomic<uint64_t>
        -
        3696 #endif
        -
        3697 
        -
        3698 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
        -
        3699 
        -
        3703  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
        -
        3704 #endif
        -
        3705 
        -
        3706 #ifndef VMA_DEBUG_ALIGNMENT
        -
        3707 
        -
        3711  #define VMA_DEBUG_ALIGNMENT (1)
        -
        3712 #endif
        -
        3713 
        -
        3714 #ifndef VMA_DEBUG_MARGIN
        -
        3715 
        -
        3719  #define VMA_DEBUG_MARGIN (0)
        -
        3720 #endif
        -
        3721 
        -
        3722 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
        -
        3723 
        -
        3727  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
        -
        3728 #endif
        -
        3729 
        -
        3730 #ifndef VMA_DEBUG_DETECT_CORRUPTION
        -
        3731 
        -
        3736  #define VMA_DEBUG_DETECT_CORRUPTION (0)
        -
        3737 #endif
        -
        3738 
        -
        3739 #ifndef VMA_DEBUG_GLOBAL_MUTEX
        +
        3533 #ifndef VMA_NULL
        +
        3534  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
        +
        3535  #define VMA_NULL nullptr
        +
        3536 #endif
        +
        3537 
        +
        3538 #if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
        +
        3539 #include <cstdlib>
        +
        3540 void *aligned_alloc(size_t alignment, size_t size)
        +
        3541 {
        +
        3542  // alignment must be >= sizeof(void*)
        +
        3543  if(alignment < sizeof(void*))
        +
        3544  {
        +
        3545  alignment = sizeof(void*);
        +
        3546  }
        +
        3547 
        +
        3548  return memalign(alignment, size);
        +
        3549 }
        +
        3550 #elif defined(__APPLE__) || defined(__ANDROID__) || (defined(__linux__) && defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC))
        +
        3551 #include <cstdlib>
        +
        3552 void *aligned_alloc(size_t alignment, size_t size)
        +
        3553 {
        +
        3554  // alignment must be >= sizeof(void*)
        +
        3555  if(alignment < sizeof(void*))
        +
        3556  {
        +
        3557  alignment = sizeof(void*);
        +
        3558  }
        +
        3559 
        +
        3560  void *pointer;
        +
        3561  if(posix_memalign(&pointer, alignment, size) == 0)
        +
        3562  return pointer;
        +
        3563  return VMA_NULL;
        +
        3564 }
        +
        3565 #endif
        +
        3566 
        +
        3567 // If your compiler is not compatible with C++11 and definition of
        +
        3568 // aligned_alloc() function is missing, uncommeting following line may help:
        +
        3569 
        +
        3570 //#include <malloc.h>
        +
        3571 
        +
        3572 // Normal assert to check for programmer's errors, especially in Debug configuration.
        +
        3573 #ifndef VMA_ASSERT
        +
        3574  #ifdef _DEBUG
        +
        3575  #define VMA_ASSERT(expr) assert(expr)
        +
        3576  #else
        +
        3577  #define VMA_ASSERT(expr)
        +
        3578  #endif
        +
        3579 #endif
        +
        3580 
        +
        3581 // Assert that will be called very often, like inside data structures e.g. operator[].
        +
        3582 // Making it non-empty can make program slow.
        +
        3583 #ifndef VMA_HEAVY_ASSERT
        +
        3584  #ifdef _DEBUG
        +
        3585  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
        +
        3586  #else
        +
        3587  #define VMA_HEAVY_ASSERT(expr)
        +
        3588  #endif
        +
        3589 #endif
        +
        3590 
        +
        3591 #ifndef VMA_ALIGN_OF
        +
        3592  #define VMA_ALIGN_OF(type) (__alignof(type))
        +
        3593 #endif
        +
        3594 
        +
        3595 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
        +
        3596  #if defined(_WIN32)
        +
        3597  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
        +
        3598  #else
        +
        3599  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
        +
        3600  #endif
        +
        3601 #endif
        +
        3602 
        +
        3603 #ifndef VMA_SYSTEM_FREE
        +
        3604  #if defined(_WIN32)
        +
        3605  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
        +
        3606  #else
        +
        3607  #define VMA_SYSTEM_FREE(ptr) free(ptr)
        +
        3608  #endif
        +
        3609 #endif
        +
        3610 
        +
        3611 #ifndef VMA_MIN
        +
        3612  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
        +
        3613 #endif
        +
        3614 
        +
        3615 #ifndef VMA_MAX
        +
        3616  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
        +
        3617 #endif
        +
        3618 
        +
        3619 #ifndef VMA_SWAP
        +
        3620  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
        +
        3621 #endif
        +
        3622 
        +
        3623 #ifndef VMA_SORT
        +
        3624  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
        +
        3625 #endif
        +
        3626 
        +
        3627 #ifndef VMA_DEBUG_LOG
        +
        3628  #define VMA_DEBUG_LOG(format, ...)
        +
        3629  /*
        +
        3630  #define VMA_DEBUG_LOG(format, ...) do { \
        +
        3631  printf(format, __VA_ARGS__); \
        +
        3632  printf("\n"); \
        +
        3633  } while(false)
        +
        3634  */
        +
        3635 #endif
        +
        3636 
        +
        3637 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
        +
        3638 #if VMA_STATS_STRING_ENABLED
        +
        3639  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
        +
        3640  {
        +
        3641  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
        +
        3642  }
        +
        3643  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
        +
        3644  {
        +
        3645  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
        +
        3646  }
        +
        3647  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
        +
        3648  {
        +
        3649  snprintf(outStr, strLen, "%p", ptr);
        +
        3650  }
        +
        3651 #endif
        +
        3652 
        +
        3653 #ifndef VMA_MUTEX
        +
        3654  class VmaMutex
        +
        3655  {
        +
        3656  public:
        +
        3657  void Lock() { m_Mutex.lock(); }
        +
        3658  void Unlock() { m_Mutex.unlock(); }
        +
        3659  private:
        +
        3660  std::mutex m_Mutex;
        +
        3661  };
        +
        3662  #define VMA_MUTEX VmaMutex
        +
        3663 #endif
        +
        3664 
        +
        3665 // Read-write mutex, where "read" is shared access, "write" is exclusive access.
        +
        3666 #ifndef VMA_RW_MUTEX
        +
        3667  #if VMA_USE_STL_SHARED_MUTEX
        +
        3668  // Use std::shared_mutex from C++17.
        +
        3669  #include <shared_mutex>
        +
        3670  class VmaRWMutex
        +
        3671  {
        +
        3672  public:
        +
        3673  void LockRead() { m_Mutex.lock_shared(); }
        +
        3674  void UnlockRead() { m_Mutex.unlock_shared(); }
        +
        3675  void LockWrite() { m_Mutex.lock(); }
        +
        3676  void UnlockWrite() { m_Mutex.unlock(); }
        +
        3677  private:
        +
        3678  std::shared_mutex m_Mutex;
        +
        3679  };
        +
        3680  #define VMA_RW_MUTEX VmaRWMutex
        +
        3681  #elif defined(_WIN32) && defined(WINVER) && WINVER >= 0x0600
        +
        3682  // Use SRWLOCK from WinAPI.
        +
        3683  // Minimum supported client = Windows Vista, server = Windows Server 2008.
        +
        3684  class VmaRWMutex
        +
        3685  {
        +
        3686  public:
        +
        3687  VmaRWMutex() { InitializeSRWLock(&m_Lock); }
        +
        3688  void LockRead() { AcquireSRWLockShared(&m_Lock); }
        +
        3689  void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
        +
        3690  void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
        +
        3691  void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
        +
        3692  private:
        +
        3693  SRWLOCK m_Lock;
        +
        3694  };
        +
        3695  #define VMA_RW_MUTEX VmaRWMutex
        +
        3696  #else
        +
        3697  // Less efficient fallback: Use normal mutex.
        +
        3698  class VmaRWMutex
        +
        3699  {
        +
        3700  public:
        +
        3701  void LockRead() { m_Mutex.Lock(); }
        +
        3702  void UnlockRead() { m_Mutex.Unlock(); }
        +
        3703  void LockWrite() { m_Mutex.Lock(); }
        +
        3704  void UnlockWrite() { m_Mutex.Unlock(); }
        +
        3705  private:
        +
        3706  VMA_MUTEX m_Mutex;
        +
        3707  };
        +
        3708  #define VMA_RW_MUTEX VmaRWMutex
        +
        3709  #endif // #if VMA_USE_STL_SHARED_MUTEX
        +
        3710 #endif // #ifndef VMA_RW_MUTEX
        +
        3711 
        +
        3712 /*
        +
        3713 If providing your own implementation, you need to implement a subset of std::atomic.
        +
        3714 */
        +
        3715 #ifndef VMA_ATOMIC_UINT32
        +
        3716  #include <atomic>
        +
        3717  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
        +
        3718 #endif
        +
        3719 
        +
        3720 #ifndef VMA_ATOMIC_UINT64
        +
        3721  #include <atomic>
        +
        3722  #define VMA_ATOMIC_UINT64 std::atomic<uint64_t>
        +
        3723 #endif
        +
        3724 
        +
        3725 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
        +
        3726 
        +
        3730  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
        +
        3731 #endif
        +
        3732 
        +
        3733 #ifndef VMA_DEBUG_ALIGNMENT
        +
        3734 
        +
        3738  #define VMA_DEBUG_ALIGNMENT (1)
        +
        3739 #endif
        3740 
        -
        3744  #define VMA_DEBUG_GLOBAL_MUTEX (0)
        -
        3745 #endif
        -
        3746 
        -
        3747 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
        +
        3741 #ifndef VMA_DEBUG_MARGIN
        +
        3742 
        +
        3746  #define VMA_DEBUG_MARGIN (0)
        +
        3747 #endif
        3748 
        -
        3752  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
        -
        3753 #endif
        -
        3754 
        -
        3755 #ifndef VMA_SMALL_HEAP_MAX_SIZE
        -
        3756  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
        -
        3758 #endif
        -
        3759 
        -
        3760 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
        -
        3761  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
        -
        3763 #endif
        -
        3764 
        -
        3765 #ifndef VMA_CLASS_NO_COPY
        -
        3766  #define VMA_CLASS_NO_COPY(className) \
        -
        3767  private: \
        -
        3768  className(const className&) = delete; \
        -
        3769  className& operator=(const className&) = delete;
        -
        3770 #endif
        -
        3771 
        -
        3772 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
        +
        3749 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
        +
        3750 
        +
        3754  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
        +
        3755 #endif
        +
        3756 
        +
        3757 #ifndef VMA_DEBUG_DETECT_CORRUPTION
        +
        3758 
        +
        3763  #define VMA_DEBUG_DETECT_CORRUPTION (0)
        +
        3764 #endif
        +
        3765 
        +
        3766 #ifndef VMA_DEBUG_GLOBAL_MUTEX
        +
        3767 
        +
        3771  #define VMA_DEBUG_GLOBAL_MUTEX (0)
        +
        3772 #endif
        3773 
        -
        3774 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
        -
        3775 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
        -
        3776 
        -
        3777 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
        -
        3778 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
        -
        3779 
        -
        3780 /*******************************************************************************
        -
        3781 END OF CONFIGURATION
        -
        3782 */
        -
        3783 
        -
        3784 static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
        -
        3785 
        -
        3786 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
        -
        3787  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
        -
        3788 
        -
        3789 // Returns number of bits set to 1 in (v).
        -
        3790 static inline uint32_t VmaCountBitsSet(uint32_t v)
        -
        3791 {
        -
        3792  uint32_t c = v - ((v >> 1) & 0x55555555);
        -
        3793  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
        -
        3794  c = ((c >> 4) + c) & 0x0F0F0F0F;
        -
        3795  c = ((c >> 8) + c) & 0x00FF00FF;
        -
        3796  c = ((c >> 16) + c) & 0x0000FFFF;
        -
        3797  return c;
        -
        3798 }
        -
        3799 
        -
        3800 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
        -
        3801 // Use types like uint32_t, uint64_t as T.
        -
        3802 template <typename T>
        -
        3803 static inline T VmaAlignUp(T val, T align)
        -
        3804 {
        -
        3805  return (val + align - 1) / align * align;
        -
        3806 }
        -
        3807 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
        -
        3808 // Use types like uint32_t, uint64_t as T.
        -
        3809 template <typename T>
        -
        3810 static inline T VmaAlignDown(T val, T align)
        -
        3811 {
        -
        3812  return val / align * align;
        -
        3813 }
        -
        3814 
        -
        3815 // Division with mathematical rounding to nearest number.
        -
        3816 template <typename T>
        -
        3817 static inline T VmaRoundDiv(T x, T y)
        +
        3774 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
        +
        3775 
        +
        3779  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
        +
        3780 #endif
        +
        3781 
        +
        3782 #ifndef VMA_SMALL_HEAP_MAX_SIZE
        +
        3783  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
        +
        3785 #endif
        +
        3786 
        +
        3787 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
        +
        3788  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
        +
        3790 #endif
        +
        3791 
        +
        3792 #ifndef VMA_CLASS_NO_COPY
        +
        3793  #define VMA_CLASS_NO_COPY(className) \
        +
        3794  private: \
        +
        3795  className(const className&) = delete; \
        +
        3796  className& operator=(const className&) = delete;
        +
        3797 #endif
        +
        3798 
        +
        3799 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
        +
        3800 
        +
        3801 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
        +
        3802 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
        +
        3803 
        +
        3804 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
        +
        3805 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
        +
        3806 
        +
        3807 /*******************************************************************************
        +
        3808 END OF CONFIGURATION
        +
        3809 */
        +
        3810 
        +
        3811 static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
        +
        3812 
        +
        3813 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
        +
        3814  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
        +
        3815 
        +
        3816 // Returns number of bits set to 1 in (v).
        +
        3817 static inline uint32_t VmaCountBitsSet(uint32_t v)
        3818 {
        -
        3819  return (x + (y / (T)2)) / y;
        -
        3820 }
        -
        3821 
        -
        3822 /*
        -
        3823 Returns true if given number is a power of two.
        -
        3824 T must be unsigned integer number or signed integer but always nonnegative.
        -
        3825 For 0 returns true.
        -
        3826 */
        -
        3827 template <typename T>
        -
        3828 inline bool VmaIsPow2(T x)
        -
        3829 {
        -
        3830  return (x & (x-1)) == 0;
        -
        3831 }
        -
        3832 
        -
        3833 // Returns smallest power of 2 greater or equal to v.
        -
        3834 static inline uint32_t VmaNextPow2(uint32_t v)
        -
        3835 {
        -
        3836  v--;
        -
        3837  v |= v >> 1;
        -
        3838  v |= v >> 2;
        -
        3839  v |= v >> 4;
        -
        3840  v |= v >> 8;
        -
        3841  v |= v >> 16;
        -
        3842  v++;
        -
        3843  return v;
        -
        3844 }
        -
        3845 static inline uint64_t VmaNextPow2(uint64_t v)
        -
        3846 {
        -
        3847  v--;
        -
        3848  v |= v >> 1;
        -
        3849  v |= v >> 2;
        -
        3850  v |= v >> 4;
        -
        3851  v |= v >> 8;
        -
        3852  v |= v >> 16;
        -
        3853  v |= v >> 32;
        -
        3854  v++;
        -
        3855  return v;
        -
        3856 }
        -
        3857 
        -
        3858 // Returns largest power of 2 less or equal to v.
        -
        3859 static inline uint32_t VmaPrevPow2(uint32_t v)
        -
        3860 {
        -
        3861  v |= v >> 1;
        -
        3862  v |= v >> 2;
        -
        3863  v |= v >> 4;
        -
        3864  v |= v >> 8;
        -
        3865  v |= v >> 16;
        -
        3866  v = v ^ (v >> 1);
        -
        3867  return v;
        -
        3868 }
        -
        3869 static inline uint64_t VmaPrevPow2(uint64_t v)
        -
        3870 {
        -
        3871  v |= v >> 1;
        -
        3872  v |= v >> 2;
        -
        3873  v |= v >> 4;
        -
        3874  v |= v >> 8;
        -
        3875  v |= v >> 16;
        -
        3876  v |= v >> 32;
        -
        3877  v = v ^ (v >> 1);
        -
        3878  return v;
        -
        3879 }
        -
        3880 
        -
        3881 static inline bool VmaStrIsEmpty(const char* pStr)
        -
        3882 {
        -
        3883  return pStr == VMA_NULL || *pStr == '\0';
        -
        3884 }
        -
        3885 
        -
        3886 #if VMA_STATS_STRING_ENABLED
        -
        3887 
        -
        3888 static const char* VmaAlgorithmToStr(uint32_t algorithm)
        -
        3889 {
        -
        3890  switch(algorithm)
        -
        3891  {
        -
        3892  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
        -
        3893  return "Linear";
        -
        3894  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
        -
        3895  return "Buddy";
        -
        3896  case 0:
        -
        3897  return "Default";
        -
        3898  default:
        -
        3899  VMA_ASSERT(0);
        -
        3900  return "";
        -
        3901  }
        -
        3902 }
        -
        3903 
        -
        3904 #endif // #if VMA_STATS_STRING_ENABLED
        -
        3905 
        -
        3906 #ifndef VMA_SORT
        +
        3819  uint32_t c = v - ((v >> 1) & 0x55555555);
        +
        3820  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
        +
        3821  c = ((c >> 4) + c) & 0x0F0F0F0F;
        +
        3822  c = ((c >> 8) + c) & 0x00FF00FF;
        +
        3823  c = ((c >> 16) + c) & 0x0000FFFF;
        +
        3824  return c;
        +
        3825 }
        +
        3826 
        +
        3827 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
        +
        3828 // Use types like uint32_t, uint64_t as T.
        +
        3829 template <typename T>
        +
        3830 static inline T VmaAlignUp(T val, T align)
        +
        3831 {
        +
        3832  return (val + align - 1) / align * align;
        +
        3833 }
        +
        3834 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
        +
        3835 // Use types like uint32_t, uint64_t as T.
        +
        3836 template <typename T>
        +
        3837 static inline T VmaAlignDown(T val, T align)
        +
        3838 {
        +
        3839  return val / align * align;
        +
        3840 }
        +
        3841 
        +
        3842 // Division with mathematical rounding to nearest number.
        +
        3843 template <typename T>
        +
        3844 static inline T VmaRoundDiv(T x, T y)
        +
        3845 {
        +
        3846  return (x + (y / (T)2)) / y;
        +
        3847 }
        +
        3848 
        +
        3849 /*
        +
        3850 Returns true if given number is a power of two.
        +
        3851 T must be unsigned integer number or signed integer but always nonnegative.
        +
        3852 For 0 returns true.
        +
        3853 */
        +
        3854 template <typename T>
        +
        3855 inline bool VmaIsPow2(T x)
        +
        3856 {
        +
        3857  return (x & (x-1)) == 0;
        +
        3858 }
        +
        3859 
        +
        3860 // Returns smallest power of 2 greater or equal to v.
        +
        3861 static inline uint32_t VmaNextPow2(uint32_t v)
        +
        3862 {
        +
        3863  v--;
        +
        3864  v |= v >> 1;
        +
        3865  v |= v >> 2;
        +
        3866  v |= v >> 4;
        +
        3867  v |= v >> 8;
        +
        3868  v |= v >> 16;
        +
        3869  v++;
        +
        3870  return v;
        +
        3871 }
        +
        3872 static inline uint64_t VmaNextPow2(uint64_t v)
        +
        3873 {
        +
        3874  v--;
        +
        3875  v |= v >> 1;
        +
        3876  v |= v >> 2;
        +
        3877  v |= v >> 4;
        +
        3878  v |= v >> 8;
        +
        3879  v |= v >> 16;
        +
        3880  v |= v >> 32;
        +
        3881  v++;
        +
        3882  return v;
        +
        3883 }
        +
        3884 
        +
        3885 // Returns largest power of 2 less or equal to v.
        +
        3886 static inline uint32_t VmaPrevPow2(uint32_t v)
        +
        3887 {
        +
        3888  v |= v >> 1;
        +
        3889  v |= v >> 2;
        +
        3890  v |= v >> 4;
        +
        3891  v |= v >> 8;
        +
        3892  v |= v >> 16;
        +
        3893  v = v ^ (v >> 1);
        +
        3894  return v;
        +
        3895 }
        +
        3896 static inline uint64_t VmaPrevPow2(uint64_t v)
        +
        3897 {
        +
        3898  v |= v >> 1;
        +
        3899  v |= v >> 2;
        +
        3900  v |= v >> 4;
        +
        3901  v |= v >> 8;
        +
        3902  v |= v >> 16;
        +
        3903  v |= v >> 32;
        +
        3904  v = v ^ (v >> 1);
        +
        3905  return v;
        +
        3906 }
        3907 
        -
        3908 template<typename Iterator, typename Compare>
        -
        3909 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
        -
        3910 {
        -
        3911  Iterator centerValue = end; --centerValue;
        -
        3912  Iterator insertIndex = beg;
        -
        3913  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
        -
        3914  {
        -
        3915  if(cmp(*memTypeIndex, *centerValue))
        -
        3916  {
        -
        3917  if(insertIndex != memTypeIndex)
        -
        3918  {
        -
        3919  VMA_SWAP(*memTypeIndex, *insertIndex);
        -
        3920  }
        -
        3921  ++insertIndex;
        -
        3922  }
        -
        3923  }
        -
        3924  if(insertIndex != centerValue)
        -
        3925  {
        -
        3926  VMA_SWAP(*insertIndex, *centerValue);
        -
        3927  }
        -
        3928  return insertIndex;
        +
        3908 static inline bool VmaStrIsEmpty(const char* pStr)
        +
        3909 {
        +
        3910  return pStr == VMA_NULL || *pStr == '\0';
        +
        3911 }
        +
        3912 
        +
        3913 #if VMA_STATS_STRING_ENABLED
        +
        3914 
        +
        3915 static const char* VmaAlgorithmToStr(uint32_t algorithm)
        +
        3916 {
        +
        3917  switch(algorithm)
        +
        3918  {
        +
        3919  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
        +
        3920  return "Linear";
        +
        3921  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
        +
        3922  return "Buddy";
        +
        3923  case 0:
        +
        3924  return "Default";
        +
        3925  default:
        +
        3926  VMA_ASSERT(0);
        +
        3927  return "";
        +
        3928  }
        3929 }
        3930 
        -
        3931 template<typename Iterator, typename Compare>
        -
        3932 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
        -
        3933 {
        -
        3934  if(beg < end)
        -
        3935  {
        -
        3936  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
        -
        3937  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
        -
        3938  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
        -
        3939  }
        -
        3940 }
        -
        3941 
        -
        3942 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
        -
        3943 
        -
        3944 #endif // #ifndef VMA_SORT
        -
        3945 
        -
        3946 /*
        -
        3947 Returns true if two memory blocks occupy overlapping pages.
        -
        3948 ResourceA must be in less memory offset than ResourceB.
        -
        3949 
        -
        3950 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
        -
        3951 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
        -
        3952 */
        -
        3953 static inline bool VmaBlocksOnSamePage(
        -
        3954  VkDeviceSize resourceAOffset,
        -
        3955  VkDeviceSize resourceASize,
        -
        3956  VkDeviceSize resourceBOffset,
        -
        3957  VkDeviceSize pageSize)
        -
        3958 {
        -
        3959  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
        -
        3960  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
        -
        3961  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
        -
        3962  VkDeviceSize resourceBStart = resourceBOffset;
        -
        3963  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
        -
        3964  return resourceAEndPage == resourceBStartPage;
        -
        3965 }
        -
        3966 
        -
        3967 enum VmaSuballocationType
        -
        3968 {
        -
        3969  VMA_SUBALLOCATION_TYPE_FREE = 0,
        -
        3970  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
        -
        3971  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
        -
        3972  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
        -
        3973  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
        -
        3974  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
        -
        3975  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
        -
        3976 };
        -
        3977 
        -
        3978 /*
        -
        3979 Returns true if given suballocation types could conflict and must respect
        -
        3980 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
        -
        3981 or linear image and another one is optimal image. If type is unknown, behave
        -
        3982 conservatively.
        -
        3983 */
        -
        3984 static inline bool VmaIsBufferImageGranularityConflict(
        -
        3985  VmaSuballocationType suballocType1,
        -
        3986  VmaSuballocationType suballocType2)
        -
        3987 {
        -
        3988  if(suballocType1 > suballocType2)
        -
        3989  {
        -
        3990  VMA_SWAP(suballocType1, suballocType2);
        -
        3991  }
        -
        3992 
        -
        3993  switch(suballocType1)
        -
        3994  {
        -
        3995  case VMA_SUBALLOCATION_TYPE_FREE:
        -
        3996  return false;
        -
        3997  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
        -
        3998  return true;
        -
        3999  case VMA_SUBALLOCATION_TYPE_BUFFER:
        -
        4000  return
        -
        4001  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        -
        4002  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        -
        4003  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
        -
        4004  return
        -
        4005  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        -
        4006  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
        -
        4007  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        -
        4008  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
        -
        4009  return
        -
        4010  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        -
        4011  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
        -
        4012  return false;
        -
        4013  default:
        -
        4014  VMA_ASSERT(0);
        -
        4015  return true;
        -
        4016  }
        -
        4017 }
        -
        4018 
        -
        4019 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
        -
        4020 {
        -
        4021 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
        -
        4022  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
        -
        4023  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        -
        4024  for(size_t i = 0; i < numberCount; ++i, ++pDst)
        -
        4025  {
        -
        4026  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
        -
        4027  }
        -
        4028 #else
        -
        4029  // no-op
        -
        4030 #endif
        -
        4031 }
        -
        4032 
        -
        4033 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
        -
        4034 {
        -
        4035 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
        -
        4036  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
        -
        4037  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        -
        4038  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
        -
        4039  {
        -
        4040  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
        -
        4041  {
        -
        4042  return false;
        -
        4043  }
        -
        4044  }
        -
        4045 #endif
        -
        4046  return true;
        -
        4047 }
        -
        4048 
        -
        4049 /*
        -
        4050 Fills structure with parameters of an example buffer to be used for transfers
        -
        4051 during GPU memory defragmentation.
        -
        4052 */
        -
        4053 static void VmaFillGpuDefragmentationBufferCreateInfo(VkBufferCreateInfo& outBufCreateInfo)
        -
        4054 {
        -
        4055  memset(&outBufCreateInfo, 0, sizeof(outBufCreateInfo));
        -
        4056  outBufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
        -
        4057  outBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
        -
        4058  outBufCreateInfo.size = (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE; // Example size.
        -
        4059 }
        -
        4060 
        -
        4061 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
        -
        4062 struct VmaMutexLock
        -
        4063 {
        -
        4064  VMA_CLASS_NO_COPY(VmaMutexLock)
        -
        4065 public:
        -
        4066  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
        -
        4067  m_pMutex(useMutex ? &mutex : VMA_NULL)
        -
        4068  { if(m_pMutex) { m_pMutex->Lock(); } }
        -
        4069  ~VmaMutexLock()
        -
        4070  { if(m_pMutex) { m_pMutex->Unlock(); } }
        -
        4071 private:
        -
        4072  VMA_MUTEX* m_pMutex;
        -
        4073 };
        -
        4074 
        -
        4075 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
        -
        4076 struct VmaMutexLockRead
        -
        4077 {
        -
        4078  VMA_CLASS_NO_COPY(VmaMutexLockRead)
        -
        4079 public:
        -
        4080  VmaMutexLockRead(VMA_RW_MUTEX& mutex, bool useMutex) :
        -
        4081  m_pMutex(useMutex ? &mutex : VMA_NULL)
        -
        4082  { if(m_pMutex) { m_pMutex->LockRead(); } }
        -
        4083  ~VmaMutexLockRead() { if(m_pMutex) { m_pMutex->UnlockRead(); } }
        -
        4084 private:
        -
        4085  VMA_RW_MUTEX* m_pMutex;
        -
        4086 };
        +
        3931 #endif // #if VMA_STATS_STRING_ENABLED
        +
        3932 
        +
        3933 #ifndef VMA_SORT
        +
        3934 
        +
        3935 template<typename Iterator, typename Compare>
        +
        3936 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
        +
        3937 {
        +
        3938  Iterator centerValue = end; --centerValue;
        +
        3939  Iterator insertIndex = beg;
        +
        3940  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
        +
        3941  {
        +
        3942  if(cmp(*memTypeIndex, *centerValue))
        +
        3943  {
        +
        3944  if(insertIndex != memTypeIndex)
        +
        3945  {
        +
        3946  VMA_SWAP(*memTypeIndex, *insertIndex);
        +
        3947  }
        +
        3948  ++insertIndex;
        +
        3949  }
        +
        3950  }
        +
        3951  if(insertIndex != centerValue)
        +
        3952  {
        +
        3953  VMA_SWAP(*insertIndex, *centerValue);
        +
        3954  }
        +
        3955  return insertIndex;
        +
        3956 }
        +
        3957 
        +
        3958 template<typename Iterator, typename Compare>
        +
        3959 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
        +
        3960 {
        +
        3961  if(beg < end)
        +
        3962  {
        +
        3963  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
        +
        3964  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
        +
        3965  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
        +
        3966  }
        +
        3967 }
        +
        3968 
        +
        3969 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
        +
        3970 
        +
        3971 #endif // #ifndef VMA_SORT
        +
        3972 
        +
        3973 /*
        +
        3974 Returns true if two memory blocks occupy overlapping pages.
        +
        3975 ResourceA must be in less memory offset than ResourceB.
        +
        3976 
        +
        3977 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
        +
        3978 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
        +
        3979 */
        +
        3980 static inline bool VmaBlocksOnSamePage(
        +
        3981  VkDeviceSize resourceAOffset,
        +
        3982  VkDeviceSize resourceASize,
        +
        3983  VkDeviceSize resourceBOffset,
        +
        3984  VkDeviceSize pageSize)
        +
        3985 {
        +
        3986  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
        +
        3987  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
        +
        3988  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
        +
        3989  VkDeviceSize resourceBStart = resourceBOffset;
        +
        3990  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
        +
        3991  return resourceAEndPage == resourceBStartPage;
        +
        3992 }
        +
        3993 
        +
        3994 enum VmaSuballocationType
        +
        3995 {
        +
        3996  VMA_SUBALLOCATION_TYPE_FREE = 0,
        +
        3997  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
        +
        3998  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
        +
        3999  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
        +
        4000  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
        +
        4001  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
        +
        4002  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
        +
        4003 };
        +
        4004 
        +
        4005 /*
        +
        4006 Returns true if given suballocation types could conflict and must respect
        +
        4007 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
        +
        4008 or linear image and another one is optimal image. If type is unknown, behave
        +
        4009 conservatively.
        +
        4010 */
        +
        4011 static inline bool VmaIsBufferImageGranularityConflict(
        +
        4012  VmaSuballocationType suballocType1,
        +
        4013  VmaSuballocationType suballocType2)
        +
        4014 {
        +
        4015  if(suballocType1 > suballocType2)
        +
        4016  {
        +
        4017  VMA_SWAP(suballocType1, suballocType2);
        +
        4018  }
        +
        4019 
        +
        4020  switch(suballocType1)
        +
        4021  {
        +
        4022  case VMA_SUBALLOCATION_TYPE_FREE:
        +
        4023  return false;
        +
        4024  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
        +
        4025  return true;
        +
        4026  case VMA_SUBALLOCATION_TYPE_BUFFER:
        +
        4027  return
        +
        4028  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        +
        4029  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        +
        4030  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
        +
        4031  return
        +
        4032  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        +
        4033  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
        +
        4034  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        +
        4035  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
        +
        4036  return
        +
        4037  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        +
        4038  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
        +
        4039  return false;
        +
        4040  default:
        +
        4041  VMA_ASSERT(0);
        +
        4042  return true;
        +
        4043  }
        +
        4044 }
        +
        4045 
        +
        4046 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
        +
        4047 {
        +
        4048 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
        +
        4049  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
        +
        4050  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        +
        4051  for(size_t i = 0; i < numberCount; ++i, ++pDst)
        +
        4052  {
        +
        4053  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
        +
        4054  }
        +
        4055 #else
        +
        4056  // no-op
        +
        4057 #endif
        +
        4058 }
        +
        4059 
        +
        4060 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
        +
        4061 {
        +
        4062 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
        +
        4063  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
        +
        4064  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        +
        4065  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
        +
        4066  {
        +
        4067  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
        +
        4068  {
        +
        4069  return false;
        +
        4070  }
        +
        4071  }
        +
        4072 #endif
        +
        4073  return true;
        +
        4074 }
        +
        4075 
        +
        4076 /*
        +
        4077 Fills structure with parameters of an example buffer to be used for transfers
        +
        4078 during GPU memory defragmentation.
        +
        4079 */
        +
        4080 static void VmaFillGpuDefragmentationBufferCreateInfo(VkBufferCreateInfo& outBufCreateInfo)
        +
        4081 {
        +
        4082  memset(&outBufCreateInfo, 0, sizeof(outBufCreateInfo));
        +
        4083  outBufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
        +
        4084  outBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
        +
        4085  outBufCreateInfo.size = (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE; // Example size.
        +
        4086 }
        4087 
        -
        4088 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
        -
        4089 struct VmaMutexLockWrite
        +
        4088 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
        +
        4089 struct VmaMutexLock
        4090 {
        -
        4091  VMA_CLASS_NO_COPY(VmaMutexLockWrite)
        +
        4091  VMA_CLASS_NO_COPY(VmaMutexLock)
        4092 public:
        -
        4093  VmaMutexLockWrite(VMA_RW_MUTEX& mutex, bool useMutex) :
        +
        4093  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
        4094  m_pMutex(useMutex ? &mutex : VMA_NULL)
        -
        4095  { if(m_pMutex) { m_pMutex->LockWrite(); } }
        -
        4096  ~VmaMutexLockWrite() { if(m_pMutex) { m_pMutex->UnlockWrite(); } }
        -
        4097 private:
        -
        4098  VMA_RW_MUTEX* m_pMutex;
        -
        4099 };
        -
        4100 
        -
        4101 #if VMA_DEBUG_GLOBAL_MUTEX
        -
        4102  static VMA_MUTEX gDebugGlobalMutex;
        -
        4103  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
        -
        4104 #else
        -
        4105  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        4106 #endif
        -
        4107 
        -
        4108 // Minimum size of a free suballocation to register it in the free suballocation collection.
        -
        4109 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
        -
        4110 
        -
        4111 /*
        -
        4112 Performs binary search and returns iterator to first element that is greater or
        -
        4113 equal to (key), according to comparison (cmp).
        -
        4114 
        -
        4115 Cmp should return true if first argument is less than second argument.
        -
        4116 
        -
        4117 Returned value is the found element, if present in the collection or place where
        -
        4118 new element with value (key) should be inserted.
        -
        4119 */
        -
        4120 template <typename CmpLess, typename IterT, typename KeyT>
        -
        4121 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, const CmpLess& cmp)
        -
        4122 {
        -
        4123  size_t down = 0, up = (end - beg);
        -
        4124  while(down < up)
        -
        4125  {
        -
        4126  const size_t mid = (down + up) / 2;
        -
        4127  if(cmp(*(beg+mid), key))
        -
        4128  {
        -
        4129  down = mid + 1;
        -
        4130  }
        -
        4131  else
        -
        4132  {
        -
        4133  up = mid;
        -
        4134  }
        -
        4135  }
        -
        4136  return beg + down;
        -
        4137 }
        -
        4138 
        -
        4139 template<typename CmpLess, typename IterT, typename KeyT>
        -
        4140 IterT VmaBinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
        -
        4141 {
        -
        4142  IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
        -
        4143  beg, end, value, cmp);
        -
        4144  if(it == end ||
        -
        4145  (!cmp(*it, value) && !cmp(value, *it)))
        -
        4146  {
        -
        4147  return it;
        -
        4148  }
        -
        4149  return end;
        -
        4150 }
        -
        4151 
        -
        4152 /*
        -
        4153 Returns true if all pointers in the array are not-null and unique.
        -
        4154 Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
        -
        4155 T must be pointer type, e.g. VmaAllocation, VmaPool.
        -
        4156 */
        -
        4157 template<typename T>
        -
        4158 static bool VmaValidatePointerArray(uint32_t count, const T* arr)
        -
        4159 {
        -
        4160  for(uint32_t i = 0; i < count; ++i)
        -
        4161  {
        -
        4162  const T iPtr = arr[i];
        -
        4163  if(iPtr == VMA_NULL)
        -
        4164  {
        -
        4165  return false;
        -
        4166  }
        -
        4167  for(uint32_t j = i + 1; j < count; ++j)
        -
        4168  {
        -
        4169  if(iPtr == arr[j])
        -
        4170  {
        -
        4171  return false;
        -
        4172  }
        -
        4173  }
        -
        4174  }
        -
        4175  return true;
        -
        4176 }
        -
        4177 
        -
        4179 // Memory allocation
        -
        4180 
        -
        4181 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
        -
        4182 {
        -
        4183  if((pAllocationCallbacks != VMA_NULL) &&
        -
        4184  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
        -
        4185  {
        -
        4186  return (*pAllocationCallbacks->pfnAllocation)(
        -
        4187  pAllocationCallbacks->pUserData,
        -
        4188  size,
        -
        4189  alignment,
        -
        4190  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        -
        4191  }
        -
        4192  else
        -
        4193  {
        -
        4194  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
        -
        4195  }
        -
        4196 }
        -
        4197 
        -
        4198 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
        -
        4199 {
        -
        4200  if((pAllocationCallbacks != VMA_NULL) &&
        -
        4201  (pAllocationCallbacks->pfnFree != VMA_NULL))
        -
        4202  {
        -
        4203  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
        -
        4204  }
        -
        4205  else
        -
        4206  {
        -
        4207  VMA_SYSTEM_FREE(ptr);
        -
        4208  }
        -
        4209 }
        -
        4210 
        -
        4211 template<typename T>
        -
        4212 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
        -
        4213 {
        -
        4214  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
        -
        4215 }
        -
        4216 
        -
        4217 template<typename T>
        -
        4218 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
        -
        4219 {
        -
        4220  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
        -
        4221 }
        -
        4222 
        -
        4223 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
        +
        4095  { if(m_pMutex) { m_pMutex->Lock(); } }
        +
        4096  ~VmaMutexLock()
        +
        4097  { if(m_pMutex) { m_pMutex->Unlock(); } }
        +
        4098 private:
        +
        4099  VMA_MUTEX* m_pMutex;
        +
        4100 };
        +
        4101 
        +
        4102 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
        +
        4103 struct VmaMutexLockRead
        +
        4104 {
        +
        4105  VMA_CLASS_NO_COPY(VmaMutexLockRead)
        +
        4106 public:
        +
        4107  VmaMutexLockRead(VMA_RW_MUTEX& mutex, bool useMutex) :
        +
        4108  m_pMutex(useMutex ? &mutex : VMA_NULL)
        +
        4109  { if(m_pMutex) { m_pMutex->LockRead(); } }
        +
        4110  ~VmaMutexLockRead() { if(m_pMutex) { m_pMutex->UnlockRead(); } }
        +
        4111 private:
        +
        4112  VMA_RW_MUTEX* m_pMutex;
        +
        4113 };
        +
        4114 
        +
        4115 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
        +
        4116 struct VmaMutexLockWrite
        +
        4117 {
        +
        4118  VMA_CLASS_NO_COPY(VmaMutexLockWrite)
        +
        4119 public:
        +
        4120  VmaMutexLockWrite(VMA_RW_MUTEX& mutex, bool useMutex) :
        +
        4121  m_pMutex(useMutex ? &mutex : VMA_NULL)
        +
        4122  { if(m_pMutex) { m_pMutex->LockWrite(); } }
        +
        4123  ~VmaMutexLockWrite() { if(m_pMutex) { m_pMutex->UnlockWrite(); } }
        +
        4124 private:
        +
        4125  VMA_RW_MUTEX* m_pMutex;
        +
        4126 };
        +
        4127 
        +
        4128 #if VMA_DEBUG_GLOBAL_MUTEX
        +
        4129  static VMA_MUTEX gDebugGlobalMutex;
        +
        4130  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
        +
        4131 #else
        +
        4132  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        4133 #endif
        +
        4134 
        +
        4135 // Minimum size of a free suballocation to register it in the free suballocation collection.
        +
        4136 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
        +
        4137 
        +
        4138 /*
        +
        4139 Performs binary search and returns iterator to first element that is greater or
        +
        4140 equal to (key), according to comparison (cmp).
        +
        4141 
        +
        4142 Cmp should return true if first argument is less than second argument.
        +
        4143 
        +
        4144 Returned value is the found element, if present in the collection or place where
        +
        4145 new element with value (key) should be inserted.
        +
        4146 */
        +
        4147 template <typename CmpLess, typename IterT, typename KeyT>
        +
        4148 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, const CmpLess& cmp)
        +
        4149 {
        +
        4150  size_t down = 0, up = (end - beg);
        +
        4151  while(down < up)
        +
        4152  {
        +
        4153  const size_t mid = (down + up) / 2;
        +
        4154  if(cmp(*(beg+mid), key))
        +
        4155  {
        +
        4156  down = mid + 1;
        +
        4157  }
        +
        4158  else
        +
        4159  {
        +
        4160  up = mid;
        +
        4161  }
        +
        4162  }
        +
        4163  return beg + down;
        +
        4164 }
        +
        4165 
        +
        4166 template<typename CmpLess, typename IterT, typename KeyT>
        +
        4167 IterT VmaBinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
        +
        4168 {
        +
        4169  IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
        +
        4170  beg, end, value, cmp);
        +
        4171  if(it == end ||
        +
        4172  (!cmp(*it, value) && !cmp(value, *it)))
        +
        4173  {
        +
        4174  return it;
        +
        4175  }
        +
        4176  return end;
        +
        4177 }
        +
        4178 
        +
        4179 /*
        +
        4180 Returns true if all pointers in the array are not-null and unique.
        +
        4181 Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
        +
        4182 T must be pointer type, e.g. VmaAllocation, VmaPool.
        +
        4183 */
        +
        4184 template<typename T>
        +
        4185 static bool VmaValidatePointerArray(uint32_t count, const T* arr)
        +
        4186 {
        +
        4187  for(uint32_t i = 0; i < count; ++i)
        +
        4188  {
        +
        4189  const T iPtr = arr[i];
        +
        4190  if(iPtr == VMA_NULL)
        +
        4191  {
        +
        4192  return false;
        +
        4193  }
        +
        4194  for(uint32_t j = i + 1; j < count; ++j)
        +
        4195  {
        +
        4196  if(iPtr == arr[j])
        +
        4197  {
        +
        4198  return false;
        +
        4199  }
        +
        4200  }
        +
        4201  }
        +
        4202  return true;
        +
        4203 }
        +
        4204 
        +
        4206 // Memory allocation
        +
        4207 
        +
        4208 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
        +
        4209 {
        +
        4210  if((pAllocationCallbacks != VMA_NULL) &&
        +
        4211  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
        +
        4212  {
        +
        4213  return (*pAllocationCallbacks->pfnAllocation)(
        +
        4214  pAllocationCallbacks->pUserData,
        +
        4215  size,
        +
        4216  alignment,
        +
        4217  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        +
        4218  }
        +
        4219  else
        +
        4220  {
        +
        4221  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
        +
        4222  }
        +
        4223 }
        4224 
        -
        4225 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
        -
        4226 
        -
        4227 template<typename T>
        -
        4228 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
        -
        4229 {
        -
        4230  ptr->~T();
        -
        4231  VmaFree(pAllocationCallbacks, ptr);
        -
        4232 }
        -
        4233 
        -
        4234 template<typename T>
        -
        4235 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
        -
        4236 {
        -
        4237  if(ptr != VMA_NULL)
        -
        4238  {
        -
        4239  for(size_t i = count; i--; )
        -
        4240  {
        -
        4241  ptr[i].~T();
        -
        4242  }
        -
        4243  VmaFree(pAllocationCallbacks, ptr);
        -
        4244  }
        -
        4245 }
        -
        4246 
        -
        4247 static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr)
        -
        4248 {
        -
        4249  if(srcStr != VMA_NULL)
        -
        4250  {
        -
        4251  const size_t len = strlen(srcStr);
        -
        4252  char* const result = vma_new_array(allocs, char, len + 1);
        -
        4253  memcpy(result, srcStr, len + 1);
        -
        4254  return result;
        -
        4255  }
        -
        4256  else
        -
        4257  {
        -
        4258  return VMA_NULL;
        -
        4259  }
        -
        4260 }
        -
        4261 
        -
        4262 static void VmaFreeString(const VkAllocationCallbacks* allocs, char* str)
        +
        4225 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
        +
        4226 {
        +
        4227  if((pAllocationCallbacks != VMA_NULL) &&
        +
        4228  (pAllocationCallbacks->pfnFree != VMA_NULL))
        +
        4229  {
        +
        4230  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
        +
        4231  }
        +
        4232  else
        +
        4233  {
        +
        4234  VMA_SYSTEM_FREE(ptr);
        +
        4235  }
        +
        4236 }
        +
        4237 
        +
        4238 template<typename T>
        +
        4239 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
        +
        4240 {
        +
        4241  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
        +
        4242 }
        +
        4243 
        +
        4244 template<typename T>
        +
        4245 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
        +
        4246 {
        +
        4247  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
        +
        4248 }
        +
        4249 
        +
        4250 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
        +
        4251 
        +
        4252 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
        +
        4253 
        +
        4254 template<typename T>
        +
        4255 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
        +
        4256 {
        +
        4257  ptr->~T();
        +
        4258  VmaFree(pAllocationCallbacks, ptr);
        +
        4259 }
        +
        4260 
        +
        4261 template<typename T>
        +
        4262 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
        4263 {
        -
        4264  if(str != VMA_NULL)
        +
        4264  if(ptr != VMA_NULL)
        4265  {
        -
        4266  const size_t len = strlen(str);
        -
        4267  vma_delete_array(allocs, str, len + 1);
        -
        4268  }
        -
        4269 }
        -
        4270 
        -
        4271 // STL-compatible allocator.
        -
        4272 template<typename T>
        -
        4273 class VmaStlAllocator
        -
        4274 {
        -
        4275 public:
        -
        4276  const VkAllocationCallbacks* const m_pCallbacks;
        -
        4277  typedef T value_type;
        -
        4278 
        -
        4279  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
        -
        4280  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
        -
        4281 
        -
        4282  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
        -
        4283  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
        -
        4284 
        -
        4285  template<typename U>
        -
        4286  bool operator==(const VmaStlAllocator<U>& rhs) const
        -
        4287  {
        -
        4288  return m_pCallbacks == rhs.m_pCallbacks;
        -
        4289  }
        -
        4290  template<typename U>
        -
        4291  bool operator!=(const VmaStlAllocator<U>& rhs) const
        -
        4292  {
        -
        4293  return m_pCallbacks != rhs.m_pCallbacks;
        -
        4294  }
        -
        4295 
        -
        4296  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
        -
        4297 };
        -
        4298 
        -
        4299 #if VMA_USE_STL_VECTOR
        -
        4300 
        -
        4301 #define VmaVector std::vector
        -
        4302 
        -
        4303 template<typename T, typename allocatorT>
        -
        4304 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
        -
        4305 {
        -
        4306  vec.insert(vec.begin() + index, item);
        -
        4307 }
        +
        4266  for(size_t i = count; i--; )
        +
        4267  {
        +
        4268  ptr[i].~T();
        +
        4269  }
        +
        4270  VmaFree(pAllocationCallbacks, ptr);
        +
        4271  }
        +
        4272 }
        +
        4273 
        +
        4274 static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr)
        +
        4275 {
        +
        4276  if(srcStr != VMA_NULL)
        +
        4277  {
        +
        4278  const size_t len = strlen(srcStr);
        +
        4279  char* const result = vma_new_array(allocs, char, len + 1);
        +
        4280  memcpy(result, srcStr, len + 1);
        +
        4281  return result;
        +
        4282  }
        +
        4283  else
        +
        4284  {
        +
        4285  return VMA_NULL;
        +
        4286  }
        +
        4287 }
        +
        4288 
        +
        4289 static void VmaFreeString(const VkAllocationCallbacks* allocs, char* str)
        +
        4290 {
        +
        4291  if(str != VMA_NULL)
        +
        4292  {
        +
        4293  const size_t len = strlen(str);
        +
        4294  vma_delete_array(allocs, str, len + 1);
        +
        4295  }
        +
        4296 }
        +
        4297 
        +
        4298 // STL-compatible allocator.
        +
        4299 template<typename T>
        +
        4300 class VmaStlAllocator
        +
        4301 {
        +
        4302 public:
        +
        4303  const VkAllocationCallbacks* const m_pCallbacks;
        +
        4304  typedef T value_type;
        +
        4305 
        +
        4306  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
        +
        4307  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
        4308 
        -
        4309 template<typename T, typename allocatorT>
        -
        4310 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
        -
        4311 {
        -
        4312  vec.erase(vec.begin() + index);
        -
        4313 }
        -
        4314 
        -
        4315 #else // #if VMA_USE_STL_VECTOR
        -
        4316 
        -
        4317 /* Class with interface compatible with subset of std::vector.
        -
        4318 T must be POD because constructors and destructors are not called and memcpy is
        -
        4319 used for these objects. */
        -
        4320 template<typename T, typename AllocatorT>
        -
        4321 class VmaVector
        -
        4322 {
        -
        4323 public:
        -
        4324  typedef T value_type;
        +
        4309  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
        +
        4310  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
        +
        4311 
        +
        4312  template<typename U>
        +
        4313  bool operator==(const VmaStlAllocator<U>& rhs) const
        +
        4314  {
        +
        4315  return m_pCallbacks == rhs.m_pCallbacks;
        +
        4316  }
        +
        4317  template<typename U>
        +
        4318  bool operator!=(const VmaStlAllocator<U>& rhs) const
        +
        4319  {
        +
        4320  return m_pCallbacks != rhs.m_pCallbacks;
        +
        4321  }
        +
        4322 
        +
        4323  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
        +
        4324 };
        4325 
        -
        4326  VmaVector(const AllocatorT& allocator) :
        -
        4327  m_Allocator(allocator),
        -
        4328  m_pArray(VMA_NULL),
        -
        4329  m_Count(0),
        -
        4330  m_Capacity(0)
        -
        4331  {
        -
        4332  }
        -
        4333 
        -
        4334  VmaVector(size_t count, const AllocatorT& allocator) :
        -
        4335  m_Allocator(allocator),
        -
        4336  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
        -
        4337  m_Count(count),
        -
        4338  m_Capacity(count)
        -
        4339  {
        -
        4340  }
        -
        4341 
        -
        4342  // This version of the constructor is here for compatibility with pre-C++14 std::vector.
        -
        4343  // value is unused.
        -
        4344  VmaVector(size_t count, const T& value, const AllocatorT& allocator)
        -
        4345  : VmaVector(count, allocator) {}
        -
        4346 
        -
        4347  VmaVector(const VmaVector<T, AllocatorT>& src) :
        -
        4348  m_Allocator(src.m_Allocator),
        -
        4349  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
        -
        4350  m_Count(src.m_Count),
        -
        4351  m_Capacity(src.m_Count)
        -
        4352  {
        -
        4353  if(m_Count != 0)
        -
        4354  {
        -
        4355  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
        -
        4356  }
        -
        4357  }
        -
        4358 
        -
        4359  ~VmaVector()
        -
        4360  {
        -
        4361  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        -
        4362  }
        -
        4363 
        -
        4364  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
        -
        4365  {
        -
        4366  if(&rhs != this)
        -
        4367  {
        -
        4368  resize(rhs.m_Count);
        -
        4369  if(m_Count != 0)
        -
        4370  {
        -
        4371  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
        -
        4372  }
        -
        4373  }
        -
        4374  return *this;
        -
        4375  }
        -
        4376 
        -
        4377  bool empty() const { return m_Count == 0; }
        -
        4378  size_t size() const { return m_Count; }
        -
        4379  T* data() { return m_pArray; }
        -
        4380  const T* data() const { return m_pArray; }
        -
        4381 
        -
        4382  T& operator[](size_t index)
        -
        4383  {
        -
        4384  VMA_HEAVY_ASSERT(index < m_Count);
        -
        4385  return m_pArray[index];
        -
        4386  }
        -
        4387  const T& operator[](size_t index) const
        -
        4388  {
        -
        4389  VMA_HEAVY_ASSERT(index < m_Count);
        -
        4390  return m_pArray[index];
        -
        4391  }
        -
        4392 
        -
        4393  T& front()
        -
        4394  {
        -
        4395  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4396  return m_pArray[0];
        -
        4397  }
        -
        4398  const T& front() const
        -
        4399  {
        -
        4400  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4401  return m_pArray[0];
        +
        4326 #if VMA_USE_STL_VECTOR
        +
        4327 
        +
        4328 #define VmaVector std::vector
        +
        4329 
        +
        4330 template<typename T, typename allocatorT>
        +
        4331 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
        +
        4332 {
        +
        4333  vec.insert(vec.begin() + index, item);
        +
        4334 }
        +
        4335 
        +
        4336 template<typename T, typename allocatorT>
        +
        4337 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
        +
        4338 {
        +
        4339  vec.erase(vec.begin() + index);
        +
        4340 }
        +
        4341 
        +
        4342 #else // #if VMA_USE_STL_VECTOR
        +
        4343 
        +
        4344 /* Class with interface compatible with subset of std::vector.
        +
        4345 T must be POD because constructors and destructors are not called and memcpy is
        +
        4346 used for these objects. */
        +
        4347 template<typename T, typename AllocatorT>
        +
        4348 class VmaVector
        +
        4349 {
        +
        4350 public:
        +
        4351  typedef T value_type;
        +
        4352 
        +
        4353  VmaVector(const AllocatorT& allocator) :
        +
        4354  m_Allocator(allocator),
        +
        4355  m_pArray(VMA_NULL),
        +
        4356  m_Count(0),
        +
        4357  m_Capacity(0)
        +
        4358  {
        +
        4359  }
        +
        4360 
        +
        4361  VmaVector(size_t count, const AllocatorT& allocator) :
        +
        4362  m_Allocator(allocator),
        +
        4363  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
        +
        4364  m_Count(count),
        +
        4365  m_Capacity(count)
        +
        4366  {
        +
        4367  }
        +
        4368 
        +
        4369  // This version of the constructor is here for compatibility with pre-C++14 std::vector.
        +
        4370  // value is unused.
        +
        4371  VmaVector(size_t count, const T& value, const AllocatorT& allocator)
        +
        4372  : VmaVector(count, allocator) {}
        +
        4373 
        +
        4374  VmaVector(const VmaVector<T, AllocatorT>& src) :
        +
        4375  m_Allocator(src.m_Allocator),
        +
        4376  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
        +
        4377  m_Count(src.m_Count),
        +
        4378  m_Capacity(src.m_Count)
        +
        4379  {
        +
        4380  if(m_Count != 0)
        +
        4381  {
        +
        4382  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
        +
        4383  }
        +
        4384  }
        +
        4385 
        +
        4386  ~VmaVector()
        +
        4387  {
        +
        4388  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        +
        4389  }
        +
        4390 
        +
        4391  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
        +
        4392  {
        +
        4393  if(&rhs != this)
        +
        4394  {
        +
        4395  resize(rhs.m_Count);
        +
        4396  if(m_Count != 0)
        +
        4397  {
        +
        4398  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
        +
        4399  }
        +
        4400  }
        +
        4401  return *this;
        4402  }
        -
        4403  T& back()
        -
        4404  {
        -
        4405  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4406  return m_pArray[m_Count - 1];
        -
        4407  }
        -
        4408  const T& back() const
        -
        4409  {
        -
        4410  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4411  return m_pArray[m_Count - 1];
        -
        4412  }
        -
        4413 
        -
        4414  void reserve(size_t newCapacity, bool freeMemory = false)
        -
        4415  {
        -
        4416  newCapacity = VMA_MAX(newCapacity, m_Count);
        -
        4417 
        -
        4418  if((newCapacity < m_Capacity) && !freeMemory)
        -
        4419  {
        -
        4420  newCapacity = m_Capacity;
        -
        4421  }
        -
        4422 
        -
        4423  if(newCapacity != m_Capacity)
        -
        4424  {
        -
        4425  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
        -
        4426  if(m_Count != 0)
        -
        4427  {
        -
        4428  memcpy(newArray, m_pArray, m_Count * sizeof(T));
        -
        4429  }
        -
        4430  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        -
        4431  m_Capacity = newCapacity;
        -
        4432  m_pArray = newArray;
        -
        4433  }
        +
        4403 
        +
        4404  bool empty() const { return m_Count == 0; }
        +
        4405  size_t size() const { return m_Count; }
        +
        4406  T* data() { return m_pArray; }
        +
        4407  const T* data() const { return m_pArray; }
        +
        4408 
        +
        4409  T& operator[](size_t index)
        +
        4410  {
        +
        4411  VMA_HEAVY_ASSERT(index < m_Count);
        +
        4412  return m_pArray[index];
        +
        4413  }
        +
        4414  const T& operator[](size_t index) const
        +
        4415  {
        +
        4416  VMA_HEAVY_ASSERT(index < m_Count);
        +
        4417  return m_pArray[index];
        +
        4418  }
        +
        4419 
        +
        4420  T& front()
        +
        4421  {
        +
        4422  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4423  return m_pArray[0];
        +
        4424  }
        +
        4425  const T& front() const
        +
        4426  {
        +
        4427  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4428  return m_pArray[0];
        +
        4429  }
        +
        4430  T& back()
        +
        4431  {
        +
        4432  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4433  return m_pArray[m_Count - 1];
        4434  }
        -
        4435 
        -
        4436  void resize(size_t newCount, bool freeMemory = false)
        -
        4437  {
        -
        4438  size_t newCapacity = m_Capacity;
        -
        4439  if(newCount > m_Capacity)
        -
        4440  {
        -
        4441  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
        -
        4442  }
        -
        4443  else if(freeMemory)
        -
        4444  {
        -
        4445  newCapacity = newCount;
        -
        4446  }
        -
        4447 
        -
        4448  if(newCapacity != m_Capacity)
        -
        4449  {
        -
        4450  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
        -
        4451  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
        -
        4452  if(elementsToCopy != 0)
        -
        4453  {
        -
        4454  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
        -
        4455  }
        -
        4456  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        -
        4457  m_Capacity = newCapacity;
        -
        4458  m_pArray = newArray;
        -
        4459  }
        -
        4460 
        -
        4461  m_Count = newCount;
        -
        4462  }
        -
        4463 
        -
        4464  void clear(bool freeMemory = false)
        -
        4465  {
        -
        4466  resize(0, freeMemory);
        -
        4467  }
        -
        4468 
        -
        4469  void insert(size_t index, const T& src)
        -
        4470  {
        -
        4471  VMA_HEAVY_ASSERT(index <= m_Count);
        -
        4472  const size_t oldCount = size();
        -
        4473  resize(oldCount + 1);
        -
        4474  if(index < oldCount)
        -
        4475  {
        -
        4476  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
        -
        4477  }
        -
        4478  m_pArray[index] = src;
        -
        4479  }
        -
        4480 
        -
        4481  void remove(size_t index)
        -
        4482  {
        -
        4483  VMA_HEAVY_ASSERT(index < m_Count);
        -
        4484  const size_t oldCount = size();
        -
        4485  if(index < oldCount - 1)
        -
        4486  {
        -
        4487  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
        -
        4488  }
        -
        4489  resize(oldCount - 1);
        -
        4490  }
        -
        4491 
        -
        4492  void push_back(const T& src)
        -
        4493  {
        -
        4494  const size_t newIndex = size();
        -
        4495  resize(newIndex + 1);
        -
        4496  m_pArray[newIndex] = src;
        -
        4497  }
        -
        4498 
        -
        4499  void pop_back()
        -
        4500  {
        -
        4501  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4502  resize(size() - 1);
        -
        4503  }
        -
        4504 
        -
        4505  void push_front(const T& src)
        -
        4506  {
        -
        4507  insert(0, src);
        -
        4508  }
        -
        4509 
        -
        4510  void pop_front()
        -
        4511  {
        -
        4512  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4513  remove(0);
        -
        4514  }
        -
        4515 
        -
        4516  typedef T* iterator;
        -
        4517 
        -
        4518  iterator begin() { return m_pArray; }
        -
        4519  iterator end() { return m_pArray + m_Count; }
        -
        4520 
        -
        4521 private:
        -
        4522  AllocatorT m_Allocator;
        -
        4523  T* m_pArray;
        -
        4524  size_t m_Count;
        -
        4525  size_t m_Capacity;
        -
        4526 };
        -
        4527 
        -
        4528 template<typename T, typename allocatorT>
        -
        4529 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
        -
        4530 {
        -
        4531  vec.insert(index, item);
        -
        4532 }
        -
        4533 
        -
        4534 template<typename T, typename allocatorT>
        -
        4535 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
        -
        4536 {
        -
        4537  vec.remove(index);
        -
        4538 }
        -
        4539 
        -
        4540 #endif // #if VMA_USE_STL_VECTOR
        -
        4541 
        -
        4542 template<typename CmpLess, typename VectorT>
        -
        4543 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
        -
        4544 {
        -
        4545  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        -
        4546  vector.data(),
        -
        4547  vector.data() + vector.size(),
        -
        4548  value,
        -
        4549  CmpLess()) - vector.data();
        -
        4550  VmaVectorInsert(vector, indexToInsert, value);
        -
        4551  return indexToInsert;
        -
        4552 }
        -
        4553 
        -
        4554 template<typename CmpLess, typename VectorT>
        -
        4555 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
        -
        4556 {
        -
        4557  CmpLess comparator;
        -
        4558  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
        -
        4559  vector.begin(),
        -
        4560  vector.end(),
        -
        4561  value,
        -
        4562  comparator);
        -
        4563  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
        -
        4564  {
        -
        4565  size_t indexToRemove = it - vector.begin();
        -
        4566  VmaVectorRemove(vector, indexToRemove);
        -
        4567  return true;
        -
        4568  }
        -
        4569  return false;
        -
        4570 }
        -
        4571 
        -
        4573 // class VmaPoolAllocator
        -
        4574 
        -
        4575 /*
        -
        4576 Allocator for objects of type T using a list of arrays (pools) to speed up
        -
        4577 allocation. Number of elements that can be allocated is not bounded because
        -
        4578 allocator can create multiple blocks.
        -
        4579 */
        -
        4580 template<typename T>
        -
        4581 class VmaPoolAllocator
        -
        4582 {
        -
        4583  VMA_CLASS_NO_COPY(VmaPoolAllocator)
        -
        4584 public:
        -
        4585  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity);
        -
        4586  ~VmaPoolAllocator();
        -
        4587  T* Alloc();
        -
        4588  void Free(T* ptr);
        -
        4589 
        -
        4590 private:
        -
        4591  union Item
        -
        4592  {
        -
        4593  uint32_t NextFreeIndex;
        -
        4594  alignas(T) char Value[sizeof(T)];
        -
        4595  };
        -
        4596 
        -
        4597  struct ItemBlock
        -
        4598  {
        -
        4599  Item* pItems;
        -
        4600  uint32_t Capacity;
        -
        4601  uint32_t FirstFreeIndex;
        -
        4602  };
        -
        4603 
        -
        4604  const VkAllocationCallbacks* m_pAllocationCallbacks;
        -
        4605  const uint32_t m_FirstBlockCapacity;
        -
        4606  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
        -
        4607 
        -
        4608  ItemBlock& CreateNewBlock();
        -
        4609 };
        -
        4610 
        -
        4611 template<typename T>
        -
        4612 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity) :
        -
        4613  m_pAllocationCallbacks(pAllocationCallbacks),
        -
        4614  m_FirstBlockCapacity(firstBlockCapacity),
        -
        4615  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
        -
        4616 {
        -
        4617  VMA_ASSERT(m_FirstBlockCapacity > 1);
        -
        4618 }
        -
        4619 
        -
        4620 template<typename T>
        -
        4621 VmaPoolAllocator<T>::~VmaPoolAllocator()
        -
        4622 {
        -
        4623  for(size_t i = m_ItemBlocks.size(); i--; )
        -
        4624  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
        -
        4625  m_ItemBlocks.clear();
        -
        4626 }
        -
        4627 
        -
        4628 template<typename T>
        -
        4629 T* VmaPoolAllocator<T>::Alloc()
        -
        4630 {
        -
        4631  for(size_t i = m_ItemBlocks.size(); i--; )
        -
        4632  {
        -
        4633  ItemBlock& block = m_ItemBlocks[i];
        -
        4634  // This block has some free items: Use first one.
        -
        4635  if(block.FirstFreeIndex != UINT32_MAX)
        -
        4636  {
        -
        4637  Item* const pItem = &block.pItems[block.FirstFreeIndex];
        -
        4638  block.FirstFreeIndex = pItem->NextFreeIndex;
        -
        4639  T* result = (T*)&pItem->Value;
        -
        4640  new(result)T(); // Explicit constructor call.
        -
        4641  return result;
        -
        4642  }
        -
        4643  }
        -
        4644 
        -
        4645  // No block has free item: Create new one and use it.
        -
        4646  ItemBlock& newBlock = CreateNewBlock();
        -
        4647  Item* const pItem = &newBlock.pItems[0];
        -
        4648  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
        -
        4649  T* result = (T*)&pItem->Value;
        -
        4650  new(result)T(); // Explicit constructor call.
        -
        4651  return result;
        -
        4652 }
        -
        4653 
        -
        4654 template<typename T>
        -
        4655 void VmaPoolAllocator<T>::Free(T* ptr)
        -
        4656 {
        -
        4657  // Search all memory blocks to find ptr.
        +
        4435  const T& back() const
        +
        4436  {
        +
        4437  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4438  return m_pArray[m_Count - 1];
        +
        4439  }
        +
        4440 
        +
        4441  void reserve(size_t newCapacity, bool freeMemory = false)
        +
        4442  {
        +
        4443  newCapacity = VMA_MAX(newCapacity, m_Count);
        +
        4444 
        +
        4445  if((newCapacity < m_Capacity) && !freeMemory)
        +
        4446  {
        +
        4447  newCapacity = m_Capacity;
        +
        4448  }
        +
        4449 
        +
        4450  if(newCapacity != m_Capacity)
        +
        4451  {
        +
        4452  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
        +
        4453  if(m_Count != 0)
        +
        4454  {
        +
        4455  memcpy(newArray, m_pArray, m_Count * sizeof(T));
        +
        4456  }
        +
        4457  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        +
        4458  m_Capacity = newCapacity;
        +
        4459  m_pArray = newArray;
        +
        4460  }
        +
        4461  }
        +
        4462 
        +
        4463  void resize(size_t newCount, bool freeMemory = false)
        +
        4464  {
        +
        4465  size_t newCapacity = m_Capacity;
        +
        4466  if(newCount > m_Capacity)
        +
        4467  {
        +
        4468  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
        +
        4469  }
        +
        4470  else if(freeMemory)
        +
        4471  {
        +
        4472  newCapacity = newCount;
        +
        4473  }
        +
        4474 
        +
        4475  if(newCapacity != m_Capacity)
        +
        4476  {
        +
        4477  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
        +
        4478  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
        +
        4479  if(elementsToCopy != 0)
        +
        4480  {
        +
        4481  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
        +
        4482  }
        +
        4483  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        +
        4484  m_Capacity = newCapacity;
        +
        4485  m_pArray = newArray;
        +
        4486  }
        +
        4487 
        +
        4488  m_Count = newCount;
        +
        4489  }
        +
        4490 
        +
        4491  void clear(bool freeMemory = false)
        +
        4492  {
        +
        4493  resize(0, freeMemory);
        +
        4494  }
        +
        4495 
        +
        4496  void insert(size_t index, const T& src)
        +
        4497  {
        +
        4498  VMA_HEAVY_ASSERT(index <= m_Count);
        +
        4499  const size_t oldCount = size();
        +
        4500  resize(oldCount + 1);
        +
        4501  if(index < oldCount)
        +
        4502  {
        +
        4503  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
        +
        4504  }
        +
        4505  m_pArray[index] = src;
        +
        4506  }
        +
        4507 
        +
        4508  void remove(size_t index)
        +
        4509  {
        +
        4510  VMA_HEAVY_ASSERT(index < m_Count);
        +
        4511  const size_t oldCount = size();
        +
        4512  if(index < oldCount - 1)
        +
        4513  {
        +
        4514  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
        +
        4515  }
        +
        4516  resize(oldCount - 1);
        +
        4517  }
        +
        4518 
        +
        4519  void push_back(const T& src)
        +
        4520  {
        +
        4521  const size_t newIndex = size();
        +
        4522  resize(newIndex + 1);
        +
        4523  m_pArray[newIndex] = src;
        +
        4524  }
        +
        4525 
        +
        4526  void pop_back()
        +
        4527  {
        +
        4528  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4529  resize(size() - 1);
        +
        4530  }
        +
        4531 
        +
        4532  void push_front(const T& src)
        +
        4533  {
        +
        4534  insert(0, src);
        +
        4535  }
        +
        4536 
        +
        4537  void pop_front()
        +
        4538  {
        +
        4539  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4540  remove(0);
        +
        4541  }
        +
        4542 
        +
        4543  typedef T* iterator;
        +
        4544 
        +
        4545  iterator begin() { return m_pArray; }
        +
        4546  iterator end() { return m_pArray + m_Count; }
        +
        4547 
        +
        4548 private:
        +
        4549  AllocatorT m_Allocator;
        +
        4550  T* m_pArray;
        +
        4551  size_t m_Count;
        +
        4552  size_t m_Capacity;
        +
        4553 };
        +
        4554 
        +
        4555 template<typename T, typename allocatorT>
        +
        4556 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
        +
        4557 {
        +
        4558  vec.insert(index, item);
        +
        4559 }
        +
        4560 
        +
        4561 template<typename T, typename allocatorT>
        +
        4562 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
        +
        4563 {
        +
        4564  vec.remove(index);
        +
        4565 }
        +
        4566 
        +
        4567 #endif // #if VMA_USE_STL_VECTOR
        +
        4568 
        +
        4569 template<typename CmpLess, typename VectorT>
        +
        4570 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
        +
        4571 {
        +
        4572  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        +
        4573  vector.data(),
        +
        4574  vector.data() + vector.size(),
        +
        4575  value,
        +
        4576  CmpLess()) - vector.data();
        +
        4577  VmaVectorInsert(vector, indexToInsert, value);
        +
        4578  return indexToInsert;
        +
        4579 }
        +
        4580 
        +
        4581 template<typename CmpLess, typename VectorT>
        +
        4582 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
        +
        4583 {
        +
        4584  CmpLess comparator;
        +
        4585  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
        +
        4586  vector.begin(),
        +
        4587  vector.end(),
        +
        4588  value,
        +
        4589  comparator);
        +
        4590  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
        +
        4591  {
        +
        4592  size_t indexToRemove = it - vector.begin();
        +
        4593  VmaVectorRemove(vector, indexToRemove);
        +
        4594  return true;
        +
        4595  }
        +
        4596  return false;
        +
        4597 }
        +
        4598 
        +
        4600 // class VmaPoolAllocator
        +
        4601 
        +
        4602 /*
        +
        4603 Allocator for objects of type T using a list of arrays (pools) to speed up
        +
        4604 allocation. Number of elements that can be allocated is not bounded because
        +
        4605 allocator can create multiple blocks.
        +
        4606 */
        +
        4607 template<typename T>
        +
        4608 class VmaPoolAllocator
        +
        4609 {
        +
        4610  VMA_CLASS_NO_COPY(VmaPoolAllocator)
        +
        4611 public:
        +
        4612  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity);
        +
        4613  ~VmaPoolAllocator();
        +
        4614  T* Alloc();
        +
        4615  void Free(T* ptr);
        +
        4616 
        +
        4617 private:
        +
        4618  union Item
        +
        4619  {
        +
        4620  uint32_t NextFreeIndex;
        +
        4621  alignas(T) char Value[sizeof(T)];
        +
        4622  };
        +
        4623 
        +
        4624  struct ItemBlock
        +
        4625  {
        +
        4626  Item* pItems;
        +
        4627  uint32_t Capacity;
        +
        4628  uint32_t FirstFreeIndex;
        +
        4629  };
        +
        4630 
        +
        4631  const VkAllocationCallbacks* m_pAllocationCallbacks;
        +
        4632  const uint32_t m_FirstBlockCapacity;
        +
        4633  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
        +
        4634 
        +
        4635  ItemBlock& CreateNewBlock();
        +
        4636 };
        +
        4637 
        +
        4638 template<typename T>
        +
        4639 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity) :
        +
        4640  m_pAllocationCallbacks(pAllocationCallbacks),
        +
        4641  m_FirstBlockCapacity(firstBlockCapacity),
        +
        4642  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
        +
        4643 {
        +
        4644  VMA_ASSERT(m_FirstBlockCapacity > 1);
        +
        4645 }
        +
        4646 
        +
        4647 template<typename T>
        +
        4648 VmaPoolAllocator<T>::~VmaPoolAllocator()
        +
        4649 {
        +
        4650  for(size_t i = m_ItemBlocks.size(); i--; )
        +
        4651  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
        +
        4652  m_ItemBlocks.clear();
        +
        4653 }
        +
        4654 
        +
        4655 template<typename T>
        +
        4656 T* VmaPoolAllocator<T>::Alloc()
        +
        4657 {
        4658  for(size_t i = m_ItemBlocks.size(); i--; )
        4659  {
        4660  ItemBlock& block = m_ItemBlocks[i];
        -
        4661 
        -
        4662  // Casting to union.
        -
        4663  Item* pItemPtr;
        -
        4664  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
        -
        4665 
        -
        4666  // Check if pItemPtr is in address range of this block.
        -
        4667  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
        -
        4668  {
        -
        4669  ptr->~T(); // Explicit destructor call.
        -
        4670  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
        -
        4671  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
        -
        4672  block.FirstFreeIndex = index;
        -
        4673  return;
        -
        4674  }
        -
        4675  }
        -
        4676  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
        -
        4677 }
        -
        4678 
        -
        4679 template<typename T>
        -
        4680 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
        -
        4681 {
        -
        4682  const uint32_t newBlockCapacity = m_ItemBlocks.empty() ?
        -
        4683  m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;
        -
        4684 
        -
        4685  const ItemBlock newBlock = {
        -
        4686  vma_new_array(m_pAllocationCallbacks, Item, newBlockCapacity),
        -
        4687  newBlockCapacity,
        -
        4688  0 };
        -
        4689 
        -
        4690  m_ItemBlocks.push_back(newBlock);
        -
        4691 
        -
        4692  // Setup singly-linked list of all free items in this block.
        -
        4693  for(uint32_t i = 0; i < newBlockCapacity - 1; ++i)
        -
        4694  newBlock.pItems[i].NextFreeIndex = i + 1;
        -
        4695  newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
        -
        4696  return m_ItemBlocks.back();
        -
        4697 }
        -
        4698 
        -
        4700 // class VmaRawList, VmaList
        -
        4701 
        -
        4702 #if VMA_USE_STL_LIST
        -
        4703 
        -
        4704 #define VmaList std::list
        +
        4661  // This block has some free items: Use first one.
        +
        4662  if(block.FirstFreeIndex != UINT32_MAX)
        +
        4663  {
        +
        4664  Item* const pItem = &block.pItems[block.FirstFreeIndex];
        +
        4665  block.FirstFreeIndex = pItem->NextFreeIndex;
        +
        4666  T* result = (T*)&pItem->Value;
        +
        4667  new(result)T(); // Explicit constructor call.
        +
        4668  return result;
        +
        4669  }
        +
        4670  }
        +
        4671 
        +
        4672  // No block has free item: Create new one and use it.
        +
        4673  ItemBlock& newBlock = CreateNewBlock();
        +
        4674  Item* const pItem = &newBlock.pItems[0];
        +
        4675  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
        +
        4676  T* result = (T*)&pItem->Value;
        +
        4677  new(result)T(); // Explicit constructor call.
        +
        4678  return result;
        +
        4679 }
        +
        4680 
        +
        4681 template<typename T>
        +
        4682 void VmaPoolAllocator<T>::Free(T* ptr)
        +
        4683 {
        +
        4684  // Search all memory blocks to find ptr.
        +
        4685  for(size_t i = m_ItemBlocks.size(); i--; )
        +
        4686  {
        +
        4687  ItemBlock& block = m_ItemBlocks[i];
        +
        4688 
        +
        4689  // Casting to union.
        +
        4690  Item* pItemPtr;
        +
        4691  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
        +
        4692 
        +
        4693  // Check if pItemPtr is in address range of this block.
        +
        4694  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
        +
        4695  {
        +
        4696  ptr->~T(); // Explicit destructor call.
        +
        4697  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
        +
        4698  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
        +
        4699  block.FirstFreeIndex = index;
        +
        4700  return;
        +
        4701  }
        +
        4702  }
        +
        4703  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
        +
        4704 }
        4705 
        -
        4706 #else // #if VMA_USE_STL_LIST
        -
        4707 
        -
        4708 template<typename T>
        -
        4709 struct VmaListItem
        -
        4710 {
        -
        4711  VmaListItem* pPrev;
        -
        4712  VmaListItem* pNext;
        -
        4713  T Value;
        -
        4714 };
        -
        4715 
        -
        4716 // Doubly linked list.
        -
        4717 template<typename T>
        -
        4718 class VmaRawList
        -
        4719 {
        -
        4720  VMA_CLASS_NO_COPY(VmaRawList)
        -
        4721 public:
        -
        4722  typedef VmaListItem<T> ItemType;
        -
        4723 
        -
        4724  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
        -
        4725  ~VmaRawList();
        -
        4726  void Clear();
        -
        4727 
        -
        4728  size_t GetCount() const { return m_Count; }
        -
        4729  bool IsEmpty() const { return m_Count == 0; }
        +
        4706 template<typename T>
        +
        4707 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
        +
        4708 {
        +
        4709  const uint32_t newBlockCapacity = m_ItemBlocks.empty() ?
        +
        4710  m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;
        +
        4711 
        +
        4712  const ItemBlock newBlock = {
        +
        4713  vma_new_array(m_pAllocationCallbacks, Item, newBlockCapacity),
        +
        4714  newBlockCapacity,
        +
        4715  0 };
        +
        4716 
        +
        4717  m_ItemBlocks.push_back(newBlock);
        +
        4718 
        +
        4719  // Setup singly-linked list of all free items in this block.
        +
        4720  for(uint32_t i = 0; i < newBlockCapacity - 1; ++i)
        +
        4721  newBlock.pItems[i].NextFreeIndex = i + 1;
        +
        4722  newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
        +
        4723  return m_ItemBlocks.back();
        +
        4724 }
        +
        4725 
        +
        4727 // class VmaRawList, VmaList
        +
        4728 
        +
        4729 #if VMA_USE_STL_LIST
        4730 
        -
        4731  ItemType* Front() { return m_pFront; }
        -
        4732  const ItemType* Front() const { return m_pFront; }
        -
        4733  ItemType* Back() { return m_pBack; }
        -
        4734  const ItemType* Back() const { return m_pBack; }
        -
        4735 
        -
        4736  ItemType* PushBack();
        -
        4737  ItemType* PushFront();
        -
        4738  ItemType* PushBack(const T& value);
        -
        4739  ItemType* PushFront(const T& value);
        -
        4740  void PopBack();
        -
        4741  void PopFront();
        -
        4742 
        -
        4743  // Item can be null - it means PushBack.
        -
        4744  ItemType* InsertBefore(ItemType* pItem);
        -
        4745  // Item can be null - it means PushFront.
        -
        4746  ItemType* InsertAfter(ItemType* pItem);
        -
        4747 
        -
        4748  ItemType* InsertBefore(ItemType* pItem, const T& value);
        -
        4749  ItemType* InsertAfter(ItemType* pItem, const T& value);
        +
        4731 #define VmaList std::list
        +
        4732 
        +
        4733 #else // #if VMA_USE_STL_LIST
        +
        4734 
        +
        4735 template<typename T>
        +
        4736 struct VmaListItem
        +
        4737 {
        +
        4738  VmaListItem* pPrev;
        +
        4739  VmaListItem* pNext;
        +
        4740  T Value;
        +
        4741 };
        +
        4742 
        +
        4743 // Doubly linked list.
        +
        4744 template<typename T>
        +
        4745 class VmaRawList
        +
        4746 {
        +
        4747  VMA_CLASS_NO_COPY(VmaRawList)
        +
        4748 public:
        +
        4749  typedef VmaListItem<T> ItemType;
        4750 
        -
        4751  void Remove(ItemType* pItem);
        -
        4752 
        -
        4753 private:
        -
        4754  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        -
        4755  VmaPoolAllocator<ItemType> m_ItemAllocator;
        -
        4756  ItemType* m_pFront;
        -
        4757  ItemType* m_pBack;
        -
        4758  size_t m_Count;
        -
        4759 };
        -
        4760 
        -
        4761 template<typename T>
        -
        4762 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
        -
        4763  m_pAllocationCallbacks(pAllocationCallbacks),
        -
        4764  m_ItemAllocator(pAllocationCallbacks, 128),
        -
        4765  m_pFront(VMA_NULL),
        -
        4766  m_pBack(VMA_NULL),
        -
        4767  m_Count(0)
        -
        4768 {
        -
        4769 }
        -
        4770 
        -
        4771 template<typename T>
        -
        4772 VmaRawList<T>::~VmaRawList()
        -
        4773 {
        -
        4774  // Intentionally not calling Clear, because that would be unnecessary
        -
        4775  // computations to return all items to m_ItemAllocator as free.
        -
        4776 }
        +
        4751  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
        +
        4752  ~VmaRawList();
        +
        4753  void Clear();
        +
        4754 
        +
        4755  size_t GetCount() const { return m_Count; }
        +
        4756  bool IsEmpty() const { return m_Count == 0; }
        +
        4757 
        +
        4758  ItemType* Front() { return m_pFront; }
        +
        4759  const ItemType* Front() const { return m_pFront; }
        +
        4760  ItemType* Back() { return m_pBack; }
        +
        4761  const ItemType* Back() const { return m_pBack; }
        +
        4762 
        +
        4763  ItemType* PushBack();
        +
        4764  ItemType* PushFront();
        +
        4765  ItemType* PushBack(const T& value);
        +
        4766  ItemType* PushFront(const T& value);
        +
        4767  void PopBack();
        +
        4768  void PopFront();
        +
        4769 
        +
        4770  // Item can be null - it means PushBack.
        +
        4771  ItemType* InsertBefore(ItemType* pItem);
        +
        4772  // Item can be null - it means PushFront.
        +
        4773  ItemType* InsertAfter(ItemType* pItem);
        +
        4774 
        +
        4775  ItemType* InsertBefore(ItemType* pItem, const T& value);
        +
        4776  ItemType* InsertAfter(ItemType* pItem, const T& value);
        4777 
        -
        4778 template<typename T>
        -
        4779 void VmaRawList<T>::Clear()
        -
        4780 {
        -
        4781  if(IsEmpty() == false)
        -
        4782  {
        -
        4783  ItemType* pItem = m_pBack;
        -
        4784  while(pItem != VMA_NULL)
        -
        4785  {
        -
        4786  ItemType* const pPrevItem = pItem->pPrev;
        -
        4787  m_ItemAllocator.Free(pItem);
        -
        4788  pItem = pPrevItem;
        -
        4789  }
        -
        4790  m_pFront = VMA_NULL;
        -
        4791  m_pBack = VMA_NULL;
        -
        4792  m_Count = 0;
        -
        4793  }
        -
        4794 }
        -
        4795 
        -
        4796 template<typename T>
        -
        4797 VmaListItem<T>* VmaRawList<T>::PushBack()
        -
        4798 {
        -
        4799  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        -
        4800  pNewItem->pNext = VMA_NULL;
        -
        4801  if(IsEmpty())
        -
        4802  {
        -
        4803  pNewItem->pPrev = VMA_NULL;
        -
        4804  m_pFront = pNewItem;
        -
        4805  m_pBack = pNewItem;
        -
        4806  m_Count = 1;
        -
        4807  }
        -
        4808  else
        +
        4778  void Remove(ItemType* pItem);
        +
        4779 
        +
        4780 private:
        +
        4781  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        +
        4782  VmaPoolAllocator<ItemType> m_ItemAllocator;
        +
        4783  ItemType* m_pFront;
        +
        4784  ItemType* m_pBack;
        +
        4785  size_t m_Count;
        +
        4786 };
        +
        4787 
        +
        4788 template<typename T>
        +
        4789 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
        +
        4790  m_pAllocationCallbacks(pAllocationCallbacks),
        +
        4791  m_ItemAllocator(pAllocationCallbacks, 128),
        +
        4792  m_pFront(VMA_NULL),
        +
        4793  m_pBack(VMA_NULL),
        +
        4794  m_Count(0)
        +
        4795 {
        +
        4796 }
        +
        4797 
        +
        4798 template<typename T>
        +
        4799 VmaRawList<T>::~VmaRawList()
        +
        4800 {
        +
        4801  // Intentionally not calling Clear, because that would be unnecessary
        +
        4802  // computations to return all items to m_ItemAllocator as free.
        +
        4803 }
        +
        4804 
        +
        4805 template<typename T>
        +
        4806 void VmaRawList<T>::Clear()
        +
        4807 {
        +
        4808  if(IsEmpty() == false)
        4809  {
        -
        4810  pNewItem->pPrev = m_pBack;
        -
        4811  m_pBack->pNext = pNewItem;
        -
        4812  m_pBack = pNewItem;
        -
        4813  ++m_Count;
        -
        4814  }
        -
        4815  return pNewItem;
        -
        4816 }
        -
        4817 
        -
        4818 template<typename T>
        -
        4819 VmaListItem<T>* VmaRawList<T>::PushFront()
        -
        4820 {
        -
        4821  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        -
        4822  pNewItem->pPrev = VMA_NULL;
        -
        4823  if(IsEmpty())
        -
        4824  {
        -
        4825  pNewItem->pNext = VMA_NULL;
        -
        4826  m_pFront = pNewItem;
        -
        4827  m_pBack = pNewItem;
        -
        4828  m_Count = 1;
        -
        4829  }
        -
        4830  else
        -
        4831  {
        -
        4832  pNewItem->pNext = m_pFront;
        -
        4833  m_pFront->pPrev = pNewItem;
        -
        4834  m_pFront = pNewItem;
        -
        4835  ++m_Count;
        -
        4836  }
        -
        4837  return pNewItem;
        -
        4838 }
        -
        4839 
        -
        4840 template<typename T>
        -
        4841 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
        -
        4842 {
        -
        4843  ItemType* const pNewItem = PushBack();
        -
        4844  pNewItem->Value = value;
        -
        4845  return pNewItem;
        -
        4846 }
        -
        4847 
        -
        4848 template<typename T>
        -
        4849 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
        -
        4850 {
        -
        4851  ItemType* const pNewItem = PushFront();
        -
        4852  pNewItem->Value = value;
        -
        4853  return pNewItem;
        -
        4854 }
        -
        4855 
        -
        4856 template<typename T>
        -
        4857 void VmaRawList<T>::PopBack()
        -
        4858 {
        -
        4859  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4860  ItemType* const pBackItem = m_pBack;
        -
        4861  ItemType* const pPrevItem = pBackItem->pPrev;
        -
        4862  if(pPrevItem != VMA_NULL)
        -
        4863  {
        -
        4864  pPrevItem->pNext = VMA_NULL;
        -
        4865  }
        -
        4866  m_pBack = pPrevItem;
        -
        4867  m_ItemAllocator.Free(pBackItem);
        -
        4868  --m_Count;
        -
        4869 }
        -
        4870 
        -
        4871 template<typename T>
        -
        4872 void VmaRawList<T>::PopFront()
        -
        4873 {
        -
        4874  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4875  ItemType* const pFrontItem = m_pFront;
        -
        4876  ItemType* const pNextItem = pFrontItem->pNext;
        -
        4877  if(pNextItem != VMA_NULL)
        -
        4878  {
        -
        4879  pNextItem->pPrev = VMA_NULL;
        -
        4880  }
        -
        4881  m_pFront = pNextItem;
        -
        4882  m_ItemAllocator.Free(pFrontItem);
        -
        4883  --m_Count;
        -
        4884 }
        -
        4885 
        -
        4886 template<typename T>
        -
        4887 void VmaRawList<T>::Remove(ItemType* pItem)
        -
        4888 {
        -
        4889  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
        -
        4890  VMA_HEAVY_ASSERT(m_Count > 0);
        -
        4891 
        -
        4892  if(pItem->pPrev != VMA_NULL)
        -
        4893  {
        -
        4894  pItem->pPrev->pNext = pItem->pNext;
        -
        4895  }
        -
        4896  else
        -
        4897  {
        -
        4898  VMA_HEAVY_ASSERT(m_pFront == pItem);
        -
        4899  m_pFront = pItem->pNext;
        -
        4900  }
        -
        4901 
        -
        4902  if(pItem->pNext != VMA_NULL)
        -
        4903  {
        -
        4904  pItem->pNext->pPrev = pItem->pPrev;
        -
        4905  }
        -
        4906  else
        -
        4907  {
        -
        4908  VMA_HEAVY_ASSERT(m_pBack == pItem);
        -
        4909  m_pBack = pItem->pPrev;
        -
        4910  }
        -
        4911 
        -
        4912  m_ItemAllocator.Free(pItem);
        -
        4913  --m_Count;
        -
        4914 }
        -
        4915 
        -
        4916 template<typename T>
        -
        4917 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
        -
        4918 {
        -
        4919  if(pItem != VMA_NULL)
        +
        4810  ItemType* pItem = m_pBack;
        +
        4811  while(pItem != VMA_NULL)
        +
        4812  {
        +
        4813  ItemType* const pPrevItem = pItem->pPrev;
        +
        4814  m_ItemAllocator.Free(pItem);
        +
        4815  pItem = pPrevItem;
        +
        4816  }
        +
        4817  m_pFront = VMA_NULL;
        +
        4818  m_pBack = VMA_NULL;
        +
        4819  m_Count = 0;
        +
        4820  }
        +
        4821 }
        +
        4822 
        +
        4823 template<typename T>
        +
        4824 VmaListItem<T>* VmaRawList<T>::PushBack()
        +
        4825 {
        +
        4826  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        +
        4827  pNewItem->pNext = VMA_NULL;
        +
        4828  if(IsEmpty())
        +
        4829  {
        +
        4830  pNewItem->pPrev = VMA_NULL;
        +
        4831  m_pFront = pNewItem;
        +
        4832  m_pBack = pNewItem;
        +
        4833  m_Count = 1;
        +
        4834  }
        +
        4835  else
        +
        4836  {
        +
        4837  pNewItem->pPrev = m_pBack;
        +
        4838  m_pBack->pNext = pNewItem;
        +
        4839  m_pBack = pNewItem;
        +
        4840  ++m_Count;
        +
        4841  }
        +
        4842  return pNewItem;
        +
        4843 }
        +
        4844 
        +
        4845 template<typename T>
        +
        4846 VmaListItem<T>* VmaRawList<T>::PushFront()
        +
        4847 {
        +
        4848  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        +
        4849  pNewItem->pPrev = VMA_NULL;
        +
        4850  if(IsEmpty())
        +
        4851  {
        +
        4852  pNewItem->pNext = VMA_NULL;
        +
        4853  m_pFront = pNewItem;
        +
        4854  m_pBack = pNewItem;
        +
        4855  m_Count = 1;
        +
        4856  }
        +
        4857  else
        +
        4858  {
        +
        4859  pNewItem->pNext = m_pFront;
        +
        4860  m_pFront->pPrev = pNewItem;
        +
        4861  m_pFront = pNewItem;
        +
        4862  ++m_Count;
        +
        4863  }
        +
        4864  return pNewItem;
        +
        4865 }
        +
        4866 
        +
        4867 template<typename T>
        +
        4868 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
        +
        4869 {
        +
        4870  ItemType* const pNewItem = PushBack();
        +
        4871  pNewItem->Value = value;
        +
        4872  return pNewItem;
        +
        4873 }
        +
        4874 
        +
        4875 template<typename T>
        +
        4876 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
        +
        4877 {
        +
        4878  ItemType* const pNewItem = PushFront();
        +
        4879  pNewItem->Value = value;
        +
        4880  return pNewItem;
        +
        4881 }
        +
        4882 
        +
        4883 template<typename T>
        +
        4884 void VmaRawList<T>::PopBack()
        +
        4885 {
        +
        4886  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4887  ItemType* const pBackItem = m_pBack;
        +
        4888  ItemType* const pPrevItem = pBackItem->pPrev;
        +
        4889  if(pPrevItem != VMA_NULL)
        +
        4890  {
        +
        4891  pPrevItem->pNext = VMA_NULL;
        +
        4892  }
        +
        4893  m_pBack = pPrevItem;
        +
        4894  m_ItemAllocator.Free(pBackItem);
        +
        4895  --m_Count;
        +
        4896 }
        +
        4897 
        +
        4898 template<typename T>
        +
        4899 void VmaRawList<T>::PopFront()
        +
        4900 {
        +
        4901  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4902  ItemType* const pFrontItem = m_pFront;
        +
        4903  ItemType* const pNextItem = pFrontItem->pNext;
        +
        4904  if(pNextItem != VMA_NULL)
        +
        4905  {
        +
        4906  pNextItem->pPrev = VMA_NULL;
        +
        4907  }
        +
        4908  m_pFront = pNextItem;
        +
        4909  m_ItemAllocator.Free(pFrontItem);
        +
        4910  --m_Count;
        +
        4911 }
        +
        4912 
        +
        4913 template<typename T>
        +
        4914 void VmaRawList<T>::Remove(ItemType* pItem)
        +
        4915 {
        +
        4916  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
        +
        4917  VMA_HEAVY_ASSERT(m_Count > 0);
        +
        4918 
        +
        4919  if(pItem->pPrev != VMA_NULL)
        4920  {
        -
        4921  ItemType* const prevItem = pItem->pPrev;
        -
        4922  ItemType* const newItem = m_ItemAllocator.Alloc();
        -
        4923  newItem->pPrev = prevItem;
        -
        4924  newItem->pNext = pItem;
        -
        4925  pItem->pPrev = newItem;
        -
        4926  if(prevItem != VMA_NULL)
        -
        4927  {
        -
        4928  prevItem->pNext = newItem;
        -
        4929  }
        -
        4930  else
        -
        4931  {
        -
        4932  VMA_HEAVY_ASSERT(m_pFront == pItem);
        -
        4933  m_pFront = newItem;
        -
        4934  }
        -
        4935  ++m_Count;
        -
        4936  return newItem;
        +
        4921  pItem->pPrev->pNext = pItem->pNext;
        +
        4922  }
        +
        4923  else
        +
        4924  {
        +
        4925  VMA_HEAVY_ASSERT(m_pFront == pItem);
        +
        4926  m_pFront = pItem->pNext;
        +
        4927  }
        +
        4928 
        +
        4929  if(pItem->pNext != VMA_NULL)
        +
        4930  {
        +
        4931  pItem->pNext->pPrev = pItem->pPrev;
        +
        4932  }
        +
        4933  else
        +
        4934  {
        +
        4935  VMA_HEAVY_ASSERT(m_pBack == pItem);
        +
        4936  m_pBack = pItem->pPrev;
        4937  }
        -
        4938  else
        -
        4939  return PushBack();
        -
        4940 }
        -
        4941 
        -
        4942 template<typename T>
        -
        4943 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
        -
        4944 {
        -
        4945  if(pItem != VMA_NULL)
        -
        4946  {
        -
        4947  ItemType* const nextItem = pItem->pNext;
        -
        4948  ItemType* const newItem = m_ItemAllocator.Alloc();
        -
        4949  newItem->pNext = nextItem;
        -
        4950  newItem->pPrev = pItem;
        -
        4951  pItem->pNext = newItem;
        -
        4952  if(nextItem != VMA_NULL)
        -
        4953  {
        -
        4954  nextItem->pPrev = newItem;
        -
        4955  }
        -
        4956  else
        -
        4957  {
        -
        4958  VMA_HEAVY_ASSERT(m_pBack == pItem);
        -
        4959  m_pBack = newItem;
        -
        4960  }
        -
        4961  ++m_Count;
        -
        4962  return newItem;
        -
        4963  }
        -
        4964  else
        -
        4965  return PushFront();
        -
        4966 }
        -
        4967 
        -
        4968 template<typename T>
        -
        4969 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
        -
        4970 {
        -
        4971  ItemType* const newItem = InsertBefore(pItem);
        -
        4972  newItem->Value = value;
        -
        4973  return newItem;
        -
        4974 }
        -
        4975 
        -
        4976 template<typename T>
        -
        4977 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
        -
        4978 {
        -
        4979  ItemType* const newItem = InsertAfter(pItem);
        -
        4980  newItem->Value = value;
        -
        4981  return newItem;
        -
        4982 }
        -
        4983 
        -
        4984 template<typename T, typename AllocatorT>
        -
        4985 class VmaList
        -
        4986 {
        -
        4987  VMA_CLASS_NO_COPY(VmaList)
        -
        4988 public:
        -
        4989  class iterator
        -
        4990  {
        -
        4991  public:
        -
        4992  iterator() :
        -
        4993  m_pList(VMA_NULL),
        -
        4994  m_pItem(VMA_NULL)
        -
        4995  {
        -
        4996  }
        -
        4997 
        -
        4998  T& operator*() const
        -
        4999  {
        -
        5000  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        -
        5001  return m_pItem->Value;
        -
        5002  }
        -
        5003  T* operator->() const
        -
        5004  {
        -
        5005  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        -
        5006  return &m_pItem->Value;
        -
        5007  }
        -
        5008 
        -
        5009  iterator& operator++()
        -
        5010  {
        -
        5011  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        -
        5012  m_pItem = m_pItem->pNext;
        -
        5013  return *this;
        -
        5014  }
        -
        5015  iterator& operator--()
        -
        5016  {
        -
        5017  if(m_pItem != VMA_NULL)
        -
        5018  {
        -
        5019  m_pItem = m_pItem->pPrev;
        -
        5020  }
        -
        5021  else
        -
        5022  {
        -
        5023  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        -
        5024  m_pItem = m_pList->Back();
        -
        5025  }
        -
        5026  return *this;
        -
        5027  }
        -
        5028 
        -
        5029  iterator operator++(int)
        -
        5030  {
        -
        5031  iterator result = *this;
        -
        5032  ++*this;
        -
        5033  return result;
        +
        4938 
        +
        4939  m_ItemAllocator.Free(pItem);
        +
        4940  --m_Count;
        +
        4941 }
        +
        4942 
        +
        4943 template<typename T>
        +
        4944 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
        +
        4945 {
        +
        4946  if(pItem != VMA_NULL)
        +
        4947  {
        +
        4948  ItemType* const prevItem = pItem->pPrev;
        +
        4949  ItemType* const newItem = m_ItemAllocator.Alloc();
        +
        4950  newItem->pPrev = prevItem;
        +
        4951  newItem->pNext = pItem;
        +
        4952  pItem->pPrev = newItem;
        +
        4953  if(prevItem != VMA_NULL)
        +
        4954  {
        +
        4955  prevItem->pNext = newItem;
        +
        4956  }
        +
        4957  else
        +
        4958  {
        +
        4959  VMA_HEAVY_ASSERT(m_pFront == pItem);
        +
        4960  m_pFront = newItem;
        +
        4961  }
        +
        4962  ++m_Count;
        +
        4963  return newItem;
        +
        4964  }
        +
        4965  else
        +
        4966  return PushBack();
        +
        4967 }
        +
        4968 
        +
        4969 template<typename T>
        +
        4970 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
        +
        4971 {
        +
        4972  if(pItem != VMA_NULL)
        +
        4973  {
        +
        4974  ItemType* const nextItem = pItem->pNext;
        +
        4975  ItemType* const newItem = m_ItemAllocator.Alloc();
        +
        4976  newItem->pNext = nextItem;
        +
        4977  newItem->pPrev = pItem;
        +
        4978  pItem->pNext = newItem;
        +
        4979  if(nextItem != VMA_NULL)
        +
        4980  {
        +
        4981  nextItem->pPrev = newItem;
        +
        4982  }
        +
        4983  else
        +
        4984  {
        +
        4985  VMA_HEAVY_ASSERT(m_pBack == pItem);
        +
        4986  m_pBack = newItem;
        +
        4987  }
        +
        4988  ++m_Count;
        +
        4989  return newItem;
        +
        4990  }
        +
        4991  else
        +
        4992  return PushFront();
        +
        4993 }
        +
        4994 
        +
        4995 template<typename T>
        +
        4996 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
        +
        4997 {
        +
        4998  ItemType* const newItem = InsertBefore(pItem);
        +
        4999  newItem->Value = value;
        +
        5000  return newItem;
        +
        5001 }
        +
        5002 
        +
        5003 template<typename T>
        +
        5004 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
        +
        5005 {
        +
        5006  ItemType* const newItem = InsertAfter(pItem);
        +
        5007  newItem->Value = value;
        +
        5008  return newItem;
        +
        5009 }
        +
        5010 
        +
        5011 template<typename T, typename AllocatorT>
        +
        5012 class VmaList
        +
        5013 {
        +
        5014  VMA_CLASS_NO_COPY(VmaList)
        +
        5015 public:
        +
        5016  class iterator
        +
        5017  {
        +
        5018  public:
        +
        5019  iterator() :
        +
        5020  m_pList(VMA_NULL),
        +
        5021  m_pItem(VMA_NULL)
        +
        5022  {
        +
        5023  }
        +
        5024 
        +
        5025  T& operator*() const
        +
        5026  {
        +
        5027  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        +
        5028  return m_pItem->Value;
        +
        5029  }
        +
        5030  T* operator->() const
        +
        5031  {
        +
        5032  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        +
        5033  return &m_pItem->Value;
        5034  }
        -
        5035  iterator operator--(int)
        -
        5036  {
        -
        5037  iterator result = *this;
        -
        5038  --*this;
        -
        5039  return result;
        -
        5040  }
        -
        5041 
        -
        5042  bool operator==(const iterator& rhs) const
        -
        5043  {
        -
        5044  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        -
        5045  return m_pItem == rhs.m_pItem;
        -
        5046  }
        -
        5047  bool operator!=(const iterator& rhs) const
        -
        5048  {
        -
        5049  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        -
        5050  return m_pItem != rhs.m_pItem;
        -
        5051  }
        -
        5052 
        -
        5053  private:
        -
        5054  VmaRawList<T>* m_pList;
        -
        5055  VmaListItem<T>* m_pItem;
        -
        5056 
        -
        5057  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
        -
        5058  m_pList(pList),
        -
        5059  m_pItem(pItem)
        -
        5060  {
        +
        5035 
        +
        5036  iterator& operator++()
        +
        5037  {
        +
        5038  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        +
        5039  m_pItem = m_pItem->pNext;
        +
        5040  return *this;
        +
        5041  }
        +
        5042  iterator& operator--()
        +
        5043  {
        +
        5044  if(m_pItem != VMA_NULL)
        +
        5045  {
        +
        5046  m_pItem = m_pItem->pPrev;
        +
        5047  }
        +
        5048  else
        +
        5049  {
        +
        5050  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        +
        5051  m_pItem = m_pList->Back();
        +
        5052  }
        +
        5053  return *this;
        +
        5054  }
        +
        5055 
        +
        5056  iterator operator++(int)
        +
        5057  {
        +
        5058  iterator result = *this;
        +
        5059  ++*this;
        +
        5060  return result;
        5061  }
        -
        5062 
        -
        5063  friend class VmaList<T, AllocatorT>;
        -
        5064  };
        -
        5065 
        -
        5066  class const_iterator
        -
        5067  {
        -
        5068  public:
        -
        5069  const_iterator() :
        -
        5070  m_pList(VMA_NULL),
        -
        5071  m_pItem(VMA_NULL)
        -
        5072  {
        +
        5062  iterator operator--(int)
        +
        5063  {
        +
        5064  iterator result = *this;
        +
        5065  --*this;
        +
        5066  return result;
        +
        5067  }
        +
        5068 
        +
        5069  bool operator==(const iterator& rhs) const
        +
        5070  {
        +
        5071  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        +
        5072  return m_pItem == rhs.m_pItem;
        5073  }
        -
        5074 
        -
        5075  const_iterator(const iterator& src) :
        -
        5076  m_pList(src.m_pList),
        -
        5077  m_pItem(src.m_pItem)
        -
        5078  {
        -
        5079  }
        -
        5080 
        -
        5081  const T& operator*() const
        -
        5082  {
        -
        5083  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        -
        5084  return m_pItem->Value;
        -
        5085  }
        -
        5086  const T* operator->() const
        -
        5087  {
        -
        5088  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        -
        5089  return &m_pItem->Value;
        -
        5090  }
        -
        5091 
        -
        5092  const_iterator& operator++()
        -
        5093  {
        -
        5094  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        -
        5095  m_pItem = m_pItem->pNext;
        -
        5096  return *this;
        -
        5097  }
        -
        5098  const_iterator& operator--()
        +
        5074  bool operator!=(const iterator& rhs) const
        +
        5075  {
        +
        5076  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        +
        5077  return m_pItem != rhs.m_pItem;
        +
        5078  }
        +
        5079 
        +
        5080  private:
        +
        5081  VmaRawList<T>* m_pList;
        +
        5082  VmaListItem<T>* m_pItem;
        +
        5083 
        +
        5084  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
        +
        5085  m_pList(pList),
        +
        5086  m_pItem(pItem)
        +
        5087  {
        +
        5088  }
        +
        5089 
        +
        5090  friend class VmaList<T, AllocatorT>;
        +
        5091  };
        +
        5092 
        +
        5093  class const_iterator
        +
        5094  {
        +
        5095  public:
        +
        5096  const_iterator() :
        +
        5097  m_pList(VMA_NULL),
        +
        5098  m_pItem(VMA_NULL)
        5099  {
        -
        5100  if(m_pItem != VMA_NULL)
        -
        5101  {
        -
        5102  m_pItem = m_pItem->pPrev;
        -
        5103  }
        -
        5104  else
        -
        5105  {
        -
        5106  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        -
        5107  m_pItem = m_pList->Back();
        -
        5108  }
        -
        5109  return *this;
        -
        5110  }
        -
        5111 
        -
        5112  const_iterator operator++(int)
        -
        5113  {
        -
        5114  const_iterator result = *this;
        -
        5115  ++*this;
        -
        5116  return result;
        +
        5100  }
        +
        5101 
        +
        5102  const_iterator(const iterator& src) :
        +
        5103  m_pList(src.m_pList),
        +
        5104  m_pItem(src.m_pItem)
        +
        5105  {
        +
        5106  }
        +
        5107 
        +
        5108  const T& operator*() const
        +
        5109  {
        +
        5110  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        +
        5111  return m_pItem->Value;
        +
        5112  }
        +
        5113  const T* operator->() const
        +
        5114  {
        +
        5115  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        +
        5116  return &m_pItem->Value;
        5117  }
        -
        5118  const_iterator operator--(int)
        -
        5119  {
        -
        5120  const_iterator result = *this;
        -
        5121  --*this;
        -
        5122  return result;
        -
        5123  }
        -
        5124 
        -
        5125  bool operator==(const const_iterator& rhs) const
        -
        5126  {
        -
        5127  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        -
        5128  return m_pItem == rhs.m_pItem;
        -
        5129  }
        -
        5130  bool operator!=(const const_iterator& rhs) const
        -
        5131  {
        -
        5132  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        -
        5133  return m_pItem != rhs.m_pItem;
        -
        5134  }
        -
        5135 
        -
        5136  private:
        -
        5137  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
        -
        5138  m_pList(pList),
        -
        5139  m_pItem(pItem)
        +
        5118 
        +
        5119  const_iterator& operator++()
        +
        5120  {
        +
        5121  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        +
        5122  m_pItem = m_pItem->pNext;
        +
        5123  return *this;
        +
        5124  }
        +
        5125  const_iterator& operator--()
        +
        5126  {
        +
        5127  if(m_pItem != VMA_NULL)
        +
        5128  {
        +
        5129  m_pItem = m_pItem->pPrev;
        +
        5130  }
        +
        5131  else
        +
        5132  {
        +
        5133  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        +
        5134  m_pItem = m_pList->Back();
        +
        5135  }
        +
        5136  return *this;
        +
        5137  }
        +
        5138 
        +
        5139  const_iterator operator++(int)
        5140  {
        -
        5141  }
        -
        5142 
        -
        5143  const VmaRawList<T>* m_pList;
        -
        5144  const VmaListItem<T>* m_pItem;
        -
        5145 
        -
        5146  friend class VmaList<T, AllocatorT>;
        -
        5147  };
        -
        5148 
        -
        5149  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
        -
        5150 
        -
        5151  bool empty() const { return m_RawList.IsEmpty(); }
        -
        5152  size_t size() const { return m_RawList.GetCount(); }
        -
        5153 
        -
        5154  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
        -
        5155  iterator end() { return iterator(&m_RawList, VMA_NULL); }
        -
        5156 
        -
        5157  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
        -
        5158  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
        -
        5159 
        -
        5160  void clear() { m_RawList.Clear(); }
        -
        5161  void push_back(const T& value) { m_RawList.PushBack(value); }
        -
        5162  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
        -
        5163  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
        -
        5164 
        -
        5165 private:
        -
        5166  VmaRawList<T> m_RawList;
        -
        5167 };
        -
        5168 
        -
        5169 #endif // #if VMA_USE_STL_LIST
        -
        5170 
        -
        5172 // class VmaMap
        -
        5173 
        -
        5174 // Unused in this version.
        -
        5175 #if 0
        -
        5176 
        -
        5177 #if VMA_USE_STL_UNORDERED_MAP
        -
        5178 
        -
        5179 #define VmaPair std::pair
        +
        5141  const_iterator result = *this;
        +
        5142  ++*this;
        +
        5143  return result;
        +
        5144  }
        +
        5145  const_iterator operator--(int)
        +
        5146  {
        +
        5147  const_iterator result = *this;
        +
        5148  --*this;
        +
        5149  return result;
        +
        5150  }
        +
        5151 
        +
        5152  bool operator==(const const_iterator& rhs) const
        +
        5153  {
        +
        5154  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        +
        5155  return m_pItem == rhs.m_pItem;
        +
        5156  }
        +
        5157  bool operator!=(const const_iterator& rhs) const
        +
        5158  {
        +
        5159  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        +
        5160  return m_pItem != rhs.m_pItem;
        +
        5161  }
        +
        5162 
        +
        5163  private:
        +
        5164  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
        +
        5165  m_pList(pList),
        +
        5166  m_pItem(pItem)
        +
        5167  {
        +
        5168  }
        +
        5169 
        +
        5170  const VmaRawList<T>* m_pList;
        +
        5171  const VmaListItem<T>* m_pItem;
        +
        5172 
        +
        5173  friend class VmaList<T, AllocatorT>;
        +
        5174  };
        +
        5175 
        +
        5176  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
        +
        5177 
        +
        5178  bool empty() const { return m_RawList.IsEmpty(); }
        +
        5179  size_t size() const { return m_RawList.GetCount(); }
        5180 
        -
        5181 #define VMA_MAP_TYPE(KeyT, ValueT) \
        -
        5182  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
        +
        5181  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
        +
        5182  iterator end() { return iterator(&m_RawList, VMA_NULL); }
        5183 
        -
        5184 #else // #if VMA_USE_STL_UNORDERED_MAP
        -
        5185 
        -
        5186 template<typename T1, typename T2>
        -
        5187 struct VmaPair
        -
        5188 {
        -
        5189  T1 first;
        -
        5190  T2 second;
        +
        5184  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
        +
        5185  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
        +
        5186 
        +
        5187  void clear() { m_RawList.Clear(); }
        +
        5188  void push_back(const T& value) { m_RawList.PushBack(value); }
        +
        5189  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
        +
        5190  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
        5191 
        -
        5192  VmaPair() : first(), second() { }
        -
        5193  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
        +
        5192 private:
        +
        5193  VmaRawList<T> m_RawList;
        5194 };
        5195 
        -
        5196 /* Class compatible with subset of interface of std::unordered_map.
        -
        5197 KeyT, ValueT must be POD because they will be stored in VmaVector.
        -
        5198 */
        -
        5199 template<typename KeyT, typename ValueT>
        -
        5200 class VmaMap
        -
        5201 {
        -
        5202 public:
        -
        5203  typedef VmaPair<KeyT, ValueT> PairType;
        -
        5204  typedef PairType* iterator;
        +
        5196 #endif // #if VMA_USE_STL_LIST
        +
        5197 
        +
        5199 // class VmaMap
        +
        5200 
        +
        5201 // Unused in this version.
        +
        5202 #if 0
        +
        5203 
        +
        5204 #if VMA_USE_STL_UNORDERED_MAP
        5205 
        -
        5206  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
        +
        5206 #define VmaPair std::pair
        5207 
        -
        5208  iterator begin() { return m_Vector.begin(); }
        -
        5209  iterator end() { return m_Vector.end(); }
        +
        5208 #define VMA_MAP_TYPE(KeyT, ValueT) \
        +
        5209  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
        5210 
        -
        5211  void insert(const PairType& pair);
        -
        5212  iterator find(const KeyT& key);
        -
        5213  void erase(iterator it);
        -
        5214 
        -
        5215 private:
        -
        5216  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
        -
        5217 };
        +
        5211 #else // #if VMA_USE_STL_UNORDERED_MAP
        +
        5212 
        +
        5213 template<typename T1, typename T2>
        +
        5214 struct VmaPair
        +
        5215 {
        +
        5216  T1 first;
        +
        5217  T2 second;
        5218 
        -
        5219 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
        -
        5220 
        -
        5221 template<typename FirstT, typename SecondT>
        -
        5222 struct VmaPairFirstLess
        -
        5223 {
        -
        5224  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
        -
        5225  {
        -
        5226  return lhs.first < rhs.first;
        -
        5227  }
        -
        5228  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
        -
        5229  {
        -
        5230  return lhs.first < rhsFirst;
        -
        5231  }
        -
        5232 };
        -
        5233 
        -
        5234 template<typename KeyT, typename ValueT>
        -
        5235 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
        -
        5236 {
        -
        5237  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        -
        5238  m_Vector.data(),
        -
        5239  m_Vector.data() + m_Vector.size(),
        -
        5240  pair,
        -
        5241  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
        -
        5242  VmaVectorInsert(m_Vector, indexToInsert, pair);
        -
        5243 }
        -
        5244 
        -
        5245 template<typename KeyT, typename ValueT>
        -
        5246 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
        -
        5247 {
        -
        5248  PairType* it = VmaBinaryFindFirstNotLess(
        -
        5249  m_Vector.data(),
        -
        5250  m_Vector.data() + m_Vector.size(),
        -
        5251  key,
        -
        5252  VmaPairFirstLess<KeyT, ValueT>());
        -
        5253  if((it != m_Vector.end()) && (it->first == key))
        -
        5254  {
        -
        5255  return it;
        -
        5256  }
        -
        5257  else
        -
        5258  {
        -
        5259  return m_Vector.end();
        -
        5260  }
        -
        5261 }
        -
        5262 
        -
        5263 template<typename KeyT, typename ValueT>
        -
        5264 void VmaMap<KeyT, ValueT>::erase(iterator it)
        -
        5265 {
        -
        5266  VmaVectorRemove(m_Vector, it - m_Vector.begin());
        -
        5267 }
        -
        5268 
        -
        5269 #endif // #if VMA_USE_STL_UNORDERED_MAP
        -
        5270 
        -
        5271 #endif // #if 0
        -
        5272 
        -
        5274 
        -
        5275 class VmaDeviceMemoryBlock;
        -
        5276 
        -
        5277 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
        -
        5278 
        -
        5279 struct VmaAllocation_T
        -
        5280 {
        -
        5281 private:
        -
        5282  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
        -
        5283 
        -
        5284  enum FLAGS
        +
        5219  VmaPair() : first(), second() { }
        +
        5220  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
        +
        5221 };
        +
        5222 
        +
        5223 /* Class compatible with subset of interface of std::unordered_map.
        +
        5224 KeyT, ValueT must be POD because they will be stored in VmaVector.
        +
        5225 */
        +
        5226 template<typename KeyT, typename ValueT>
        +
        5227 class VmaMap
        +
        5228 {
        +
        5229 public:
        +
        5230  typedef VmaPair<KeyT, ValueT> PairType;
        +
        5231  typedef PairType* iterator;
        +
        5232 
        +
        5233  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
        +
        5234 
        +
        5235  iterator begin() { return m_Vector.begin(); }
        +
        5236  iterator end() { return m_Vector.end(); }
        +
        5237 
        +
        5238  void insert(const PairType& pair);
        +
        5239  iterator find(const KeyT& key);
        +
        5240  void erase(iterator it);
        +
        5241 
        +
        5242 private:
        +
        5243  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
        +
        5244 };
        +
        5245 
        +
        5246 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
        +
        5247 
        +
        5248 template<typename FirstT, typename SecondT>
        +
        5249 struct VmaPairFirstLess
        +
        5250 {
        +
        5251  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
        +
        5252  {
        +
        5253  return lhs.first < rhs.first;
        +
        5254  }
        +
        5255  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
        +
        5256  {
        +
        5257  return lhs.first < rhsFirst;
        +
        5258  }
        +
        5259 };
        +
        5260 
        +
        5261 template<typename KeyT, typename ValueT>
        +
        5262 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
        +
        5263 {
        +
        5264  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        +
        5265  m_Vector.data(),
        +
        5266  m_Vector.data() + m_Vector.size(),
        +
        5267  pair,
        +
        5268  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
        +
        5269  VmaVectorInsert(m_Vector, indexToInsert, pair);
        +
        5270 }
        +
        5271 
        +
        5272 template<typename KeyT, typename ValueT>
        +
        5273 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
        +
        5274 {
        +
        5275  PairType* it = VmaBinaryFindFirstNotLess(
        +
        5276  m_Vector.data(),
        +
        5277  m_Vector.data() + m_Vector.size(),
        +
        5278  key,
        +
        5279  VmaPairFirstLess<KeyT, ValueT>());
        +
        5280  if((it != m_Vector.end()) && (it->first == key))
        +
        5281  {
        +
        5282  return it;
        +
        5283  }
        +
        5284  else
        5285  {
        -
        5286  FLAG_USER_DATA_STRING = 0x01,
        -
        5287  };
        -
        5288 
        -
        5289 public:
        -
        5290  enum ALLOCATION_TYPE
        -
        5291  {
        -
        5292  ALLOCATION_TYPE_NONE,
        -
        5293  ALLOCATION_TYPE_BLOCK,
        -
        5294  ALLOCATION_TYPE_DEDICATED,
        -
        5295  };
        -
        5296 
        -
        5297  /*
        -
        5298  This struct is allocated using VmaPoolAllocator.
        -
        5299  */
        -
        5300 
        -
        5301  void Ctor(uint32_t currentFrameIndex, bool userDataString)
        -
        5302  {
        -
        5303  m_Alignment = 1;
        -
        5304  m_Size = 0;
        -
        5305  m_MemoryTypeIndex = 0;
        -
        5306  m_pUserData = VMA_NULL;
        -
        5307  m_LastUseFrameIndex = currentFrameIndex;
        -
        5308  m_Type = (uint8_t)ALLOCATION_TYPE_NONE;
        -
        5309  m_SuballocationType = (uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN;
        -
        5310  m_MapCount = 0;
        -
        5311  m_Flags = userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0;
        -
        5312 
        -
        5313 #if VMA_STATS_STRING_ENABLED
        -
        5314  m_CreationFrameIndex = currentFrameIndex;
        -
        5315  m_BufferImageUsage = 0;
        -
        5316 #endif
        -
        5317  }
        -
        5318 
        -
        5319  void Dtor()
        -
        5320  {
        -
        5321  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
        -
        5322 
        -
        5323  // Check if owned string was freed.
        -
        5324  VMA_ASSERT(m_pUserData == VMA_NULL);
        -
        5325  }
        -
        5326 
        -
        5327  void InitBlockAllocation(
        -
        5328  VmaDeviceMemoryBlock* block,
        -
        5329  VkDeviceSize offset,
        -
        5330  VkDeviceSize alignment,
        -
        5331  VkDeviceSize size,
        -
        5332  uint32_t memoryTypeIndex,
        -
        5333  VmaSuballocationType suballocationType,
        -
        5334  bool mapped,
        -
        5335  bool canBecomeLost)
        -
        5336  {
        -
        5337  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        -
        5338  VMA_ASSERT(block != VMA_NULL);
        -
        5339  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        -
        5340  m_Alignment = alignment;
        -
        5341  m_Size = size;
        -
        5342  m_MemoryTypeIndex = memoryTypeIndex;
        -
        5343  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        -
        5344  m_SuballocationType = (uint8_t)suballocationType;
        -
        5345  m_BlockAllocation.m_Block = block;
        -
        5346  m_BlockAllocation.m_Offset = offset;
        -
        5347  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
        -
        5348  }
        +
        5286  return m_Vector.end();
        +
        5287  }
        +
        5288 }
        +
        5289 
        +
        5290 template<typename KeyT, typename ValueT>
        +
        5291 void VmaMap<KeyT, ValueT>::erase(iterator it)
        +
        5292 {
        +
        5293  VmaVectorRemove(m_Vector, it - m_Vector.begin());
        +
        5294 }
        +
        5295 
        +
        5296 #endif // #if VMA_USE_STL_UNORDERED_MAP
        +
        5297 
        +
        5298 #endif // #if 0
        +
        5299 
        +
        5301 
        +
        5302 class VmaDeviceMemoryBlock;
        +
        5303 
        +
        5304 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
        +
        5305 
        +
        5306 struct VmaAllocation_T
        +
        5307 {
        +
        5308 private:
        +
        5309  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
        +
        5310 
        +
        5311  enum FLAGS
        +
        5312  {
        +
        5313  FLAG_USER_DATA_STRING = 0x01,
        +
        5314  };
        +
        5315 
        +
        5316 public:
        +
        5317  enum ALLOCATION_TYPE
        +
        5318  {
        +
        5319  ALLOCATION_TYPE_NONE,
        +
        5320  ALLOCATION_TYPE_BLOCK,
        +
        5321  ALLOCATION_TYPE_DEDICATED,
        +
        5322  };
        +
        5323 
        +
        5324  /*
        +
        5325  This struct is allocated using VmaPoolAllocator.
        +
        5326  */
        +
        5327 
        +
        5328  void Ctor(uint32_t currentFrameIndex, bool userDataString)
        +
        5329  {
        +
        5330  m_Alignment = 1;
        +
        5331  m_Size = 0;
        +
        5332  m_MemoryTypeIndex = 0;
        +
        5333  m_pUserData = VMA_NULL;
        +
        5334  m_LastUseFrameIndex = currentFrameIndex;
        +
        5335  m_Type = (uint8_t)ALLOCATION_TYPE_NONE;
        +
        5336  m_SuballocationType = (uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN;
        +
        5337  m_MapCount = 0;
        +
        5338  m_Flags = userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0;
        +
        5339 
        +
        5340 #if VMA_STATS_STRING_ENABLED
        +
        5341  m_CreationFrameIndex = currentFrameIndex;
        +
        5342  m_BufferImageUsage = 0;
        +
        5343 #endif
        +
        5344  }
        +
        5345 
        +
        5346  void Dtor()
        +
        5347  {
        +
        5348  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
        5349 
        -
        5350  void InitLost()
        -
        5351  {
        -
        5352  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        -
        5353  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
        -
        5354  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        -
        5355  m_MemoryTypeIndex = 0;
        -
        5356  m_BlockAllocation.m_Block = VMA_NULL;
        -
        5357  m_BlockAllocation.m_Offset = 0;
        -
        5358  m_BlockAllocation.m_CanBecomeLost = true;
        -
        5359  }
        -
        5360 
        -
        5361  void ChangeBlockAllocation(
        -
        5362  VmaAllocator hAllocator,
        -
        5363  VmaDeviceMemoryBlock* block,
        -
        5364  VkDeviceSize offset);
        -
        5365 
        -
        5366  void ChangeOffset(VkDeviceSize newOffset);
        -
        5367 
        -
        5368  // pMappedData not null means allocation is created with MAPPED flag.
        -
        5369  void InitDedicatedAllocation(
        -
        5370  uint32_t memoryTypeIndex,
        -
        5371  VkDeviceMemory hMemory,
        -
        5372  VmaSuballocationType suballocationType,
        -
        5373  void* pMappedData,
        -
        5374  VkDeviceSize size)
        -
        5375  {
        -
        5376  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        -
        5377  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
        -
        5378  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
        -
        5379  m_Alignment = 0;
        -
        5380  m_Size = size;
        -
        5381  m_MemoryTypeIndex = memoryTypeIndex;
        -
        5382  m_SuballocationType = (uint8_t)suballocationType;
        -
        5383  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        -
        5384  m_DedicatedAllocation.m_hMemory = hMemory;
        -
        5385  m_DedicatedAllocation.m_pMappedData = pMappedData;
        +
        5350  // Check if owned string was freed.
        +
        5351  VMA_ASSERT(m_pUserData == VMA_NULL);
        +
        5352  }
        +
        5353 
        +
        5354  void InitBlockAllocation(
        +
        5355  VmaDeviceMemoryBlock* block,
        +
        5356  VkDeviceSize offset,
        +
        5357  VkDeviceSize alignment,
        +
        5358  VkDeviceSize size,
        +
        5359  uint32_t memoryTypeIndex,
        +
        5360  VmaSuballocationType suballocationType,
        +
        5361  bool mapped,
        +
        5362  bool canBecomeLost)
        +
        5363  {
        +
        5364  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        +
        5365  VMA_ASSERT(block != VMA_NULL);
        +
        5366  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        +
        5367  m_Alignment = alignment;
        +
        5368  m_Size = size;
        +
        5369  m_MemoryTypeIndex = memoryTypeIndex;
        +
        5370  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        +
        5371  m_SuballocationType = (uint8_t)suballocationType;
        +
        5372  m_BlockAllocation.m_Block = block;
        +
        5373  m_BlockAllocation.m_Offset = offset;
        +
        5374  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
        +
        5375  }
        +
        5376 
        +
        5377  void InitLost()
        +
        5378  {
        +
        5379  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        +
        5380  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
        +
        5381  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        +
        5382  m_MemoryTypeIndex = 0;
        +
        5383  m_BlockAllocation.m_Block = VMA_NULL;
        +
        5384  m_BlockAllocation.m_Offset = 0;
        +
        5385  m_BlockAllocation.m_CanBecomeLost = true;
        5386  }
        5387 
        -
        5388  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
        -
        5389  VkDeviceSize GetAlignment() const { return m_Alignment; }
        -
        5390  VkDeviceSize GetSize() const { return m_Size; }
        -
        5391  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
        -
        5392  void* GetUserData() const { return m_pUserData; }
        -
        5393  void SetUserData(VmaAllocator hAllocator, void* pUserData);
        -
        5394  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
        -
        5395 
        -
        5396  VmaDeviceMemoryBlock* GetBlock() const
        -
        5397  {
        -
        5398  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        -
        5399  return m_BlockAllocation.m_Block;
        -
        5400  }
        -
        5401  VkDeviceSize GetOffset() const;
        -
        5402  VkDeviceMemory GetMemory() const;
        -
        5403  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        -
        5404  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
        -
        5405  void* GetMappedData() const;
        -
        5406  bool CanBecomeLost() const;
        -
        5407 
        -
        5408  uint32_t GetLastUseFrameIndex() const
        -
        5409  {
        -
        5410  return m_LastUseFrameIndex.load();
        -
        5411  }
        -
        5412  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
        -
        5413  {
        -
        5414  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
        -
        5415  }
        -
        5416  /*
        -
        5417  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
        -
        5418  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
        -
        5419  - Else, returns false.
        -
        5420 
        -
        5421  If hAllocation is already lost, assert - you should not call it then.
        -
        5422  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
        -
        5423  */
        -
        5424  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        -
        5425 
        -
        5426  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
        -
        5427  {
        -
        5428  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
        -
        5429  outInfo.blockCount = 1;
        -
        5430  outInfo.allocationCount = 1;
        -
        5431  outInfo.unusedRangeCount = 0;
        -
        5432  outInfo.usedBytes = m_Size;
        -
        5433  outInfo.unusedBytes = 0;
        -
        5434  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
        -
        5435  outInfo.unusedRangeSizeMin = UINT64_MAX;
        -
        5436  outInfo.unusedRangeSizeMax = 0;
        -
        5437  }
        -
        5438 
        -
        5439  void BlockAllocMap();
        -
        5440  void BlockAllocUnmap();
        -
        5441  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
        -
        5442  void DedicatedAllocUnmap(VmaAllocator hAllocator);
        -
        5443 
        -
        5444 #if VMA_STATS_STRING_ENABLED
        -
        5445  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
        -
        5446  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
        -
        5447 
        -
        5448  void InitBufferImageUsage(uint32_t bufferImageUsage)
        -
        5449  {
        -
        5450  VMA_ASSERT(m_BufferImageUsage == 0);
        -
        5451  m_BufferImageUsage = bufferImageUsage;
        -
        5452  }
        -
        5453 
        -
        5454  void PrintParameters(class VmaJsonWriter& json) const;
        -
        5455 #endif
        -
        5456 
        -
        5457 private:
        -
        5458  VkDeviceSize m_Alignment;
        -
        5459  VkDeviceSize m_Size;
        -
        5460  void* m_pUserData;
        -
        5461  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
        -
        5462  uint32_t m_MemoryTypeIndex;
        -
        5463  uint8_t m_Type; // ALLOCATION_TYPE
        -
        5464  uint8_t m_SuballocationType; // VmaSuballocationType
        -
        5465  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
        -
        5466  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
        -
        5467  uint8_t m_MapCount;
        -
        5468  uint8_t m_Flags; // enum FLAGS
        -
        5469 
        -
        5470  // Allocation out of VmaDeviceMemoryBlock.
        -
        5471  struct BlockAllocation
        -
        5472  {
        -
        5473  VmaDeviceMemoryBlock* m_Block;
        -
        5474  VkDeviceSize m_Offset;
        -
        5475  bool m_CanBecomeLost;
        -
        5476  };
        -
        5477 
        -
        5478  // Allocation for an object that has its own private VkDeviceMemory.
        -
        5479  struct DedicatedAllocation
        -
        5480  {
        -
        5481  VkDeviceMemory m_hMemory;
        -
        5482  void* m_pMappedData; // Not null means memory is mapped.
        -
        5483  };
        -
        5484 
        -
        5485  union
        -
        5486  {
        -
        5487  // Allocation out of VmaDeviceMemoryBlock.
        -
        5488  BlockAllocation m_BlockAllocation;
        -
        5489  // Allocation for an object that has its own private VkDeviceMemory.
        -
        5490  DedicatedAllocation m_DedicatedAllocation;
        -
        5491  };
        -
        5492 
        -
        5493 #if VMA_STATS_STRING_ENABLED
        -
        5494  uint32_t m_CreationFrameIndex;
        -
        5495  uint32_t m_BufferImageUsage; // 0 if unknown.
        -
        5496 #endif
        -
        5497 
        -
        5498  void FreeUserDataString(VmaAllocator hAllocator);
        -
        5499 };
        -
        5500 
        -
        5501 /*
        -
        5502 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
        -
        5503 allocated memory block or free.
        -
        5504 */
        -
        5505 struct VmaSuballocation
        -
        5506 {
        -
        5507  VkDeviceSize offset;
        -
        5508  VkDeviceSize size;
        -
        5509  VmaAllocation hAllocation;
        -
        5510  VmaSuballocationType type;
        -
        5511 };
        -
        5512 
        -
        5513 // Comparator for offsets.
        -
        5514 struct VmaSuballocationOffsetLess
        -
        5515 {
        -
        5516  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        -
        5517  {
        -
        5518  return lhs.offset < rhs.offset;
        -
        5519  }
        -
        5520 };
        -
        5521 struct VmaSuballocationOffsetGreater
        -
        5522 {
        -
        5523  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        -
        5524  {
        -
        5525  return lhs.offset > rhs.offset;
        -
        5526  }
        -
        5527 };
        -
        5528 
        -
        5529 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
        -
        5530 
        -
        5531 // Cost of one additional allocation lost, as equivalent in bytes.
        -
        5532 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
        -
        5533 
        -
        5534 enum class VmaAllocationRequestType
        -
        5535 {
        -
        5536  Normal,
        -
        5537  // Used by "Linear" algorithm.
        -
        5538  UpperAddress,
        -
        5539  EndOf1st,
        -
        5540  EndOf2nd,
        -
        5541 };
        -
        5542 
        -
        5543 /*
        -
        5544 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
        -
        5545 
        -
        5546 If canMakeOtherLost was false:
        -
        5547 - item points to a FREE suballocation.
        -
        5548 - itemsToMakeLostCount is 0.
        -
        5549 
        -
        5550 If canMakeOtherLost was true:
        -
        5551 - item points to first of sequence of suballocations, which are either FREE,
        -
        5552  or point to VmaAllocations that can become lost.
        -
        5553 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
        -
        5554  the requested allocation to succeed.
        -
        5555 */
        -
        5556 struct VmaAllocationRequest
        -
        5557 {
        -
        5558  VkDeviceSize offset;
        -
        5559  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
        -
        5560  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
        -
        5561  VmaSuballocationList::iterator item;
        -
        5562  size_t itemsToMakeLostCount;
        -
        5563  void* customData;
        -
        5564  VmaAllocationRequestType type;
        -
        5565 
        -
        5566  VkDeviceSize CalcCost() const
        -
        5567  {
        -
        5568  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
        -
        5569  }
        -
        5570 };
        -
        5571 
        -
        5572 /*
        -
        5573 Data structure used for bookkeeping of allocations and unused ranges of memory
        -
        5574 in a single VkDeviceMemory block.
        -
        5575 */
        -
        5576 class VmaBlockMetadata
        -
        5577 {
        -
        5578 public:
        -
        5579  VmaBlockMetadata(VmaAllocator hAllocator);
        -
        5580  virtual ~VmaBlockMetadata() { }
        -
        5581  virtual void Init(VkDeviceSize size) { m_Size = size; }
        -
        5582 
        -
        5583  // Validates all data structures inside this object. If not valid, returns false.
        -
        5584  virtual bool Validate() const = 0;
        -
        5585  VkDeviceSize GetSize() const { return m_Size; }
        -
        5586  virtual size_t GetAllocationCount() const = 0;
        -
        5587  virtual VkDeviceSize GetSumFreeSize() const = 0;
        -
        5588  virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;
        -
        5589  // Returns true if this block is empty - contains only single free suballocation.
        -
        5590  virtual bool IsEmpty() const = 0;
        -
        5591 
        -
        5592  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;
        -
        5593  // Shouldn't modify blockCount.
        -
        5594  virtual void AddPoolStats(VmaPoolStats& inoutStats) const = 0;
        -
        5595 
        -
        5596 #if VMA_STATS_STRING_ENABLED
        -
        5597  virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
        -
        5598 #endif
        -
        5599 
        -
        5600  // Tries to find a place for suballocation with given parameters inside this block.
        -
        5601  // If succeeded, fills pAllocationRequest and returns true.
        -
        5602  // If failed, returns false.
        -
        5603  virtual bool CreateAllocationRequest(
        -
        5604  uint32_t currentFrameIndex,
        -
        5605  uint32_t frameInUseCount,
        -
        5606  VkDeviceSize bufferImageGranularity,
        -
        5607  VkDeviceSize allocSize,
        -
        5608  VkDeviceSize allocAlignment,
        -
        5609  bool upperAddress,
        -
        5610  VmaSuballocationType allocType,
        -
        5611  bool canMakeOtherLost,
        -
        5612  // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.
        -
        5613  uint32_t strategy,
        -
        5614  VmaAllocationRequest* pAllocationRequest) = 0;
        -
        5615 
        -
        5616  virtual bool MakeRequestedAllocationsLost(
        -
        5617  uint32_t currentFrameIndex,
        -
        5618  uint32_t frameInUseCount,
        -
        5619  VmaAllocationRequest* pAllocationRequest) = 0;
        -
        5620 
        -
        5621  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 0;
        +
        5388  void ChangeBlockAllocation(
        +
        5389  VmaAllocator hAllocator,
        +
        5390  VmaDeviceMemoryBlock* block,
        +
        5391  VkDeviceSize offset);
        +
        5392 
        +
        5393  void ChangeOffset(VkDeviceSize newOffset);
        +
        5394 
        +
        5395  // pMappedData not null means allocation is created with MAPPED flag.
        +
        5396  void InitDedicatedAllocation(
        +
        5397  uint32_t memoryTypeIndex,
        +
        5398  VkDeviceMemory hMemory,
        +
        5399  VmaSuballocationType suballocationType,
        +
        5400  void* pMappedData,
        +
        5401  VkDeviceSize size)
        +
        5402  {
        +
        5403  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        +
        5404  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
        +
        5405  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
        +
        5406  m_Alignment = 0;
        +
        5407  m_Size = size;
        +
        5408  m_MemoryTypeIndex = memoryTypeIndex;
        +
        5409  m_SuballocationType = (uint8_t)suballocationType;
        +
        5410  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        +
        5411  m_DedicatedAllocation.m_hMemory = hMemory;
        +
        5412  m_DedicatedAllocation.m_pMappedData = pMappedData;
        +
        5413  }
        +
        5414 
        +
        5415  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
        +
        5416  VkDeviceSize GetAlignment() const { return m_Alignment; }
        +
        5417  VkDeviceSize GetSize() const { return m_Size; }
        +
        5418  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
        +
        5419  void* GetUserData() const { return m_pUserData; }
        +
        5420  void SetUserData(VmaAllocator hAllocator, void* pUserData);
        +
        5421  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
        +
        5422 
        +
        5423  VmaDeviceMemoryBlock* GetBlock() const
        +
        5424  {
        +
        5425  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        +
        5426  return m_BlockAllocation.m_Block;
        +
        5427  }
        +
        5428  VkDeviceSize GetOffset() const;
        +
        5429  VkDeviceMemory GetMemory() const;
        +
        5430  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        +
        5431  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
        +
        5432  void* GetMappedData() const;
        +
        5433  bool CanBecomeLost() const;
        +
        5434 
        +
        5435  uint32_t GetLastUseFrameIndex() const
        +
        5436  {
        +
        5437  return m_LastUseFrameIndex.load();
        +
        5438  }
        +
        5439  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
        +
        5440  {
        +
        5441  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
        +
        5442  }
        +
        5443  /*
        +
        5444  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
        +
        5445  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
        +
        5446  - Else, returns false.
        +
        5447 
        +
        5448  If hAllocation is already lost, assert - you should not call it then.
        +
        5449  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
        +
        5450  */
        +
        5451  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        +
        5452 
        +
        5453  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
        +
        5454  {
        +
        5455  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
        +
        5456  outInfo.blockCount = 1;
        +
        5457  outInfo.allocationCount = 1;
        +
        5458  outInfo.unusedRangeCount = 0;
        +
        5459  outInfo.usedBytes = m_Size;
        +
        5460  outInfo.unusedBytes = 0;
        +
        5461  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
        +
        5462  outInfo.unusedRangeSizeMin = UINT64_MAX;
        +
        5463  outInfo.unusedRangeSizeMax = 0;
        +
        5464  }
        +
        5465 
        +
        5466  void BlockAllocMap();
        +
        5467  void BlockAllocUnmap();
        +
        5468  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
        +
        5469  void DedicatedAllocUnmap(VmaAllocator hAllocator);
        +
        5470 
        +
        5471 #if VMA_STATS_STRING_ENABLED
        +
        5472  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
        +
        5473  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
        +
        5474 
        +
        5475  void InitBufferImageUsage(uint32_t bufferImageUsage)
        +
        5476  {
        +
        5477  VMA_ASSERT(m_BufferImageUsage == 0);
        +
        5478  m_BufferImageUsage = bufferImageUsage;
        +
        5479  }
        +
        5480 
        +
        5481  void PrintParameters(class VmaJsonWriter& json) const;
        +
        5482 #endif
        +
        5483 
        +
        5484 private:
        +
        5485  VkDeviceSize m_Alignment;
        +
        5486  VkDeviceSize m_Size;
        +
        5487  void* m_pUserData;
        +
        5488  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
        +
        5489  uint32_t m_MemoryTypeIndex;
        +
        5490  uint8_t m_Type; // ALLOCATION_TYPE
        +
        5491  uint8_t m_SuballocationType; // VmaSuballocationType
        +
        5492  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
        +
        5493  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
        +
        5494  uint8_t m_MapCount;
        +
        5495  uint8_t m_Flags; // enum FLAGS
        +
        5496 
        +
        5497  // Allocation out of VmaDeviceMemoryBlock.
        +
        5498  struct BlockAllocation
        +
        5499  {
        +
        5500  VmaDeviceMemoryBlock* m_Block;
        +
        5501  VkDeviceSize m_Offset;
        +
        5502  bool m_CanBecomeLost;
        +
        5503  };
        +
        5504 
        +
        5505  // Allocation for an object that has its own private VkDeviceMemory.
        +
        5506  struct DedicatedAllocation
        +
        5507  {
        +
        5508  VkDeviceMemory m_hMemory;
        +
        5509  void* m_pMappedData; // Not null means memory is mapped.
        +
        5510  };
        +
        5511 
        +
        5512  union
        +
        5513  {
        +
        5514  // Allocation out of VmaDeviceMemoryBlock.
        +
        5515  BlockAllocation m_BlockAllocation;
        +
        5516  // Allocation for an object that has its own private VkDeviceMemory.
        +
        5517  DedicatedAllocation m_DedicatedAllocation;
        +
        5518  };
        +
        5519 
        +
        5520 #if VMA_STATS_STRING_ENABLED
        +
        5521  uint32_t m_CreationFrameIndex;
        +
        5522  uint32_t m_BufferImageUsage; // 0 if unknown.
        +
        5523 #endif
        +
        5524 
        +
        5525  void FreeUserDataString(VmaAllocator hAllocator);
        +
        5526 };
        +
        5527 
        +
        5528 /*
        +
        5529 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
        +
        5530 allocated memory block or free.
        +
        5531 */
        +
        5532 struct VmaSuballocation
        +
        5533 {
        +
        5534  VkDeviceSize offset;
        +
        5535  VkDeviceSize size;
        +
        5536  VmaAllocation hAllocation;
        +
        5537  VmaSuballocationType type;
        +
        5538 };
        +
        5539 
        +
        5540 // Comparator for offsets.
        +
        5541 struct VmaSuballocationOffsetLess
        +
        5542 {
        +
        5543  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        +
        5544  {
        +
        5545  return lhs.offset < rhs.offset;
        +
        5546  }
        +
        5547 };
        +
        5548 struct VmaSuballocationOffsetGreater
        +
        5549 {
        +
        5550  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        +
        5551  {
        +
        5552  return lhs.offset > rhs.offset;
        +
        5553  }
        +
        5554 };
        +
        5555 
        +
        5556 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
        +
        5557 
        +
        5558 // Cost of one additional allocation lost, as equivalent in bytes.
        +
        5559 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
        +
        5560 
        +
        5561 enum class VmaAllocationRequestType
        +
        5562 {
        +
        5563  Normal,
        +
        5564  // Used by "Linear" algorithm.
        +
        5565  UpperAddress,
        +
        5566  EndOf1st,
        +
        5567  EndOf2nd,
        +
        5568 };
        +
        5569 
        +
        5570 /*
        +
        5571 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
        +
        5572 
        +
        5573 If canMakeOtherLost was false:
        +
        5574 - item points to a FREE suballocation.
        +
        5575 - itemsToMakeLostCount is 0.
        +
        5576 
        +
        5577 If canMakeOtherLost was true:
        +
        5578 - item points to first of sequence of suballocations, which are either FREE,
        +
        5579  or point to VmaAllocations that can become lost.
        +
        5580 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
        +
        5581  the requested allocation to succeed.
        +
        5582 */
        +
        5583 struct VmaAllocationRequest
        +
        5584 {
        +
        5585  VkDeviceSize offset;
        +
        5586  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
        +
        5587  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
        +
        5588  VmaSuballocationList::iterator item;
        +
        5589  size_t itemsToMakeLostCount;
        +
        5590  void* customData;
        +
        5591  VmaAllocationRequestType type;
        +
        5592 
        +
        5593  VkDeviceSize CalcCost() const
        +
        5594  {
        +
        5595  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
        +
        5596  }
        +
        5597 };
        +
        5598 
        +
        5599 /*
        +
        5600 Data structure used for bookkeeping of allocations and unused ranges of memory
        +
        5601 in a single VkDeviceMemory block.
        +
        5602 */
        +
        5603 class VmaBlockMetadata
        +
        5604 {
        +
        5605 public:
        +
        5606  VmaBlockMetadata(VmaAllocator hAllocator);
        +
        5607  virtual ~VmaBlockMetadata() { }
        +
        5608  virtual void Init(VkDeviceSize size) { m_Size = size; }
        +
        5609 
        +
        5610  // Validates all data structures inside this object. If not valid, returns false.
        +
        5611  virtual bool Validate() const = 0;
        +
        5612  VkDeviceSize GetSize() const { return m_Size; }
        +
        5613  virtual size_t GetAllocationCount() const = 0;
        +
        5614  virtual VkDeviceSize GetSumFreeSize() const = 0;
        +
        5615  virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;
        +
        5616  // Returns true if this block is empty - contains only single free suballocation.
        +
        5617  virtual bool IsEmpty() const = 0;
        +
        5618 
        +
        5619  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;
        +
        5620  // Shouldn't modify blockCount.
        +
        5621  virtual void AddPoolStats(VmaPoolStats& inoutStats) const = 0;
        5622 
        -
        5623  virtual VkResult CheckCorruption(const void* pBlockData) = 0;
        -
        5624 
        -
        5625  // Makes actual allocation based on request. Request must already be checked and valid.
        -
        5626  virtual void Alloc(
        -
        5627  const VmaAllocationRequest& request,
        -
        5628  VmaSuballocationType type,
        -
        5629  VkDeviceSize allocSize,
        -
        5630  VmaAllocation hAllocation) = 0;
        -
        5631 
        -
        5632  // Frees suballocation assigned to given memory region.
        -
        5633  virtual void Free(const VmaAllocation allocation) = 0;
        -
        5634  virtual void FreeAtOffset(VkDeviceSize offset) = 0;
        -
        5635 
        -
        5636 protected:
        -
        5637  const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }
        -
        5638 
        -
        5639 #if VMA_STATS_STRING_ENABLED
        -
        5640  void PrintDetailedMap_Begin(class VmaJsonWriter& json,
        -
        5641  VkDeviceSize unusedBytes,
        -
        5642  size_t allocationCount,
        -
        5643  size_t unusedRangeCount) const;
        -
        5644  void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        -
        5645  VkDeviceSize offset,
        -
        5646  VmaAllocation hAllocation) const;
        -
        5647  void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        -
        5648  VkDeviceSize offset,
        -
        5649  VkDeviceSize size) const;
        -
        5650  void PrintDetailedMap_End(class VmaJsonWriter& json) const;
        -
        5651 #endif
        -
        5652 
        -
        5653 private:
        -
        5654  VkDeviceSize m_Size;
        -
        5655  const VkAllocationCallbacks* m_pAllocationCallbacks;
        -
        5656 };
        -
        5657 
        -
        5658 #define VMA_VALIDATE(cond) do { if(!(cond)) { \
        -
        5659  VMA_ASSERT(0 && "Validation failed: " #cond); \
        -
        5660  return false; \
        -
        5661  } } while(false)
        +
        5623 #if VMA_STATS_STRING_ENABLED
        +
        5624  virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
        +
        5625 #endif
        +
        5626 
        +
        5627  // Tries to find a place for suballocation with given parameters inside this block.
        +
        5628  // If succeeded, fills pAllocationRequest and returns true.
        +
        5629  // If failed, returns false.
        +
        5630  virtual bool CreateAllocationRequest(
        +
        5631  uint32_t currentFrameIndex,
        +
        5632  uint32_t frameInUseCount,
        +
        5633  VkDeviceSize bufferImageGranularity,
        +
        5634  VkDeviceSize allocSize,
        +
        5635  VkDeviceSize allocAlignment,
        +
        5636  bool upperAddress,
        +
        5637  VmaSuballocationType allocType,
        +
        5638  bool canMakeOtherLost,
        +
        5639  // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.
        +
        5640  uint32_t strategy,
        +
        5641  VmaAllocationRequest* pAllocationRequest) = 0;
        +
        5642 
        +
        5643  virtual bool MakeRequestedAllocationsLost(
        +
        5644  uint32_t currentFrameIndex,
        +
        5645  uint32_t frameInUseCount,
        +
        5646  VmaAllocationRequest* pAllocationRequest) = 0;
        +
        5647 
        +
        5648  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 0;
        +
        5649 
        +
        5650  virtual VkResult CheckCorruption(const void* pBlockData) = 0;
        +
        5651 
        +
        5652  // Makes actual allocation based on request. Request must already be checked and valid.
        +
        5653  virtual void Alloc(
        +
        5654  const VmaAllocationRequest& request,
        +
        5655  VmaSuballocationType type,
        +
        5656  VkDeviceSize allocSize,
        +
        5657  VmaAllocation hAllocation) = 0;
        +
        5658 
        +
        5659  // Frees suballocation assigned to given memory region.
        +
        5660  virtual void Free(const VmaAllocation allocation) = 0;
        +
        5661  virtual void FreeAtOffset(VkDeviceSize offset) = 0;
        5662 
        -
        5663 class VmaBlockMetadata_Generic : public VmaBlockMetadata
        -
        5664 {
        -
        5665  VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
        -
        5666 public:
        -
        5667  VmaBlockMetadata_Generic(VmaAllocator hAllocator);
        -
        5668  virtual ~VmaBlockMetadata_Generic();
        -
        5669  virtual void Init(VkDeviceSize size);
        -
        5670 
        -
        5671  virtual bool Validate() const;
        -
        5672  virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
        -
        5673  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        -
        5674  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        -
        5675  virtual bool IsEmpty() const;
        -
        5676 
        -
        5677  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        -
        5678  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        +
        5663 protected:
        +
        5664  const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }
        +
        5665 
        +
        5666 #if VMA_STATS_STRING_ENABLED
        +
        5667  void PrintDetailedMap_Begin(class VmaJsonWriter& json,
        +
        5668  VkDeviceSize unusedBytes,
        +
        5669  size_t allocationCount,
        +
        5670  size_t unusedRangeCount) const;
        +
        5671  void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        +
        5672  VkDeviceSize offset,
        +
        5673  VmaAllocation hAllocation) const;
        +
        5674  void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        +
        5675  VkDeviceSize offset,
        +
        5676  VkDeviceSize size) const;
        +
        5677  void PrintDetailedMap_End(class VmaJsonWriter& json) const;
        +
        5678 #endif
        5679 
        -
        5680 #if VMA_STATS_STRING_ENABLED
        -
        5681  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        -
        5682 #endif
        -
        5683 
        -
        5684  virtual bool CreateAllocationRequest(
        -
        5685  uint32_t currentFrameIndex,
        -
        5686  uint32_t frameInUseCount,
        -
        5687  VkDeviceSize bufferImageGranularity,
        -
        5688  VkDeviceSize allocSize,
        -
        5689  VkDeviceSize allocAlignment,
        -
        5690  bool upperAddress,
        -
        5691  VmaSuballocationType allocType,
        -
        5692  bool canMakeOtherLost,
        -
        5693  uint32_t strategy,
        -
        5694  VmaAllocationRequest* pAllocationRequest);
        -
        5695 
        -
        5696  virtual bool MakeRequestedAllocationsLost(
        -
        5697  uint32_t currentFrameIndex,
        -
        5698  uint32_t frameInUseCount,
        -
        5699  VmaAllocationRequest* pAllocationRequest);
        -
        5700 
        -
        5701  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        -
        5702 
        -
        5703  virtual VkResult CheckCorruption(const void* pBlockData);
        -
        5704 
        -
        5705  virtual void Alloc(
        -
        5706  const VmaAllocationRequest& request,
        -
        5707  VmaSuballocationType type,
        -
        5708  VkDeviceSize allocSize,
        -
        5709  VmaAllocation hAllocation);
        +
        5680 private:
        +
        5681  VkDeviceSize m_Size;
        +
        5682  const VkAllocationCallbacks* m_pAllocationCallbacks;
        +
        5683 };
        +
        5684 
        +
        5685 #define VMA_VALIDATE(cond) do { if(!(cond)) { \
        +
        5686  VMA_ASSERT(0 && "Validation failed: " #cond); \
        +
        5687  return false; \
        +
        5688  } } while(false)
        +
        5689 
        +
        5690 class VmaBlockMetadata_Generic : public VmaBlockMetadata
        +
        5691 {
        +
        5692  VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
        +
        5693 public:
        +
        5694  VmaBlockMetadata_Generic(VmaAllocator hAllocator);
        +
        5695  virtual ~VmaBlockMetadata_Generic();
        +
        5696  virtual void Init(VkDeviceSize size);
        +
        5697 
        +
        5698  virtual bool Validate() const;
        +
        5699  virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
        +
        5700  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        +
        5701  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        +
        5702  virtual bool IsEmpty() const;
        +
        5703 
        +
        5704  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        +
        5705  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        +
        5706 
        +
        5707 #if VMA_STATS_STRING_ENABLED
        +
        5708  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        +
        5709 #endif
        5710 
        -
        5711  virtual void Free(const VmaAllocation allocation);
        -
        5712  virtual void FreeAtOffset(VkDeviceSize offset);
        -
        5713 
        -
        5715  // For defragmentation
        -
        5716 
        -
        5717  bool IsBufferImageGranularityConflictPossible(
        -
        5718  VkDeviceSize bufferImageGranularity,
        -
        5719  VmaSuballocationType& inOutPrevSuballocType) const;
        -
        5720 
        -
        5721 private:
        -
        5722  friend class VmaDefragmentationAlgorithm_Generic;
        -
        5723  friend class VmaDefragmentationAlgorithm_Fast;
        -
        5724 
        -
        5725  uint32_t m_FreeCount;
        -
        5726  VkDeviceSize m_SumFreeSize;
        -
        5727  VmaSuballocationList m_Suballocations;
        -
        5728  // Suballocations that are free and have size greater than certain threshold.
        -
        5729  // Sorted by size, ascending.
        -
        5730  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
        +
        5711  virtual bool CreateAllocationRequest(
        +
        5712  uint32_t currentFrameIndex,
        +
        5713  uint32_t frameInUseCount,
        +
        5714  VkDeviceSize bufferImageGranularity,
        +
        5715  VkDeviceSize allocSize,
        +
        5716  VkDeviceSize allocAlignment,
        +
        5717  bool upperAddress,
        +
        5718  VmaSuballocationType allocType,
        +
        5719  bool canMakeOtherLost,
        +
        5720  uint32_t strategy,
        +
        5721  VmaAllocationRequest* pAllocationRequest);
        +
        5722 
        +
        5723  virtual bool MakeRequestedAllocationsLost(
        +
        5724  uint32_t currentFrameIndex,
        +
        5725  uint32_t frameInUseCount,
        +
        5726  VmaAllocationRequest* pAllocationRequest);
        +
        5727 
        +
        5728  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        +
        5729 
        +
        5730  virtual VkResult CheckCorruption(const void* pBlockData);
        5731 
        -
        5732  bool ValidateFreeSuballocationList() const;
        -
        5733 
        -
        5734  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
        -
        5735  // If yes, fills pOffset and returns true. If no, returns false.
        -
        5736  bool CheckAllocation(
        -
        5737  uint32_t currentFrameIndex,
        -
        5738  uint32_t frameInUseCount,
        -
        5739  VkDeviceSize bufferImageGranularity,
        -
        5740  VkDeviceSize allocSize,
        -
        5741  VkDeviceSize allocAlignment,
        -
        5742  VmaSuballocationType allocType,
        -
        5743  VmaSuballocationList::const_iterator suballocItem,
        -
        5744  bool canMakeOtherLost,
        -
        5745  VkDeviceSize* pOffset,
        -
        5746  size_t* itemsToMakeLostCount,
        -
        5747  VkDeviceSize* pSumFreeSize,
        -
        5748  VkDeviceSize* pSumItemSize) const;
        -
        5749  // Given free suballocation, it merges it with following one, which must also be free.
        -
        5750  void MergeFreeWithNext(VmaSuballocationList::iterator item);
        -
        5751  // Releases given suballocation, making it free.
        -
        5752  // Merges it with adjacent free suballocations if applicable.
        -
        5753  // Returns iterator to new free suballocation at this place.
        -
        5754  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
        -
        5755  // Given free suballocation, it inserts it into sorted list of
        -
        5756  // m_FreeSuballocationsBySize if it's suitable.
        -
        5757  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
        -
        5758  // Given free suballocation, it removes it from sorted list of
        -
        5759  // m_FreeSuballocationsBySize if it's suitable.
        -
        5760  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
        -
        5761 };
        -
        5762 
        -
        5763 /*
        -
        5764 Allocations and their references in internal data structure look like this:
        -
        5765 
        -
        5766 if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
        -
        5767 
        -
        5768  0 +-------+
        -
        5769  | |
        -
        5770  | |
        -
        5771  | |
        -
        5772  +-------+
        -
        5773  | Alloc | 1st[m_1stNullItemsBeginCount]
        -
        5774  +-------+
        -
        5775  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        -
        5776  +-------+
        -
        5777  | ... |
        -
        5778  +-------+
        -
        5779  | Alloc | 1st[1st.size() - 1]
        -
        5780  +-------+
        -
        5781  | |
        -
        5782  | |
        -
        5783  | |
        -
        5784 GetSize() +-------+
        -
        5785 
        -
        5786 if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
        -
        5787 
        -
        5788  0 +-------+
        -
        5789  | Alloc | 2nd[0]
        -
        5790  +-------+
        -
        5791  | Alloc | 2nd[1]
        -
        5792  +-------+
        -
        5793  | ... |
        -
        5794  +-------+
        -
        5795  | Alloc | 2nd[2nd.size() - 1]
        -
        5796  +-------+
        +
        5732  virtual void Alloc(
        +
        5733  const VmaAllocationRequest& request,
        +
        5734  VmaSuballocationType type,
        +
        5735  VkDeviceSize allocSize,
        +
        5736  VmaAllocation hAllocation);
        +
        5737 
        +
        5738  virtual void Free(const VmaAllocation allocation);
        +
        5739  virtual void FreeAtOffset(VkDeviceSize offset);
        +
        5740 
        +
        5742  // For defragmentation
        +
        5743 
        +
        5744  bool IsBufferImageGranularityConflictPossible(
        +
        5745  VkDeviceSize bufferImageGranularity,
        +
        5746  VmaSuballocationType& inOutPrevSuballocType) const;
        +
        5747 
        +
        5748 private:
        +
        5749  friend class VmaDefragmentationAlgorithm_Generic;
        +
        5750  friend class VmaDefragmentationAlgorithm_Fast;
        +
        5751 
        +
        5752  uint32_t m_FreeCount;
        +
        5753  VkDeviceSize m_SumFreeSize;
        +
        5754  VmaSuballocationList m_Suballocations;
        +
        5755  // Suballocations that are free and have size greater than certain threshold.
        +
        5756  // Sorted by size, ascending.
        +
        5757  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
        +
        5758 
        +
        5759  bool ValidateFreeSuballocationList() const;
        +
        5760 
        +
        5761  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
        +
        5762  // If yes, fills pOffset and returns true. If no, returns false.
        +
        5763  bool CheckAllocation(
        +
        5764  uint32_t currentFrameIndex,
        +
        5765  uint32_t frameInUseCount,
        +
        5766  VkDeviceSize bufferImageGranularity,
        +
        5767  VkDeviceSize allocSize,
        +
        5768  VkDeviceSize allocAlignment,
        +
        5769  VmaSuballocationType allocType,
        +
        5770  VmaSuballocationList::const_iterator suballocItem,
        +
        5771  bool canMakeOtherLost,
        +
        5772  VkDeviceSize* pOffset,
        +
        5773  size_t* itemsToMakeLostCount,
        +
        5774  VkDeviceSize* pSumFreeSize,
        +
        5775  VkDeviceSize* pSumItemSize) const;
        +
        5776  // Given free suballocation, it merges it with following one, which must also be free.
        +
        5777  void MergeFreeWithNext(VmaSuballocationList::iterator item);
        +
        5778  // Releases given suballocation, making it free.
        +
        5779  // Merges it with adjacent free suballocations if applicable.
        +
        5780  // Returns iterator to new free suballocation at this place.
        +
        5781  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
        +
        5782  // Given free suballocation, it inserts it into sorted list of
        +
        5783  // m_FreeSuballocationsBySize if it's suitable.
        +
        5784  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
        +
        5785  // Given free suballocation, it removes it from sorted list of
        +
        5786  // m_FreeSuballocationsBySize if it's suitable.
        +
        5787  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
        +
        5788 };
        +
        5789 
        +
        5790 /*
        +
        5791 Allocations and their references in internal data structure look like this:
        +
        5792 
        +
        5793 if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
        +
        5794 
        +
        5795  0 +-------+
        +
        5796  | |
        5797  | |
        5798  | |
        -
        5799  | |
        -
        5800  +-------+
        -
        5801  | Alloc | 1st[m_1stNullItemsBeginCount]
        -
        5802  +-------+
        -
        5803  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        -
        5804  +-------+
        -
        5805  | ... |
        -
        5806  +-------+
        -
        5807  | Alloc | 1st[1st.size() - 1]
        -
        5808  +-------+
        +
        5799  +-------+
        +
        5800  | Alloc | 1st[m_1stNullItemsBeginCount]
        +
        5801  +-------+
        +
        5802  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        +
        5803  +-------+
        +
        5804  | ... |
        +
        5805  +-------+
        +
        5806  | Alloc | 1st[1st.size() - 1]
        +
        5807  +-------+
        +
        5808  | |
        5809  | |
        -
        5810 GetSize() +-------+
        -
        5811 
        -
        5812 if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
        -
        5813 
        -
        5814  0 +-------+
        -
        5815  | |
        -
        5816  | |
        -
        5817  | |
        -
        5818  +-------+
        -
        5819  | Alloc | 1st[m_1stNullItemsBeginCount]
        -
        5820  +-------+
        -
        5821  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        -
        5822  +-------+
        -
        5823  | ... |
        -
        5824  +-------+
        -
        5825  | Alloc | 1st[1st.size() - 1]
        -
        5826  +-------+
        -
        5827  | |
        -
        5828  | |
        -
        5829  | |
        -
        5830  +-------+
        -
        5831  | Alloc | 2nd[2nd.size() - 1]
        -
        5832  +-------+
        -
        5833  | ... |
        -
        5834  +-------+
        -
        5835  | Alloc | 2nd[1]
        -
        5836  +-------+
        -
        5837  | Alloc | 2nd[0]
        -
        5838 GetSize() +-------+
        -
        5839 
        -
        5840 */
        -
        5841 class VmaBlockMetadata_Linear : public VmaBlockMetadata
        -
        5842 {
        -
        5843  VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
        -
        5844 public:
        -
        5845  VmaBlockMetadata_Linear(VmaAllocator hAllocator);
        -
        5846  virtual ~VmaBlockMetadata_Linear();
        -
        5847  virtual void Init(VkDeviceSize size);
        -
        5848 
        -
        5849  virtual bool Validate() const;
        -
        5850  virtual size_t GetAllocationCount() const;
        -
        5851  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        -
        5852  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        -
        5853  virtual bool IsEmpty() const { return GetAllocationCount() == 0; }
        -
        5854 
        -
        5855  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        -
        5856  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        -
        5857 
        -
        5858 #if VMA_STATS_STRING_ENABLED
        -
        5859  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        -
        5860 #endif
        -
        5861 
        -
        5862  virtual bool CreateAllocationRequest(
        -
        5863  uint32_t currentFrameIndex,
        -
        5864  uint32_t frameInUseCount,
        -
        5865  VkDeviceSize bufferImageGranularity,
        -
        5866  VkDeviceSize allocSize,
        -
        5867  VkDeviceSize allocAlignment,
        -
        5868  bool upperAddress,
        -
        5869  VmaSuballocationType allocType,
        -
        5870  bool canMakeOtherLost,
        -
        5871  uint32_t strategy,
        -
        5872  VmaAllocationRequest* pAllocationRequest);
        -
        5873 
        -
        5874  virtual bool MakeRequestedAllocationsLost(
        -
        5875  uint32_t currentFrameIndex,
        -
        5876  uint32_t frameInUseCount,
        -
        5877  VmaAllocationRequest* pAllocationRequest);
        -
        5878 
        -
        5879  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        -
        5880 
        -
        5881  virtual VkResult CheckCorruption(const void* pBlockData);
        -
        5882 
        -
        5883  virtual void Alloc(
        -
        5884  const VmaAllocationRequest& request,
        -
        5885  VmaSuballocationType type,
        -
        5886  VkDeviceSize allocSize,
        -
        5887  VmaAllocation hAllocation);
        +
        5810  | |
        +
        5811 GetSize() +-------+
        +
        5812 
        +
        5813 if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
        +
        5814 
        +
        5815  0 +-------+
        +
        5816  | Alloc | 2nd[0]
        +
        5817  +-------+
        +
        5818  | Alloc | 2nd[1]
        +
        5819  +-------+
        +
        5820  | ... |
        +
        5821  +-------+
        +
        5822  | Alloc | 2nd[2nd.size() - 1]
        +
        5823  +-------+
        +
        5824  | |
        +
        5825  | |
        +
        5826  | |
        +
        5827  +-------+
        +
        5828  | Alloc | 1st[m_1stNullItemsBeginCount]
        +
        5829  +-------+
        +
        5830  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        +
        5831  +-------+
        +
        5832  | ... |
        +
        5833  +-------+
        +
        5834  | Alloc | 1st[1st.size() - 1]
        +
        5835  +-------+
        +
        5836  | |
        +
        5837 GetSize() +-------+
        +
        5838 
        +
        5839 if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
        +
        5840 
        +
        5841  0 +-------+
        +
        5842  | |
        +
        5843  | |
        +
        5844  | |
        +
        5845  +-------+
        +
        5846  | Alloc | 1st[m_1stNullItemsBeginCount]
        +
        5847  +-------+
        +
        5848  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        +
        5849  +-------+
        +
        5850  | ... |
        +
        5851  +-------+
        +
        5852  | Alloc | 1st[1st.size() - 1]
        +
        5853  +-------+
        +
        5854  | |
        +
        5855  | |
        +
        5856  | |
        +
        5857  +-------+
        +
        5858  | Alloc | 2nd[2nd.size() - 1]
        +
        5859  +-------+
        +
        5860  | ... |
        +
        5861  +-------+
        +
        5862  | Alloc | 2nd[1]
        +
        5863  +-------+
        +
        5864  | Alloc | 2nd[0]
        +
        5865 GetSize() +-------+
        +
        5866 
        +
        5867 */
        +
        5868 class VmaBlockMetadata_Linear : public VmaBlockMetadata
        +
        5869 {
        +
        5870  VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
        +
        5871 public:
        +
        5872  VmaBlockMetadata_Linear(VmaAllocator hAllocator);
        +
        5873  virtual ~VmaBlockMetadata_Linear();
        +
        5874  virtual void Init(VkDeviceSize size);
        +
        5875 
        +
        5876  virtual bool Validate() const;
        +
        5877  virtual size_t GetAllocationCount() const;
        +
        5878  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        +
        5879  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        +
        5880  virtual bool IsEmpty() const { return GetAllocationCount() == 0; }
        +
        5881 
        +
        5882  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        +
        5883  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        +
        5884 
        +
        5885 #if VMA_STATS_STRING_ENABLED
        +
        5886  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        +
        5887 #endif
        5888 
        -
        5889  virtual void Free(const VmaAllocation allocation);
        -
        5890  virtual void FreeAtOffset(VkDeviceSize offset);
        -
        5891 
        -
        5892 private:
        -
        5893  /*
        -
        5894  There are two suballocation vectors, used in ping-pong way.
        -
        5895  The one with index m_1stVectorIndex is called 1st.
        -
        5896  The one with index (m_1stVectorIndex ^ 1) is called 2nd.
        -
        5897  2nd can be non-empty only when 1st is not empty.
        -
        5898  When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
        -
        5899  */
        -
        5900  typedef VmaVector< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > SuballocationVectorType;
        -
        5901 
        -
        5902  enum SECOND_VECTOR_MODE
        -
        5903  {
        -
        5904  SECOND_VECTOR_EMPTY,
        -
        5905  /*
        -
        5906  Suballocations in 2nd vector are created later than the ones in 1st, but they
        -
        5907  all have smaller offset.
        -
        5908  */
        -
        5909  SECOND_VECTOR_RING_BUFFER,
        -
        5910  /*
        -
        5911  Suballocations in 2nd vector are upper side of double stack.
        -
        5912  They all have offsets higher than those in 1st vector.
        -
        5913  Top of this stack means smaller offsets, but higher indices in this vector.
        -
        5914  */
        -
        5915  SECOND_VECTOR_DOUBLE_STACK,
        -
        5916  };
        -
        5917 
        -
        5918  VkDeviceSize m_SumFreeSize;
        -
        5919  SuballocationVectorType m_Suballocations0, m_Suballocations1;
        -
        5920  uint32_t m_1stVectorIndex;
        -
        5921  SECOND_VECTOR_MODE m_2ndVectorMode;
        -
        5922 
        -
        5923  SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        -
        5924  SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        -
        5925  const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        -
        5926  const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        -
        5927 
        -
        5928  // Number of items in 1st vector with hAllocation = null at the beginning.
        -
        5929  size_t m_1stNullItemsBeginCount;
        -
        5930  // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
        -
        5931  size_t m_1stNullItemsMiddleCount;
        -
        5932  // Number of items in 2nd vector with hAllocation = null.
        -
        5933  size_t m_2ndNullItemsCount;
        -
        5934 
        -
        5935  bool ShouldCompact1st() const;
        -
        5936  void CleanupAfterFree();
        -
        5937 
        -
        5938  bool CreateAllocationRequest_LowerAddress(
        -
        5939  uint32_t currentFrameIndex,
        -
        5940  uint32_t frameInUseCount,
        -
        5941  VkDeviceSize bufferImageGranularity,
        -
        5942  VkDeviceSize allocSize,
        -
        5943  VkDeviceSize allocAlignment,
        -
        5944  VmaSuballocationType allocType,
        -
        5945  bool canMakeOtherLost,
        -
        5946  uint32_t strategy,
        -
        5947  VmaAllocationRequest* pAllocationRequest);
        -
        5948  bool CreateAllocationRequest_UpperAddress(
        -
        5949  uint32_t currentFrameIndex,
        -
        5950  uint32_t frameInUseCount,
        -
        5951  VkDeviceSize bufferImageGranularity,
        -
        5952  VkDeviceSize allocSize,
        -
        5953  VkDeviceSize allocAlignment,
        -
        5954  VmaSuballocationType allocType,
        -
        5955  bool canMakeOtherLost,
        -
        5956  uint32_t strategy,
        -
        5957  VmaAllocationRequest* pAllocationRequest);
        -
        5958 };
        -
        5959 
        -
        5960 /*
        -
        5961 - GetSize() is the original size of allocated memory block.
        -
        5962 - m_UsableSize is this size aligned down to a power of two.
        -
        5963  All allocations and calculations happen relative to m_UsableSize.
        -
        5964 - GetUnusableSize() is the difference between them.
        -
        5965  It is repoted as separate, unused range, not available for allocations.
        -
        5966 
        -
        5967 Node at level 0 has size = m_UsableSize.
        -
        5968 Each next level contains nodes with size 2 times smaller than current level.
        -
        5969 m_LevelCount is the maximum number of levels to use in the current object.
        -
        5970 */
        -
        5971 class VmaBlockMetadata_Buddy : public VmaBlockMetadata
        -
        5972 {
        -
        5973  VMA_CLASS_NO_COPY(VmaBlockMetadata_Buddy)
        -
        5974 public:
        -
        5975  VmaBlockMetadata_Buddy(VmaAllocator hAllocator);
        -
        5976  virtual ~VmaBlockMetadata_Buddy();
        -
        5977  virtual void Init(VkDeviceSize size);
        -
        5978 
        -
        5979  virtual bool Validate() const;
        -
        5980  virtual size_t GetAllocationCount() const { return m_AllocationCount; }
        -
        5981  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize + GetUnusableSize(); }
        -
        5982  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        -
        5983  virtual bool IsEmpty() const { return m_Root->type == Node::TYPE_FREE; }
        -
        5984 
        -
        5985  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        -
        5986  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        -
        5987 
        -
        5988 #if VMA_STATS_STRING_ENABLED
        -
        5989  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        -
        5990 #endif
        -
        5991 
        -
        5992  virtual bool CreateAllocationRequest(
        -
        5993  uint32_t currentFrameIndex,
        -
        5994  uint32_t frameInUseCount,
        -
        5995  VkDeviceSize bufferImageGranularity,
        -
        5996  VkDeviceSize allocSize,
        -
        5997  VkDeviceSize allocAlignment,
        -
        5998  bool upperAddress,
        -
        5999  VmaSuballocationType allocType,
        -
        6000  bool canMakeOtherLost,
        -
        6001  uint32_t strategy,
        -
        6002  VmaAllocationRequest* pAllocationRequest);
        -
        6003 
        -
        6004  virtual bool MakeRequestedAllocationsLost(
        -
        6005  uint32_t currentFrameIndex,
        -
        6006  uint32_t frameInUseCount,
        -
        6007  VmaAllocationRequest* pAllocationRequest);
        -
        6008 
        -
        6009  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        -
        6010 
        -
        6011  virtual VkResult CheckCorruption(const void* pBlockData) { return VK_ERROR_FEATURE_NOT_PRESENT; }
        -
        6012 
        -
        6013  virtual void Alloc(
        -
        6014  const VmaAllocationRequest& request,
        -
        6015  VmaSuballocationType type,
        -
        6016  VkDeviceSize allocSize,
        -
        6017  VmaAllocation hAllocation);
        +
        5889  virtual bool CreateAllocationRequest(
        +
        5890  uint32_t currentFrameIndex,
        +
        5891  uint32_t frameInUseCount,
        +
        5892  VkDeviceSize bufferImageGranularity,
        +
        5893  VkDeviceSize allocSize,
        +
        5894  VkDeviceSize allocAlignment,
        +
        5895  bool upperAddress,
        +
        5896  VmaSuballocationType allocType,
        +
        5897  bool canMakeOtherLost,
        +
        5898  uint32_t strategy,
        +
        5899  VmaAllocationRequest* pAllocationRequest);
        +
        5900 
        +
        5901  virtual bool MakeRequestedAllocationsLost(
        +
        5902  uint32_t currentFrameIndex,
        +
        5903  uint32_t frameInUseCount,
        +
        5904  VmaAllocationRequest* pAllocationRequest);
        +
        5905 
        +
        5906  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        +
        5907 
        +
        5908  virtual VkResult CheckCorruption(const void* pBlockData);
        +
        5909 
        +
        5910  virtual void Alloc(
        +
        5911  const VmaAllocationRequest& request,
        +
        5912  VmaSuballocationType type,
        +
        5913  VkDeviceSize allocSize,
        +
        5914  VmaAllocation hAllocation);
        +
        5915 
        +
        5916  virtual void Free(const VmaAllocation allocation);
        +
        5917  virtual void FreeAtOffset(VkDeviceSize offset);
        +
        5918 
        +
        5919 private:
        +
        5920  /*
        +
        5921  There are two suballocation vectors, used in ping-pong way.
        +
        5922  The one with index m_1stVectorIndex is called 1st.
        +
        5923  The one with index (m_1stVectorIndex ^ 1) is called 2nd.
        +
        5924  2nd can be non-empty only when 1st is not empty.
        +
        5925  When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
        +
        5926  */
        +
        5927  typedef VmaVector< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > SuballocationVectorType;
        +
        5928 
        +
        5929  enum SECOND_VECTOR_MODE
        +
        5930  {
        +
        5931  SECOND_VECTOR_EMPTY,
        +
        5932  /*
        +
        5933  Suballocations in 2nd vector are created later than the ones in 1st, but they
        +
        5934  all have smaller offset.
        +
        5935  */
        +
        5936  SECOND_VECTOR_RING_BUFFER,
        +
        5937  /*
        +
        5938  Suballocations in 2nd vector are upper side of double stack.
        +
        5939  They all have offsets higher than those in 1st vector.
        +
        5940  Top of this stack means smaller offsets, but higher indices in this vector.
        +
        5941  */
        +
        5942  SECOND_VECTOR_DOUBLE_STACK,
        +
        5943  };
        +
        5944 
        +
        5945  VkDeviceSize m_SumFreeSize;
        +
        5946  SuballocationVectorType m_Suballocations0, m_Suballocations1;
        +
        5947  uint32_t m_1stVectorIndex;
        +
        5948  SECOND_VECTOR_MODE m_2ndVectorMode;
        +
        5949 
        +
        5950  SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        +
        5951  SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        +
        5952  const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        +
        5953  const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        +
        5954 
        +
        5955  // Number of items in 1st vector with hAllocation = null at the beginning.
        +
        5956  size_t m_1stNullItemsBeginCount;
        +
        5957  // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
        +
        5958  size_t m_1stNullItemsMiddleCount;
        +
        5959  // Number of items in 2nd vector with hAllocation = null.
        +
        5960  size_t m_2ndNullItemsCount;
        +
        5961 
        +
        5962  bool ShouldCompact1st() const;
        +
        5963  void CleanupAfterFree();
        +
        5964 
        +
        5965  bool CreateAllocationRequest_LowerAddress(
        +
        5966  uint32_t currentFrameIndex,
        +
        5967  uint32_t frameInUseCount,
        +
        5968  VkDeviceSize bufferImageGranularity,
        +
        5969  VkDeviceSize allocSize,
        +
        5970  VkDeviceSize allocAlignment,
        +
        5971  VmaSuballocationType allocType,
        +
        5972  bool canMakeOtherLost,
        +
        5973  uint32_t strategy,
        +
        5974  VmaAllocationRequest* pAllocationRequest);
        +
        5975  bool CreateAllocationRequest_UpperAddress(
        +
        5976  uint32_t currentFrameIndex,
        +
        5977  uint32_t frameInUseCount,
        +
        5978  VkDeviceSize bufferImageGranularity,
        +
        5979  VkDeviceSize allocSize,
        +
        5980  VkDeviceSize allocAlignment,
        +
        5981  VmaSuballocationType allocType,
        +
        5982  bool canMakeOtherLost,
        +
        5983  uint32_t strategy,
        +
        5984  VmaAllocationRequest* pAllocationRequest);
        +
        5985 };
        +
        5986 
        +
        5987 /*
        +
        5988 - GetSize() is the original size of allocated memory block.
        +
        5989 - m_UsableSize is this size aligned down to a power of two.
        +
        5990  All allocations and calculations happen relative to m_UsableSize.
        +
        5991 - GetUnusableSize() is the difference between them.
        +
        5992  It is repoted as separate, unused range, not available for allocations.
        +
        5993 
        +
        5994 Node at level 0 has size = m_UsableSize.
        +
        5995 Each next level contains nodes with size 2 times smaller than current level.
        +
        5996 m_LevelCount is the maximum number of levels to use in the current object.
        +
        5997 */
        +
        5998 class VmaBlockMetadata_Buddy : public VmaBlockMetadata
        +
        5999 {
        +
        6000  VMA_CLASS_NO_COPY(VmaBlockMetadata_Buddy)
        +
        6001 public:
        +
        6002  VmaBlockMetadata_Buddy(VmaAllocator hAllocator);
        +
        6003  virtual ~VmaBlockMetadata_Buddy();
        +
        6004  virtual void Init(VkDeviceSize size);
        +
        6005 
        +
        6006  virtual bool Validate() const;
        +
        6007  virtual size_t GetAllocationCount() const { return m_AllocationCount; }
        +
        6008  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize + GetUnusableSize(); }
        +
        6009  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        +
        6010  virtual bool IsEmpty() const { return m_Root->type == Node::TYPE_FREE; }
        +
        6011 
        +
        6012  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        +
        6013  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        +
        6014 
        +
        6015 #if VMA_STATS_STRING_ENABLED
        +
        6016  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        +
        6017 #endif
        6018 
        -
        6019  virtual void Free(const VmaAllocation allocation) { FreeAtOffset(allocation, allocation->GetOffset()); }
        -
        6020  virtual void FreeAtOffset(VkDeviceSize offset) { FreeAtOffset(VMA_NULL, offset); }
        -
        6021 
        -
        6022 private:
        -
        6023  static const VkDeviceSize MIN_NODE_SIZE = 32;
        -
        6024  static const size_t MAX_LEVELS = 30;
        -
        6025 
        -
        6026  struct ValidationContext
        -
        6027  {
        -
        6028  size_t calculatedAllocationCount;
        -
        6029  size_t calculatedFreeCount;
        -
        6030  VkDeviceSize calculatedSumFreeSize;
        -
        6031 
        -
        6032  ValidationContext() :
        -
        6033  calculatedAllocationCount(0),
        -
        6034  calculatedFreeCount(0),
        -
        6035  calculatedSumFreeSize(0) { }
        -
        6036  };
        +
        6019  virtual bool CreateAllocationRequest(
        +
        6020  uint32_t currentFrameIndex,
        +
        6021  uint32_t frameInUseCount,
        +
        6022  VkDeviceSize bufferImageGranularity,
        +
        6023  VkDeviceSize allocSize,
        +
        6024  VkDeviceSize allocAlignment,
        +
        6025  bool upperAddress,
        +
        6026  VmaSuballocationType allocType,
        +
        6027  bool canMakeOtherLost,
        +
        6028  uint32_t strategy,
        +
        6029  VmaAllocationRequest* pAllocationRequest);
        +
        6030 
        +
        6031  virtual bool MakeRequestedAllocationsLost(
        +
        6032  uint32_t currentFrameIndex,
        +
        6033  uint32_t frameInUseCount,
        +
        6034  VmaAllocationRequest* pAllocationRequest);
        +
        6035 
        +
        6036  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        6037 
        -
        6038  struct Node
        -
        6039  {
        -
        6040  VkDeviceSize offset;
        -
        6041  enum TYPE
        -
        6042  {
        -
        6043  TYPE_FREE,
        -
        6044  TYPE_ALLOCATION,
        -
        6045  TYPE_SPLIT,
        -
        6046  TYPE_COUNT
        -
        6047  } type;
        -
        6048  Node* parent;
        -
        6049  Node* buddy;
        -
        6050 
        -
        6051  union
        -
        6052  {
        -
        6053  struct
        -
        6054  {
        -
        6055  Node* prev;
        -
        6056  Node* next;
        -
        6057  } free;
        -
        6058  struct
        -
        6059  {
        -
        6060  VmaAllocation alloc;
        -
        6061  } allocation;
        -
        6062  struct
        -
        6063  {
        -
        6064  Node* leftChild;
        -
        6065  } split;
        -
        6066  };
        -
        6067  };
        -
        6068 
        -
        6069  // Size of the memory block aligned down to a power of two.
        -
        6070  VkDeviceSize m_UsableSize;
        -
        6071  uint32_t m_LevelCount;
        -
        6072 
        -
        6073  Node* m_Root;
        -
        6074  struct {
        -
        6075  Node* front;
        -
        6076  Node* back;
        -
        6077  } m_FreeList[MAX_LEVELS];
        -
        6078  // Number of nodes in the tree with type == TYPE_ALLOCATION.
        -
        6079  size_t m_AllocationCount;
        -
        6080  // Number of nodes in the tree with type == TYPE_FREE.
        -
        6081  size_t m_FreeCount;
        -
        6082  // This includes space wasted due to internal fragmentation. Doesn't include unusable size.
        -
        6083  VkDeviceSize m_SumFreeSize;
        -
        6084 
        -
        6085  VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
        -
        6086  void DeleteNode(Node* node);
        -
        6087  bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
        -
        6088  uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
        -
        6089  inline VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }
        -
        6090  // Alloc passed just for validation. Can be null.
        -
        6091  void FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset);
        -
        6092  void CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const;
        -
        6093  // Adds node to the front of FreeList at given level.
        -
        6094  // node->type must be FREE.
        -
        6095  // node->free.prev, next can be undefined.
        -
        6096  void AddToFreeListFront(uint32_t level, Node* node);
        -
        6097  // Removes node from FreeList at given level.
        -
        6098  // node->type must be FREE.
        -
        6099  // node->free.prev, next stay untouched.
        -
        6100  void RemoveFromFreeList(uint32_t level, Node* node);
        -
        6101 
        -
        6102 #if VMA_STATS_STRING_ENABLED
        -
        6103  void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
        -
        6104 #endif
        -
        6105 };
        -
        6106 
        -
        6107 /*
        -
        6108 Represents a single block of device memory (`VkDeviceMemory`) with all the
        -
        6109 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
        -
        6110 
        -
        6111 Thread-safety: This class must be externally synchronized.
        -
        6112 */
        -
        6113 class VmaDeviceMemoryBlock
        -
        6114 {
        -
        6115  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
        -
        6116 public:
        -
        6117  VmaBlockMetadata* m_pMetadata;
        -
        6118 
        -
        6119  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
        -
        6120 
        -
        6121  ~VmaDeviceMemoryBlock()
        -
        6122  {
        -
        6123  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
        -
        6124  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        -
        6125  }
        -
        6126 
        -
        6127  // Always call after construction.
        -
        6128  void Init(
        -
        6129  VmaAllocator hAllocator,
        -
        6130  VmaPool hParentPool,
        -
        6131  uint32_t newMemoryTypeIndex,
        -
        6132  VkDeviceMemory newMemory,
        -
        6133  VkDeviceSize newSize,
        -
        6134  uint32_t id,
        -
        6135  uint32_t algorithm);
        -
        6136  // Always call before destruction.
        -
        6137  void Destroy(VmaAllocator allocator);
        -
        6138 
        -
        6139  VmaPool GetParentPool() const { return m_hParentPool; }
        -
        6140  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
        -
        6141  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        -
        6142  uint32_t GetId() const { return m_Id; }
        -
        6143  void* GetMappedData() const { return m_pMappedData; }
        -
        6144 
        -
        6145  // Validates all data structures inside this object. If not valid, returns false.
        -
        6146  bool Validate() const;
        +
        6038  virtual VkResult CheckCorruption(const void* pBlockData) { return VK_ERROR_FEATURE_NOT_PRESENT; }
        +
        6039 
        +
        6040  virtual void Alloc(
        +
        6041  const VmaAllocationRequest& request,
        +
        6042  VmaSuballocationType type,
        +
        6043  VkDeviceSize allocSize,
        +
        6044  VmaAllocation hAllocation);
        +
        6045 
        +
        6046  virtual void Free(const VmaAllocation allocation) { FreeAtOffset(allocation, allocation->GetOffset()); }
        +
        6047  virtual void FreeAtOffset(VkDeviceSize offset) { FreeAtOffset(VMA_NULL, offset); }
        +
        6048 
        +
        6049 private:
        +
        6050  static const VkDeviceSize MIN_NODE_SIZE = 32;
        +
        6051  static const size_t MAX_LEVELS = 30;
        +
        6052 
        +
        6053  struct ValidationContext
        +
        6054  {
        +
        6055  size_t calculatedAllocationCount;
        +
        6056  size_t calculatedFreeCount;
        +
        6057  VkDeviceSize calculatedSumFreeSize;
        +
        6058 
        +
        6059  ValidationContext() :
        +
        6060  calculatedAllocationCount(0),
        +
        6061  calculatedFreeCount(0),
        +
        6062  calculatedSumFreeSize(0) { }
        +
        6063  };
        +
        6064 
        +
        6065  struct Node
        +
        6066  {
        +
        6067  VkDeviceSize offset;
        +
        6068  enum TYPE
        +
        6069  {
        +
        6070  TYPE_FREE,
        +
        6071  TYPE_ALLOCATION,
        +
        6072  TYPE_SPLIT,
        +
        6073  TYPE_COUNT
        +
        6074  } type;
        +
        6075  Node* parent;
        +
        6076  Node* buddy;
        +
        6077 
        +
        6078  union
        +
        6079  {
        +
        6080  struct
        +
        6081  {
        +
        6082  Node* prev;
        +
        6083  Node* next;
        +
        6084  } free;
        +
        6085  struct
        +
        6086  {
        +
        6087  VmaAllocation alloc;
        +
        6088  } allocation;
        +
        6089  struct
        +
        6090  {
        +
        6091  Node* leftChild;
        +
        6092  } split;
        +
        6093  };
        +
        6094  };
        +
        6095 
        +
        6096  // Size of the memory block aligned down to a power of two.
        +
        6097  VkDeviceSize m_UsableSize;
        +
        6098  uint32_t m_LevelCount;
        +
        6099 
        +
        6100  Node* m_Root;
        +
        6101  struct {
        +
        6102  Node* front;
        +
        6103  Node* back;
        +
        6104  } m_FreeList[MAX_LEVELS];
        +
        6105  // Number of nodes in the tree with type == TYPE_ALLOCATION.
        +
        6106  size_t m_AllocationCount;
        +
        6107  // Number of nodes in the tree with type == TYPE_FREE.
        +
        6108  size_t m_FreeCount;
        +
        6109  // This includes space wasted due to internal fragmentation. Doesn't include unusable size.
        +
        6110  VkDeviceSize m_SumFreeSize;
        +
        6111 
        +
        6112  VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
        +
        6113  void DeleteNode(Node* node);
        +
        6114  bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
        +
        6115  uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
        +
        6116  inline VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }
        +
        6117  // Alloc passed just for validation. Can be null.
        +
        6118  void FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset);
        +
        6119  void CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const;
        +
        6120  // Adds node to the front of FreeList at given level.
        +
        6121  // node->type must be FREE.
        +
        6122  // node->free.prev, next can be undefined.
        +
        6123  void AddToFreeListFront(uint32_t level, Node* node);
        +
        6124  // Removes node from FreeList at given level.
        +
        6125  // node->type must be FREE.
        +
        6126  // node->free.prev, next stay untouched.
        +
        6127  void RemoveFromFreeList(uint32_t level, Node* node);
        +
        6128 
        +
        6129 #if VMA_STATS_STRING_ENABLED
        +
        6130  void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
        +
        6131 #endif
        +
        6132 };
        +
        6133 
        +
        6134 /*
        +
        6135 Represents a single block of device memory (`VkDeviceMemory`) with all the
        +
        6136 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
        +
        6137 
        +
        6138 Thread-safety: This class must be externally synchronized.
        +
        6139 */
        +
        6140 class VmaDeviceMemoryBlock
        +
        6141 {
        +
        6142  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
        +
        6143 public:
        +
        6144  VmaBlockMetadata* m_pMetadata;
        +
        6145 
        +
        6146  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
        6147 
        -
        6148  VkResult CheckCorruption(VmaAllocator hAllocator);
        -
        6149 
        -
        6150  // ppData can be null.
        -
        6151  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
        -
        6152  void Unmap(VmaAllocator hAllocator, uint32_t count);
        +
        6148  ~VmaDeviceMemoryBlock()
        +
        6149  {
        +
        6150  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
        +
        6151  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        +
        6152  }
        6153 
        -
        6154  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        -
        6155  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        -
        6156 
        -
        6157  VkResult BindBufferMemory(
        -
        6158  const VmaAllocator hAllocator,
        -
        6159  const VmaAllocation hAllocation,
        -
        6160  VkDeviceSize allocationLocalOffset,
        -
        6161  VkBuffer hBuffer,
        -
        6162  const void* pNext);
        -
        6163  VkResult BindImageMemory(
        -
        6164  const VmaAllocator hAllocator,
        -
        6165  const VmaAllocation hAllocation,
        -
        6166  VkDeviceSize allocationLocalOffset,
        -
        6167  VkImage hImage,
        -
        6168  const void* pNext);
        -
        6169 
        -
        6170 private:
        -
        6171  VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
        -
        6172  uint32_t m_MemoryTypeIndex;
        -
        6173  uint32_t m_Id;
        -
        6174  VkDeviceMemory m_hMemory;
        -
        6175 
        -
        6176  /*
        -
        6177  Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
        -
        6178  Also protects m_MapCount, m_pMappedData.
        -
        6179  Allocations, deallocations, any change in m_pMetadata is protected by parent's VmaBlockVector::m_Mutex.
        -
        6180  */
        -
        6181  VMA_MUTEX m_Mutex;
        -
        6182  uint32_t m_MapCount;
        -
        6183  void* m_pMappedData;
        -
        6184 };
        -
        6185 
        -
        6186 struct VmaPointerLess
        -
        6187 {
        -
        6188  bool operator()(const void* lhs, const void* rhs) const
        -
        6189  {
        -
        6190  return lhs < rhs;
        -
        6191  }
        -
        6192 };
        -
        6193 
        -
        6194 struct VmaDefragmentationMove
        -
        6195 {
        -
        6196  size_t srcBlockIndex;
        -
        6197  size_t dstBlockIndex;
        -
        6198  VkDeviceSize srcOffset;
        -
        6199  VkDeviceSize dstOffset;
        -
        6200  VkDeviceSize size;
        -
        6201 };
        +
        6154  // Always call after construction.
        +
        6155  void Init(
        +
        6156  VmaAllocator hAllocator,
        +
        6157  VmaPool hParentPool,
        +
        6158  uint32_t newMemoryTypeIndex,
        +
        6159  VkDeviceMemory newMemory,
        +
        6160  VkDeviceSize newSize,
        +
        6161  uint32_t id,
        +
        6162  uint32_t algorithm);
        +
        6163  // Always call before destruction.
        +
        6164  void Destroy(VmaAllocator allocator);
        +
        6165 
        +
        6166  VmaPool GetParentPool() const { return m_hParentPool; }
        +
        6167  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
        +
        6168  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        +
        6169  uint32_t GetId() const { return m_Id; }
        +
        6170  void* GetMappedData() const { return m_pMappedData; }
        +
        6171 
        +
        6172  // Validates all data structures inside this object. If not valid, returns false.
        +
        6173  bool Validate() const;
        +
        6174 
        +
        6175  VkResult CheckCorruption(VmaAllocator hAllocator);
        +
        6176 
        +
        6177  // ppData can be null.
        +
        6178  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
        +
        6179  void Unmap(VmaAllocator hAllocator, uint32_t count);
        +
        6180 
        +
        6181  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        +
        6182  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        +
        6183 
        +
        6184  VkResult BindBufferMemory(
        +
        6185  const VmaAllocator hAllocator,
        +
        6186  const VmaAllocation hAllocation,
        +
        6187  VkDeviceSize allocationLocalOffset,
        +
        6188  VkBuffer hBuffer,
        +
        6189  const void* pNext);
        +
        6190  VkResult BindImageMemory(
        +
        6191  const VmaAllocator hAllocator,
        +
        6192  const VmaAllocation hAllocation,
        +
        6193  VkDeviceSize allocationLocalOffset,
        +
        6194  VkImage hImage,
        +
        6195  const void* pNext);
        +
        6196 
        +
        6197 private:
        +
        6198  VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
        +
        6199  uint32_t m_MemoryTypeIndex;
        +
        6200  uint32_t m_Id;
        +
        6201  VkDeviceMemory m_hMemory;
        6202 
        -
        6203 class VmaDefragmentationAlgorithm;
        -
        6204 
        -
        6205 /*
        -
        6206 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
        -
        6207 Vulkan memory type.
        -
        6208 
        -
        6209 Synchronized internally with a mutex.
        -
        6210 */
        -
        6211 struct VmaBlockVector
        -
        6212 {
        -
        6213  VMA_CLASS_NO_COPY(VmaBlockVector)
        -
        6214 public:
        -
        6215  VmaBlockVector(
        -
        6216  VmaAllocator hAllocator,
        -
        6217  VmaPool hParentPool,
        -
        6218  uint32_t memoryTypeIndex,
        -
        6219  VkDeviceSize preferredBlockSize,
        -
        6220  size_t minBlockCount,
        -
        6221  size_t maxBlockCount,
        -
        6222  VkDeviceSize bufferImageGranularity,
        -
        6223  uint32_t frameInUseCount,
        -
        6224  bool explicitBlockSize,
        -
        6225  uint32_t algorithm);
        -
        6226  ~VmaBlockVector();
        -
        6227 
        -
        6228  VkResult CreateMinBlocks();
        +
        6203  /*
        +
        6204  Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
        +
        6205  Also protects m_MapCount, m_pMappedData.
        +
        6206  Allocations, deallocations, any change in m_pMetadata is protected by parent's VmaBlockVector::m_Mutex.
        +
        6207  */
        +
        6208  VMA_MUTEX m_Mutex;
        +
        6209  uint32_t m_MapCount;
        +
        6210  void* m_pMappedData;
        +
        6211 };
        +
        6212 
        +
        6213 struct VmaPointerLess
        +
        6214 {
        +
        6215  bool operator()(const void* lhs, const void* rhs) const
        +
        6216  {
        +
        6217  return lhs < rhs;
        +
        6218  }
        +
        6219 };
        +
        6220 
        +
        6221 struct VmaDefragmentationMove
        +
        6222 {
        +
        6223  size_t srcBlockIndex;
        +
        6224  size_t dstBlockIndex;
        +
        6225  VkDeviceSize srcOffset;
        +
        6226  VkDeviceSize dstOffset;
        +
        6227  VkDeviceSize size;
        +
        6228 };
        6229 
        -
        6230  VmaAllocator GetAllocator() const { return m_hAllocator; }
        -
        6231  VmaPool GetParentPool() const { return m_hParentPool; }
        -
        6232  bool IsCustomPool() const { return m_hParentPool != VMA_NULL; }
        -
        6233  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        -
        6234  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
        -
        6235  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
        -
        6236  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
        -
        6237  uint32_t GetAlgorithm() const { return m_Algorithm; }
        -
        6238 
        -
        6239  void GetPoolStats(VmaPoolStats* pStats);
        -
        6240 
        -
        6241  bool IsEmpty() const { return m_Blocks.empty(); }
        -
        6242  bool IsCorruptionDetectionEnabled() const;
        -
        6243 
        -
        6244  VkResult Allocate(
        -
        6245  uint32_t currentFrameIndex,
        -
        6246  VkDeviceSize size,
        -
        6247  VkDeviceSize alignment,
        -
        6248  const VmaAllocationCreateInfo& createInfo,
        -
        6249  VmaSuballocationType suballocType,
        -
        6250  size_t allocationCount,
        -
        6251  VmaAllocation* pAllocations);
        -
        6252 
        -
        6253  void Free(const VmaAllocation hAllocation);
        +
        6230 class VmaDefragmentationAlgorithm;
        +
        6231 
        +
        6232 /*
        +
        6233 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
        +
        6234 Vulkan memory type.
        +
        6235 
        +
        6236 Synchronized internally with a mutex.
        +
        6237 */
        +
        6238 struct VmaBlockVector
        +
        6239 {
        +
        6240  VMA_CLASS_NO_COPY(VmaBlockVector)
        +
        6241 public:
        +
        6242  VmaBlockVector(
        +
        6243  VmaAllocator hAllocator,
        +
        6244  VmaPool hParentPool,
        +
        6245  uint32_t memoryTypeIndex,
        +
        6246  VkDeviceSize preferredBlockSize,
        +
        6247  size_t minBlockCount,
        +
        6248  size_t maxBlockCount,
        +
        6249  VkDeviceSize bufferImageGranularity,
        +
        6250  uint32_t frameInUseCount,
        +
        6251  bool explicitBlockSize,
        +
        6252  uint32_t algorithm);
        +
        6253  ~VmaBlockVector();
        6254 
        -
        6255  // Adds statistics of this BlockVector to pStats.
        -
        6256  void AddStats(VmaStats* pStats);
        -
        6257 
        -
        6258 #if VMA_STATS_STRING_ENABLED
        -
        6259  void PrintDetailedMap(class VmaJsonWriter& json);
        -
        6260 #endif
        -
        6261 
        -
        6262  void MakePoolAllocationsLost(
        -
        6263  uint32_t currentFrameIndex,
        -
        6264  size_t* pLostAllocationCount);
        -
        6265  VkResult CheckCorruption();
        -
        6266 
        -
        6267  // Saves results in pCtx->res.
        -
        6268  void Defragment(
        -
        6269  class VmaBlockVectorDefragmentationContext* pCtx,
        -
        6270  VmaDefragmentationStats* pStats,
        -
        6271  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
        -
        6272  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
        -
        6273  VkCommandBuffer commandBuffer);
        -
        6274  void DefragmentationEnd(
        -
        6275  class VmaBlockVectorDefragmentationContext* pCtx,
        -
        6276  VmaDefragmentationStats* pStats);
        -
        6277 
        -
        6279  // To be used only while the m_Mutex is locked. Used during defragmentation.
        -
        6280 
        -
        6281  size_t GetBlockCount() const { return m_Blocks.size(); }
        -
        6282  VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
        -
        6283  size_t CalcAllocationCount() const;
        -
        6284  bool IsBufferImageGranularityConflictPossible() const;
        -
        6285 
        -
        6286 private:
        -
        6287  friend class VmaDefragmentationAlgorithm_Generic;
        +
        6255  VkResult CreateMinBlocks();
        +
        6256 
        +
        6257  VmaAllocator GetAllocator() const { return m_hAllocator; }
        +
        6258  VmaPool GetParentPool() const { return m_hParentPool; }
        +
        6259  bool IsCustomPool() const { return m_hParentPool != VMA_NULL; }
        +
        6260  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        +
        6261  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
        +
        6262  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
        +
        6263  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
        +
        6264  uint32_t GetAlgorithm() const { return m_Algorithm; }
        +
        6265 
        +
        6266  void GetPoolStats(VmaPoolStats* pStats);
        +
        6267 
        +
        6268  bool IsEmpty() const { return m_Blocks.empty(); }
        +
        6269  bool IsCorruptionDetectionEnabled() const;
        +
        6270 
        +
        6271  VkResult Allocate(
        +
        6272  uint32_t currentFrameIndex,
        +
        6273  VkDeviceSize size,
        +
        6274  VkDeviceSize alignment,
        +
        6275  const VmaAllocationCreateInfo& createInfo,
        +
        6276  VmaSuballocationType suballocType,
        +
        6277  size_t allocationCount,
        +
        6278  VmaAllocation* pAllocations);
        +
        6279 
        +
        6280  void Free(const VmaAllocation hAllocation);
        +
        6281 
        +
        6282  // Adds statistics of this BlockVector to pStats.
        +
        6283  void AddStats(VmaStats* pStats);
        +
        6284 
        +
        6285 #if VMA_STATS_STRING_ENABLED
        +
        6286  void PrintDetailedMap(class VmaJsonWriter& json);
        +
        6287 #endif
        6288 
        -
        6289  const VmaAllocator m_hAllocator;
        -
        6290  const VmaPool m_hParentPool;
        -
        6291  const uint32_t m_MemoryTypeIndex;
        -
        6292  const VkDeviceSize m_PreferredBlockSize;
        -
        6293  const size_t m_MinBlockCount;
        -
        6294  const size_t m_MaxBlockCount;
        -
        6295  const VkDeviceSize m_BufferImageGranularity;
        -
        6296  const uint32_t m_FrameInUseCount;
        -
        6297  const bool m_ExplicitBlockSize;
        -
        6298  const uint32_t m_Algorithm;
        -
        6299  /* There can be at most one allocation that is completely empty - a
        -
        6300  hysteresis to avoid pessimistic case of alternating creation and destruction
        -
        6301  of a VkDeviceMemory. */
        -
        6302  bool m_HasEmptyBlock;
        -
        6303  VMA_RW_MUTEX m_Mutex;
        -
        6304  // Incrementally sorted by sumFreeSize, ascending.
        -
        6305  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
        -
        6306  uint32_t m_NextBlockId;
        +
        6289  void MakePoolAllocationsLost(
        +
        6290  uint32_t currentFrameIndex,
        +
        6291  size_t* pLostAllocationCount);
        +
        6292  VkResult CheckCorruption();
        +
        6293 
        +
        6294  // Saves results in pCtx->res.
        +
        6295  void Defragment(
        +
        6296  class VmaBlockVectorDefragmentationContext* pCtx,
        +
        6297  VmaDefragmentationStats* pStats,
        +
        6298  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
        +
        6299  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
        +
        6300  VkCommandBuffer commandBuffer);
        +
        6301  void DefragmentationEnd(
        +
        6302  class VmaBlockVectorDefragmentationContext* pCtx,
        +
        6303  VmaDefragmentationStats* pStats);
        +
        6304 
        +
        6306  // To be used only while the m_Mutex is locked. Used during defragmentation.
        6307 
        -
        6308  VkDeviceSize CalcMaxBlockSize() const;
        -
        6309 
        -
        6310  // Finds and removes given block from vector.
        -
        6311  void Remove(VmaDeviceMemoryBlock* pBlock);
        +
        6308  size_t GetBlockCount() const { return m_Blocks.size(); }
        +
        6309  VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
        +
        6310  size_t CalcAllocationCount() const;
        +
        6311  bool IsBufferImageGranularityConflictPossible() const;
        6312 
        -
        6313  // Performs single step in sorting m_Blocks. They may not be fully sorted
        -
        6314  // after this call.
        -
        6315  void IncrementallySortBlocks();
        -
        6316 
        -
        6317  VkResult AllocatePage(
        -
        6318  uint32_t currentFrameIndex,
        -
        6319  VkDeviceSize size,
        -
        6320  VkDeviceSize alignment,
        -
        6321  const VmaAllocationCreateInfo& createInfo,
        -
        6322  VmaSuballocationType suballocType,
        -
        6323  VmaAllocation* pAllocation);
        -
        6324 
        -
        6325  // To be used only without CAN_MAKE_OTHER_LOST flag.
        -
        6326  VkResult AllocateFromBlock(
        -
        6327  VmaDeviceMemoryBlock* pBlock,
        -
        6328  uint32_t currentFrameIndex,
        -
        6329  VkDeviceSize size,
        -
        6330  VkDeviceSize alignment,
        -
        6331  VmaAllocationCreateFlags allocFlags,
        -
        6332  void* pUserData,
        -
        6333  VmaSuballocationType suballocType,
        -
        6334  uint32_t strategy,
        -
        6335  VmaAllocation* pAllocation);
        +
        6313 private:
        +
        6314  friend class VmaDefragmentationAlgorithm_Generic;
        +
        6315 
        +
        6316  const VmaAllocator m_hAllocator;
        +
        6317  const VmaPool m_hParentPool;
        +
        6318  const uint32_t m_MemoryTypeIndex;
        +
        6319  const VkDeviceSize m_PreferredBlockSize;
        +
        6320  const size_t m_MinBlockCount;
        +
        6321  const size_t m_MaxBlockCount;
        +
        6322  const VkDeviceSize m_BufferImageGranularity;
        +
        6323  const uint32_t m_FrameInUseCount;
        +
        6324  const bool m_ExplicitBlockSize;
        +
        6325  const uint32_t m_Algorithm;
        +
        6326  VMA_RW_MUTEX m_Mutex;
        +
        6327 
        +
        6328  /* There can be at most one allocation that is completely empty (except when minBlockCount > 0) -
        +
        6329  a hysteresis to avoid pessimistic case of alternating creation and destruction of a VkDeviceMemory. */
        +
        6330  bool m_HasEmptyBlock;
        +
        6331  // Incrementally sorted by sumFreeSize, ascending.
        +
        6332  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
        +
        6333  uint32_t m_NextBlockId;
        +
        6334 
        +
        6335  VkDeviceSize CalcMaxBlockSize() const;
        6336 
        -
        6337  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
        -
        6338 
        -
        6339  // Saves result to pCtx->res.
        -
        6340  void ApplyDefragmentationMovesCpu(
        -
        6341  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        -
        6342  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves);
        -
        6343  // Saves result to pCtx->res.
        -
        6344  void ApplyDefragmentationMovesGpu(
        -
        6345  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        -
        6346  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        6347  VkCommandBuffer commandBuffer);
        -
        6348 
        -
        6349  /*
        -
        6350  Used during defragmentation. pDefragmentationStats is optional. It's in/out
        -
        6351  - updated with new data.
        -
        6352  */
        -
        6353  void FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats);
        -
        6354 };
        -
        6355 
        -
        6356 struct VmaPool_T
        -
        6357 {
        -
        6358  VMA_CLASS_NO_COPY(VmaPool_T)
        -
        6359 public:
        -
        6360  VmaBlockVector m_BlockVector;
        -
        6361 
        -
        6362  VmaPool_T(
        -
        6363  VmaAllocator hAllocator,
        -
        6364  const VmaPoolCreateInfo& createInfo,
        -
        6365  VkDeviceSize preferredBlockSize);
        -
        6366  ~VmaPool_T();
        -
        6367 
        -
        6368  uint32_t GetId() const { return m_Id; }
        -
        6369  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
        -
        6370 
        -
        6371  const char* GetName() const { return m_Name; }
        -
        6372  void SetName(const char* pName);
        -
        6373 
        -
        6374 #if VMA_STATS_STRING_ENABLED
        -
        6375  //void PrintDetailedMap(class VmaStringBuilder& sb);
        -
        6376 #endif
        -
        6377 
        -
        6378 private:
        -
        6379  uint32_t m_Id;
        -
        6380  char* m_Name;
        -
        6381 };
        -
        6382 
        -
        6383 /*
        -
        6384 Performs defragmentation:
        -
        6385 
        -
        6386 - Updates `pBlockVector->m_pMetadata`.
        -
        6387 - Updates allocations by calling ChangeBlockAllocation() or ChangeOffset().
        -
        6388 - Does not move actual data, only returns requested moves as `moves`.
        -
        6389 */
        -
        6390 class VmaDefragmentationAlgorithm
        -
        6391 {
        -
        6392  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm)
        -
        6393 public:
        -
        6394  VmaDefragmentationAlgorithm(
        -
        6395  VmaAllocator hAllocator,
        -
        6396  VmaBlockVector* pBlockVector,
        -
        6397  uint32_t currentFrameIndex) :
        -
        6398  m_hAllocator(hAllocator),
        -
        6399  m_pBlockVector(pBlockVector),
        -
        6400  m_CurrentFrameIndex(currentFrameIndex)
        -
        6401  {
        -
        6402  }
        -
        6403  virtual ~VmaDefragmentationAlgorithm()
        -
        6404  {
        -
        6405  }
        +
        6337  // Finds and removes given block from vector.
        +
        6338  void Remove(VmaDeviceMemoryBlock* pBlock);
        +
        6339 
        +
        6340  // Performs single step in sorting m_Blocks. They may not be fully sorted
        +
        6341  // after this call.
        +
        6342  void IncrementallySortBlocks();
        +
        6343 
        +
        6344  VkResult AllocatePage(
        +
        6345  uint32_t currentFrameIndex,
        +
        6346  VkDeviceSize size,
        +
        6347  VkDeviceSize alignment,
        +
        6348  const VmaAllocationCreateInfo& createInfo,
        +
        6349  VmaSuballocationType suballocType,
        +
        6350  VmaAllocation* pAllocation);
        +
        6351 
        +
        6352  // To be used only without CAN_MAKE_OTHER_LOST flag.
        +
        6353  VkResult AllocateFromBlock(
        +
        6354  VmaDeviceMemoryBlock* pBlock,
        +
        6355  uint32_t currentFrameIndex,
        +
        6356  VkDeviceSize size,
        +
        6357  VkDeviceSize alignment,
        +
        6358  VmaAllocationCreateFlags allocFlags,
        +
        6359  void* pUserData,
        +
        6360  VmaSuballocationType suballocType,
        +
        6361  uint32_t strategy,
        +
        6362  VmaAllocation* pAllocation);
        +
        6363 
        +
        6364  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
        +
        6365 
        +
        6366  // Saves result to pCtx->res.
        +
        6367  void ApplyDefragmentationMovesCpu(
        +
        6368  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        +
        6369  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves);
        +
        6370  // Saves result to pCtx->res.
        +
        6371  void ApplyDefragmentationMovesGpu(
        +
        6372  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        +
        6373  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        6374  VkCommandBuffer commandBuffer);
        +
        6375 
        +
        6376  /*
        +
        6377  Used during defragmentation. pDefragmentationStats is optional. It's in/out
        +
        6378  - updated with new data.
        +
        6379  */
        +
        6380  void FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats);
        +
        6381 
        +
        6382  void UpdateHasEmptyBlock();
        +
        6383 };
        +
        6384 
        +
        6385 struct VmaPool_T
        +
        6386 {
        +
        6387  VMA_CLASS_NO_COPY(VmaPool_T)
        +
        6388 public:
        +
        6389  VmaBlockVector m_BlockVector;
        +
        6390 
        +
        6391  VmaPool_T(
        +
        6392  VmaAllocator hAllocator,
        +
        6393  const VmaPoolCreateInfo& createInfo,
        +
        6394  VkDeviceSize preferredBlockSize);
        +
        6395  ~VmaPool_T();
        +
        6396 
        +
        6397  uint32_t GetId() const { return m_Id; }
        +
        6398  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
        +
        6399 
        +
        6400  const char* GetName() const { return m_Name; }
        +
        6401  void SetName(const char* pName);
        +
        6402 
        +
        6403 #if VMA_STATS_STRING_ENABLED
        +
        6404  //void PrintDetailedMap(class VmaStringBuilder& sb);
        +
        6405 #endif
        6406 
        -
        6407  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) = 0;
        -
        6408  virtual void AddAll() = 0;
        -
        6409 
        -
        6410  virtual VkResult Defragment(
        -
        6411  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        6412  VkDeviceSize maxBytesToMove,
        -
        6413  uint32_t maxAllocationsToMove) = 0;
        -
        6414 
        -
        6415  virtual VkDeviceSize GetBytesMoved() const = 0;
        -
        6416  virtual uint32_t GetAllocationsMoved() const = 0;
        -
        6417 
        -
        6418 protected:
        -
        6419  VmaAllocator const m_hAllocator;
        -
        6420  VmaBlockVector* const m_pBlockVector;
        -
        6421  const uint32_t m_CurrentFrameIndex;
        -
        6422 
        -
        6423  struct AllocationInfo
        -
        6424  {
        -
        6425  VmaAllocation m_hAllocation;
        -
        6426  VkBool32* m_pChanged;
        -
        6427 
        -
        6428  AllocationInfo() :
        -
        6429  m_hAllocation(VK_NULL_HANDLE),
        -
        6430  m_pChanged(VMA_NULL)
        -
        6431  {
        -
        6432  }
        -
        6433  AllocationInfo(VmaAllocation hAlloc, VkBool32* pChanged) :
        -
        6434  m_hAllocation(hAlloc),
        -
        6435  m_pChanged(pChanged)
        -
        6436  {
        -
        6437  }
        -
        6438  };
        -
        6439 };
        -
        6440 
        -
        6441 class VmaDefragmentationAlgorithm_Generic : public VmaDefragmentationAlgorithm
        -
        6442 {
        -
        6443  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Generic)
        -
        6444 public:
        -
        6445  VmaDefragmentationAlgorithm_Generic(
        -
        6446  VmaAllocator hAllocator,
        -
        6447  VmaBlockVector* pBlockVector,
        -
        6448  uint32_t currentFrameIndex,
        -
        6449  bool overlappingMoveSupported);
        -
        6450  virtual ~VmaDefragmentationAlgorithm_Generic();
        +
        6407 private:
        +
        6408  uint32_t m_Id;
        +
        6409  char* m_Name;
        +
        6410 };
        +
        6411 
        +
        6412 /*
        +
        6413 Performs defragmentation:
        +
        6414 
        +
        6415 - Updates `pBlockVector->m_pMetadata`.
        +
        6416 - Updates allocations by calling ChangeBlockAllocation() or ChangeOffset().
        +
        6417 - Does not move actual data, only returns requested moves as `moves`.
        +
        6418 */
        +
        6419 class VmaDefragmentationAlgorithm
        +
        6420 {
        +
        6421  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm)
        +
        6422 public:
        +
        6423  VmaDefragmentationAlgorithm(
        +
        6424  VmaAllocator hAllocator,
        +
        6425  VmaBlockVector* pBlockVector,
        +
        6426  uint32_t currentFrameIndex) :
        +
        6427  m_hAllocator(hAllocator),
        +
        6428  m_pBlockVector(pBlockVector),
        +
        6429  m_CurrentFrameIndex(currentFrameIndex)
        +
        6430  {
        +
        6431  }
        +
        6432  virtual ~VmaDefragmentationAlgorithm()
        +
        6433  {
        +
        6434  }
        +
        6435 
        +
        6436  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) = 0;
        +
        6437  virtual void AddAll() = 0;
        +
        6438 
        +
        6439  virtual VkResult Defragment(
        +
        6440  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        6441  VkDeviceSize maxBytesToMove,
        +
        6442  uint32_t maxAllocationsToMove) = 0;
        +
        6443 
        +
        6444  virtual VkDeviceSize GetBytesMoved() const = 0;
        +
        6445  virtual uint32_t GetAllocationsMoved() const = 0;
        +
        6446 
        +
        6447 protected:
        +
        6448  VmaAllocator const m_hAllocator;
        +
        6449  VmaBlockVector* const m_pBlockVector;
        +
        6450  const uint32_t m_CurrentFrameIndex;
        6451 
        -
        6452  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        -
        6453  virtual void AddAll() { m_AllAllocations = true; }
        -
        6454 
        -
        6455  virtual VkResult Defragment(
        -
        6456  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        6457  VkDeviceSize maxBytesToMove,
        -
        6458  uint32_t maxAllocationsToMove);
        -
        6459 
        -
        6460  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        -
        6461  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        -
        6462 
        -
        6463 private:
        -
        6464  uint32_t m_AllocationCount;
        -
        6465  bool m_AllAllocations;
        -
        6466 
        -
        6467  VkDeviceSize m_BytesMoved;
        -
        6468  uint32_t m_AllocationsMoved;
        +
        6452  struct AllocationInfo
        +
        6453  {
        +
        6454  VmaAllocation m_hAllocation;
        +
        6455  VkBool32* m_pChanged;
        +
        6456 
        +
        6457  AllocationInfo() :
        +
        6458  m_hAllocation(VK_NULL_HANDLE),
        +
        6459  m_pChanged(VMA_NULL)
        +
        6460  {
        +
        6461  }
        +
        6462  AllocationInfo(VmaAllocation hAlloc, VkBool32* pChanged) :
        +
        6463  m_hAllocation(hAlloc),
        +
        6464  m_pChanged(pChanged)
        +
        6465  {
        +
        6466  }
        +
        6467  };
        +
        6468 };
        6469 
        -
        6470  struct AllocationInfoSizeGreater
        -
        6471  {
        -
        6472  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        -
        6473  {
        -
        6474  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
        -
        6475  }
        -
        6476  };
        -
        6477 
        -
        6478  struct AllocationInfoOffsetGreater
        -
        6479  {
        -
        6480  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        -
        6481  {
        -
        6482  return lhs.m_hAllocation->GetOffset() > rhs.m_hAllocation->GetOffset();
        -
        6483  }
        -
        6484  };
        -
        6485 
        -
        6486  struct BlockInfo
        -
        6487  {
        -
        6488  size_t m_OriginalBlockIndex;
        -
        6489  VmaDeviceMemoryBlock* m_pBlock;
        -
        6490  bool m_HasNonMovableAllocations;
        -
        6491  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        -
        6492 
        -
        6493  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
        -
        6494  m_OriginalBlockIndex(SIZE_MAX),
        -
        6495  m_pBlock(VMA_NULL),
        -
        6496  m_HasNonMovableAllocations(true),
        -
        6497  m_Allocations(pAllocationCallbacks)
        -
        6498  {
        -
        6499  }
        -
        6500 
        -
        6501  void CalcHasNonMovableAllocations()
        -
        6502  {
        -
        6503  const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();
        -
        6504  const size_t defragmentAllocCount = m_Allocations.size();
        -
        6505  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
        -
        6506  }
        -
        6507 
        -
        6508  void SortAllocationsBySizeDescending()
        -
        6509  {
        -
        6510  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
        -
        6511  }
        -
        6512 
        -
        6513  void SortAllocationsByOffsetDescending()
        -
        6514  {
        -
        6515  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoOffsetGreater());
        -
        6516  }
        -
        6517  };
        -
        6518 
        -
        6519  struct BlockPointerLess
        -
        6520  {
        -
        6521  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
        -
        6522  {
        -
        6523  return pLhsBlockInfo->m_pBlock < pRhsBlock;
        -
        6524  }
        -
        6525  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        -
        6526  {
        -
        6527  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
        +
        6470 class VmaDefragmentationAlgorithm_Generic : public VmaDefragmentationAlgorithm
        +
        6471 {
        +
        6472  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Generic)
        +
        6473 public:
        +
        6474  VmaDefragmentationAlgorithm_Generic(
        +
        6475  VmaAllocator hAllocator,
        +
        6476  VmaBlockVector* pBlockVector,
        +
        6477  uint32_t currentFrameIndex,
        +
        6478  bool overlappingMoveSupported);
        +
        6479  virtual ~VmaDefragmentationAlgorithm_Generic();
        +
        6480 
        +
        6481  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        +
        6482  virtual void AddAll() { m_AllAllocations = true; }
        +
        6483 
        +
        6484  virtual VkResult Defragment(
        +
        6485  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        6486  VkDeviceSize maxBytesToMove,
        +
        6487  uint32_t maxAllocationsToMove);
        +
        6488 
        +
        6489  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        +
        6490  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        +
        6491 
        +
        6492 private:
        +
        6493  uint32_t m_AllocationCount;
        +
        6494  bool m_AllAllocations;
        +
        6495 
        +
        6496  VkDeviceSize m_BytesMoved;
        +
        6497  uint32_t m_AllocationsMoved;
        +
        6498 
        +
        6499  struct AllocationInfoSizeGreater
        +
        6500  {
        +
        6501  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        +
        6502  {
        +
        6503  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
        +
        6504  }
        +
        6505  };
        +
        6506 
        +
        6507  struct AllocationInfoOffsetGreater
        +
        6508  {
        +
        6509  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        +
        6510  {
        +
        6511  return lhs.m_hAllocation->GetOffset() > rhs.m_hAllocation->GetOffset();
        +
        6512  }
        +
        6513  };
        +
        6514 
        +
        6515  struct BlockInfo
        +
        6516  {
        +
        6517  size_t m_OriginalBlockIndex;
        +
        6518  VmaDeviceMemoryBlock* m_pBlock;
        +
        6519  bool m_HasNonMovableAllocations;
        +
        6520  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        +
        6521 
        +
        6522  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
        +
        6523  m_OriginalBlockIndex(SIZE_MAX),
        +
        6524  m_pBlock(VMA_NULL),
        +
        6525  m_HasNonMovableAllocations(true),
        +
        6526  m_Allocations(pAllocationCallbacks)
        +
        6527  {
        6528  }
        -
        6529  };
        -
        6530 
        -
        6531  // 1. Blocks with some non-movable allocations go first.
        -
        6532  // 2. Blocks with smaller sumFreeSize go first.
        -
        6533  struct BlockInfoCompareMoveDestination
        -
        6534  {
        -
        6535  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        -
        6536  {
        -
        6537  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
        -
        6538  {
        -
        6539  return true;
        -
        6540  }
        -
        6541  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
        -
        6542  {
        -
        6543  return false;
        -
        6544  }
        -
        6545  if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())
        -
        6546  {
        -
        6547  return true;
        -
        6548  }
        -
        6549  return false;
        -
        6550  }
        -
        6551  };
        -
        6552 
        -
        6553  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
        -
        6554  BlockInfoVector m_Blocks;
        -
        6555 
        -
        6556  VkResult DefragmentRound(
        -
        6557  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        6558  VkDeviceSize maxBytesToMove,
        -
        6559  uint32_t maxAllocationsToMove);
        -
        6560 
        -
        6561  size_t CalcBlocksWithNonMovableCount() const;
        -
        6562 
        -
        6563  static bool MoveMakesSense(
        -
        6564  size_t dstBlockIndex, VkDeviceSize dstOffset,
        -
        6565  size_t srcBlockIndex, VkDeviceSize srcOffset);
        -
        6566 };
        -
        6567 
        -
        6568 class VmaDefragmentationAlgorithm_Fast : public VmaDefragmentationAlgorithm
        -
        6569 {
        -
        6570  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Fast)
        -
        6571 public:
        -
        6572  VmaDefragmentationAlgorithm_Fast(
        -
        6573  VmaAllocator hAllocator,
        -
        6574  VmaBlockVector* pBlockVector,
        -
        6575  uint32_t currentFrameIndex,
        -
        6576  bool overlappingMoveSupported);
        -
        6577  virtual ~VmaDefragmentationAlgorithm_Fast();
        -
        6578 
        -
        6579  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) { ++m_AllocationCount; }
        -
        6580  virtual void AddAll() { m_AllAllocations = true; }
        +
        6529 
        +
        6530  void CalcHasNonMovableAllocations()
        +
        6531  {
        +
        6532  const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();
        +
        6533  const size_t defragmentAllocCount = m_Allocations.size();
        +
        6534  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
        +
        6535  }
        +
        6536 
        +
        6537  void SortAllocationsBySizeDescending()
        +
        6538  {
        +
        6539  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
        +
        6540  }
        +
        6541 
        +
        6542  void SortAllocationsByOffsetDescending()
        +
        6543  {
        +
        6544  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoOffsetGreater());
        +
        6545  }
        +
        6546  };
        +
        6547 
        +
        6548  struct BlockPointerLess
        +
        6549  {
        +
        6550  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
        +
        6551  {
        +
        6552  return pLhsBlockInfo->m_pBlock < pRhsBlock;
        +
        6553  }
        +
        6554  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        +
        6555  {
        +
        6556  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
        +
        6557  }
        +
        6558  };
        +
        6559 
        +
        6560  // 1. Blocks with some non-movable allocations go first.
        +
        6561  // 2. Blocks with smaller sumFreeSize go first.
        +
        6562  struct BlockInfoCompareMoveDestination
        +
        6563  {
        +
        6564  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        +
        6565  {
        +
        6566  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
        +
        6567  {
        +
        6568  return true;
        +
        6569  }
        +
        6570  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
        +
        6571  {
        +
        6572  return false;
        +
        6573  }
        +
        6574  if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())
        +
        6575  {
        +
        6576  return true;
        +
        6577  }
        +
        6578  return false;
        +
        6579  }
        +
        6580  };
        6581 
        -
        6582  virtual VkResult Defragment(
        -
        6583  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        6584  VkDeviceSize maxBytesToMove,
        -
        6585  uint32_t maxAllocationsToMove);
        -
        6586 
        -
        6587  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        -
        6588  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        +
        6582  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
        +
        6583  BlockInfoVector m_Blocks;
        +
        6584 
        +
        6585  VkResult DefragmentRound(
        +
        6586  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        6587  VkDeviceSize maxBytesToMove,
        +
        6588  uint32_t maxAllocationsToMove);
        6589 
        -
        6590 private:
        -
        6591  struct BlockInfo
        -
        6592  {
        -
        6593  size_t origBlockIndex;
        -
        6594  };
        -
        6595 
        -
        6596  class FreeSpaceDatabase
        -
        6597  {
        -
        6598  public:
        -
        6599  FreeSpaceDatabase()
        -
        6600  {
        -
        6601  FreeSpace s = {};
        -
        6602  s.blockInfoIndex = SIZE_MAX;
        -
        6603  for(size_t i = 0; i < MAX_COUNT; ++i)
        -
        6604  {
        -
        6605  m_FreeSpaces[i] = s;
        -
        6606  }
        -
        6607  }
        -
        6608 
        -
        6609  void Register(size_t blockInfoIndex, VkDeviceSize offset, VkDeviceSize size)
        -
        6610  {
        -
        6611  if(size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        -
        6612  {
        -
        6613  return;
        -
        6614  }
        +
        6590  size_t CalcBlocksWithNonMovableCount() const;
        +
        6591 
        +
        6592  static bool MoveMakesSense(
        +
        6593  size_t dstBlockIndex, VkDeviceSize dstOffset,
        +
        6594  size_t srcBlockIndex, VkDeviceSize srcOffset);
        +
        6595 };
        +
        6596 
        +
        6597 class VmaDefragmentationAlgorithm_Fast : public VmaDefragmentationAlgorithm
        +
        6598 {
        +
        6599  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Fast)
        +
        6600 public:
        +
        6601  VmaDefragmentationAlgorithm_Fast(
        +
        6602  VmaAllocator hAllocator,
        +
        6603  VmaBlockVector* pBlockVector,
        +
        6604  uint32_t currentFrameIndex,
        +
        6605  bool overlappingMoveSupported);
        +
        6606  virtual ~VmaDefragmentationAlgorithm_Fast();
        +
        6607 
        +
        6608  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) { ++m_AllocationCount; }
        +
        6609  virtual void AddAll() { m_AllAllocations = true; }
        +
        6610 
        +
        6611  virtual VkResult Defragment(
        +
        6612  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        6613  VkDeviceSize maxBytesToMove,
        +
        6614  uint32_t maxAllocationsToMove);
        6615 
        -
        6616  // Find first invalid or the smallest structure.
        -
        6617  size_t bestIndex = SIZE_MAX;
        -
        6618  for(size_t i = 0; i < MAX_COUNT; ++i)
        -
        6619  {
        -
        6620  // Empty structure.
        -
        6621  if(m_FreeSpaces[i].blockInfoIndex == SIZE_MAX)
        -
        6622  {
        -
        6623  bestIndex = i;
        -
        6624  break;
        -
        6625  }
        -
        6626  if(m_FreeSpaces[i].size < size &&
        -
        6627  (bestIndex == SIZE_MAX || m_FreeSpaces[bestIndex].size > m_FreeSpaces[i].size))
        -
        6628  {
        -
        6629  bestIndex = i;
        -
        6630  }
        -
        6631  }
        -
        6632 
        -
        6633  if(bestIndex != SIZE_MAX)
        -
        6634  {
        -
        6635  m_FreeSpaces[bestIndex].blockInfoIndex = blockInfoIndex;
        -
        6636  m_FreeSpaces[bestIndex].offset = offset;
        -
        6637  m_FreeSpaces[bestIndex].size = size;
        -
        6638  }
        -
        6639  }
        -
        6640 
        -
        6641  bool Fetch(VkDeviceSize alignment, VkDeviceSize size,
        -
        6642  size_t& outBlockInfoIndex, VkDeviceSize& outDstOffset)
        -
        6643  {
        -
        6644  size_t bestIndex = SIZE_MAX;
        -
        6645  VkDeviceSize bestFreeSpaceAfter = 0;
        -
        6646  for(size_t i = 0; i < MAX_COUNT; ++i)
        -
        6647  {
        -
        6648  // Structure is valid.
        -
        6649  if(m_FreeSpaces[i].blockInfoIndex != SIZE_MAX)
        -
        6650  {
        -
        6651  const VkDeviceSize dstOffset = VmaAlignUp(m_FreeSpaces[i].offset, alignment);
        -
        6652  // Allocation fits into this structure.
        -
        6653  if(dstOffset + size <= m_FreeSpaces[i].offset + m_FreeSpaces[i].size)
        -
        6654  {
        -
        6655  const VkDeviceSize freeSpaceAfter = (m_FreeSpaces[i].offset + m_FreeSpaces[i].size) -
        -
        6656  (dstOffset + size);
        -
        6657  if(bestIndex == SIZE_MAX || freeSpaceAfter > bestFreeSpaceAfter)
        -
        6658  {
        -
        6659  bestIndex = i;
        -
        6660  bestFreeSpaceAfter = freeSpaceAfter;
        -
        6661  }
        -
        6662  }
        -
        6663  }
        -
        6664  }
        -
        6665 
        -
        6666  if(bestIndex != SIZE_MAX)
        -
        6667  {
        -
        6668  outBlockInfoIndex = m_FreeSpaces[bestIndex].blockInfoIndex;
        -
        6669  outDstOffset = VmaAlignUp(m_FreeSpaces[bestIndex].offset, alignment);
        -
        6670 
        -
        6671  if(bestFreeSpaceAfter >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        -
        6672  {
        -
        6673  // Leave this structure for remaining empty space.
        -
        6674  const VkDeviceSize alignmentPlusSize = (outDstOffset - m_FreeSpaces[bestIndex].offset) + size;
        -
        6675  m_FreeSpaces[bestIndex].offset += alignmentPlusSize;
        -
        6676  m_FreeSpaces[bestIndex].size -= alignmentPlusSize;
        -
        6677  }
        -
        6678  else
        +
        6616  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        +
        6617  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        +
        6618 
        +
        6619 private:
        +
        6620  struct BlockInfo
        +
        6621  {
        +
        6622  size_t origBlockIndex;
        +
        6623  };
        +
        6624 
        +
        6625  class FreeSpaceDatabase
        +
        6626  {
        +
        6627  public:
        +
        6628  FreeSpaceDatabase()
        +
        6629  {
        +
        6630  FreeSpace s = {};
        +
        6631  s.blockInfoIndex = SIZE_MAX;
        +
        6632  for(size_t i = 0; i < MAX_COUNT; ++i)
        +
        6633  {
        +
        6634  m_FreeSpaces[i] = s;
        +
        6635  }
        +
        6636  }
        +
        6637 
        +
        6638  void Register(size_t blockInfoIndex, VkDeviceSize offset, VkDeviceSize size)
        +
        6639  {
        +
        6640  if(size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        6641  {
        +
        6642  return;
        +
        6643  }
        +
        6644 
        +
        6645  // Find first invalid or the smallest structure.
        +
        6646  size_t bestIndex = SIZE_MAX;
        +
        6647  for(size_t i = 0; i < MAX_COUNT; ++i)
        +
        6648  {
        +
        6649  // Empty structure.
        +
        6650  if(m_FreeSpaces[i].blockInfoIndex == SIZE_MAX)
        +
        6651  {
        +
        6652  bestIndex = i;
        +
        6653  break;
        +
        6654  }
        +
        6655  if(m_FreeSpaces[i].size < size &&
        +
        6656  (bestIndex == SIZE_MAX || m_FreeSpaces[bestIndex].size > m_FreeSpaces[i].size))
        +
        6657  {
        +
        6658  bestIndex = i;
        +
        6659  }
        +
        6660  }
        +
        6661 
        +
        6662  if(bestIndex != SIZE_MAX)
        +
        6663  {
        +
        6664  m_FreeSpaces[bestIndex].blockInfoIndex = blockInfoIndex;
        +
        6665  m_FreeSpaces[bestIndex].offset = offset;
        +
        6666  m_FreeSpaces[bestIndex].size = size;
        +
        6667  }
        +
        6668  }
        +
        6669 
        +
        6670  bool Fetch(VkDeviceSize alignment, VkDeviceSize size,
        +
        6671  size_t& outBlockInfoIndex, VkDeviceSize& outDstOffset)
        +
        6672  {
        +
        6673  size_t bestIndex = SIZE_MAX;
        +
        6674  VkDeviceSize bestFreeSpaceAfter = 0;
        +
        6675  for(size_t i = 0; i < MAX_COUNT; ++i)
        +
        6676  {
        +
        6677  // Structure is valid.
        +
        6678  if(m_FreeSpaces[i].blockInfoIndex != SIZE_MAX)
        6679  {
        -
        6680  // This structure becomes invalid.
        -
        6681  m_FreeSpaces[bestIndex].blockInfoIndex = SIZE_MAX;
        -
        6682  }
        -
        6683 
        -
        6684  return true;
        -
        6685  }
        -
        6686 
        -
        6687  return false;
        -
        6688  }
        -
        6689 
        -
        6690  private:
        -
        6691  static const size_t MAX_COUNT = 4;
        -
        6692 
        -
        6693  struct FreeSpace
        -
        6694  {
        -
        6695  size_t blockInfoIndex; // SIZE_MAX means this structure is invalid.
        -
        6696  VkDeviceSize offset;
        -
        6697  VkDeviceSize size;
        -
        6698  } m_FreeSpaces[MAX_COUNT];
        -
        6699  };
        -
        6700 
        -
        6701  const bool m_OverlappingMoveSupported;
        -
        6702 
        -
        6703  uint32_t m_AllocationCount;
        -
        6704  bool m_AllAllocations;
        -
        6705 
        -
        6706  VkDeviceSize m_BytesMoved;
        -
        6707  uint32_t m_AllocationsMoved;
        -
        6708 
        -
        6709  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> > m_BlockInfos;
        -
        6710 
        -
        6711  void PreprocessMetadata();
        -
        6712  void PostprocessMetadata();
        -
        6713  void InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc);
        -
        6714 };
        +
        6680  const VkDeviceSize dstOffset = VmaAlignUp(m_FreeSpaces[i].offset, alignment);
        +
        6681  // Allocation fits into this structure.
        +
        6682  if(dstOffset + size <= m_FreeSpaces[i].offset + m_FreeSpaces[i].size)
        +
        6683  {
        +
        6684  const VkDeviceSize freeSpaceAfter = (m_FreeSpaces[i].offset + m_FreeSpaces[i].size) -
        +
        6685  (dstOffset + size);
        +
        6686  if(bestIndex == SIZE_MAX || freeSpaceAfter > bestFreeSpaceAfter)
        +
        6687  {
        +
        6688  bestIndex = i;
        +
        6689  bestFreeSpaceAfter = freeSpaceAfter;
        +
        6690  }
        +
        6691  }
        +
        6692  }
        +
        6693  }
        +
        6694 
        +
        6695  if(bestIndex != SIZE_MAX)
        +
        6696  {
        +
        6697  outBlockInfoIndex = m_FreeSpaces[bestIndex].blockInfoIndex;
        +
        6698  outDstOffset = VmaAlignUp(m_FreeSpaces[bestIndex].offset, alignment);
        +
        6699 
        +
        6700  if(bestFreeSpaceAfter >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        6701  {
        +
        6702  // Leave this structure for remaining empty space.
        +
        6703  const VkDeviceSize alignmentPlusSize = (outDstOffset - m_FreeSpaces[bestIndex].offset) + size;
        +
        6704  m_FreeSpaces[bestIndex].offset += alignmentPlusSize;
        +
        6705  m_FreeSpaces[bestIndex].size -= alignmentPlusSize;
        +
        6706  }
        +
        6707  else
        +
        6708  {
        +
        6709  // This structure becomes invalid.
        +
        6710  m_FreeSpaces[bestIndex].blockInfoIndex = SIZE_MAX;
        +
        6711  }
        +
        6712 
        +
        6713  return true;
        +
        6714  }
        6715 
        -
        6716 struct VmaBlockDefragmentationContext
        -
        6717 {
        -
        6718  enum BLOCK_FLAG
        -
        6719  {
        -
        6720  BLOCK_FLAG_USED = 0x00000001,
        -
        6721  };
        -
        6722  uint32_t flags;
        -
        6723  VkBuffer hBuffer;
        -
        6724 };
        -
        6725 
        -
        6726 class VmaBlockVectorDefragmentationContext
        -
        6727 {
        -
        6728  VMA_CLASS_NO_COPY(VmaBlockVectorDefragmentationContext)
        -
        6729 public:
        -
        6730  VkResult res;
        -
        6731  bool mutexLocked;
        -
        6732  VmaVector< VmaBlockDefragmentationContext, VmaStlAllocator<VmaBlockDefragmentationContext> > blockContexts;
        -
        6733 
        -
        6734  VmaBlockVectorDefragmentationContext(
        -
        6735  VmaAllocator hAllocator,
        -
        6736  VmaPool hCustomPool, // Optional.
        -
        6737  VmaBlockVector* pBlockVector,
        -
        6738  uint32_t currFrameIndex);
        -
        6739  ~VmaBlockVectorDefragmentationContext();
        -
        6740 
        -
        6741  VmaPool GetCustomPool() const { return m_hCustomPool; }
        -
        6742  VmaBlockVector* GetBlockVector() const { return m_pBlockVector; }
        -
        6743  VmaDefragmentationAlgorithm* GetAlgorithm() const { return m_pAlgorithm; }
        +
        6716  return false;
        +
        6717  }
        +
        6718 
        +
        6719  private:
        +
        6720  static const size_t MAX_COUNT = 4;
        +
        6721 
        +
        6722  struct FreeSpace
        +
        6723  {
        +
        6724  size_t blockInfoIndex; // SIZE_MAX means this structure is invalid.
        +
        6725  VkDeviceSize offset;
        +
        6726  VkDeviceSize size;
        +
        6727  } m_FreeSpaces[MAX_COUNT];
        +
        6728  };
        +
        6729 
        +
        6730  const bool m_OverlappingMoveSupported;
        +
        6731 
        +
        6732  uint32_t m_AllocationCount;
        +
        6733  bool m_AllAllocations;
        +
        6734 
        +
        6735  VkDeviceSize m_BytesMoved;
        +
        6736  uint32_t m_AllocationsMoved;
        +
        6737 
        +
        6738  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> > m_BlockInfos;
        +
        6739 
        +
        6740  void PreprocessMetadata();
        +
        6741  void PostprocessMetadata();
        +
        6742  void InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc);
        +
        6743 };
        6744 
        -
        6745  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        -
        6746  void AddAll() { m_AllAllocations = true; }
        -
        6747 
        -
        6748  void Begin(bool overlappingMoveSupported);
        -
        6749 
        -
        6750 private:
        -
        6751  const VmaAllocator m_hAllocator;
        -
        6752  // Null if not from custom pool.
        -
        6753  const VmaPool m_hCustomPool;
        -
        6754  // Redundant, for convenience not to fetch from m_hCustomPool->m_BlockVector or m_hAllocator->m_pBlockVectors.
        -
        6755  VmaBlockVector* const m_pBlockVector;
        -
        6756  const uint32_t m_CurrFrameIndex;
        -
        6757  // Owner of this object.
        -
        6758  VmaDefragmentationAlgorithm* m_pAlgorithm;
        -
        6759 
        -
        6760  struct AllocInfo
        -
        6761  {
        -
        6762  VmaAllocation hAlloc;
        -
        6763  VkBool32* pChanged;
        -
        6764  };
        -
        6765  // Used between constructor and Begin.
        -
        6766  VmaVector< AllocInfo, VmaStlAllocator<AllocInfo> > m_Allocations;
        -
        6767  bool m_AllAllocations;
        -
        6768 };
        +
        6745 struct VmaBlockDefragmentationContext
        +
        6746 {
        +
        6747  enum BLOCK_FLAG
        +
        6748  {
        +
        6749  BLOCK_FLAG_USED = 0x00000001,
        +
        6750  };
        +
        6751  uint32_t flags;
        +
        6752  VkBuffer hBuffer;
        +
        6753 };
        +
        6754 
        +
        6755 class VmaBlockVectorDefragmentationContext
        +
        6756 {
        +
        6757  VMA_CLASS_NO_COPY(VmaBlockVectorDefragmentationContext)
        +
        6758 public:
        +
        6759  VkResult res;
        +
        6760  bool mutexLocked;
        +
        6761  VmaVector< VmaBlockDefragmentationContext, VmaStlAllocator<VmaBlockDefragmentationContext> > blockContexts;
        +
        6762 
        +
        6763  VmaBlockVectorDefragmentationContext(
        +
        6764  VmaAllocator hAllocator,
        +
        6765  VmaPool hCustomPool, // Optional.
        +
        6766  VmaBlockVector* pBlockVector,
        +
        6767  uint32_t currFrameIndex);
        +
        6768  ~VmaBlockVectorDefragmentationContext();
        6769 
        -
        6770 struct VmaDefragmentationContext_T
        -
        6771 {
        -
        6772 private:
        -
        6773  VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)
        -
        6774 public:
        -
        6775  VmaDefragmentationContext_T(
        -
        6776  VmaAllocator hAllocator,
        -
        6777  uint32_t currFrameIndex,
        -
        6778  uint32_t flags,
        -
        6779  VmaDefragmentationStats* pStats);
        -
        6780  ~VmaDefragmentationContext_T();
        -
        6781 
        -
        6782  void AddPools(uint32_t poolCount, VmaPool* pPools);
        -
        6783  void AddAllocations(
        -
        6784  uint32_t allocationCount,
        -
        6785  VmaAllocation* pAllocations,
        -
        6786  VkBool32* pAllocationsChanged);
        -
        6787 
        -
        6788  /*
        -
        6789  Returns:
        -
        6790  - `VK_SUCCESS` if succeeded and object can be destroyed immediately.
        -
        6791  - `VK_NOT_READY` if succeeded but the object must remain alive until vmaDefragmentationEnd().
        -
        6792  - Negative value if error occured and object can be destroyed immediately.
        -
        6793  */
        -
        6794  VkResult Defragment(
        -
        6795  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
        -
        6796  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
        -
        6797  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats);
        +
        6770  VmaPool GetCustomPool() const { return m_hCustomPool; }
        +
        6771  VmaBlockVector* GetBlockVector() const { return m_pBlockVector; }
        +
        6772  VmaDefragmentationAlgorithm* GetAlgorithm() const { return m_pAlgorithm; }
        +
        6773 
        +
        6774  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        +
        6775  void AddAll() { m_AllAllocations = true; }
        +
        6776 
        +
        6777  void Begin(bool overlappingMoveSupported);
        +
        6778 
        +
        6779 private:
        +
        6780  const VmaAllocator m_hAllocator;
        +
        6781  // Null if not from custom pool.
        +
        6782  const VmaPool m_hCustomPool;
        +
        6783  // Redundant, for convenience not to fetch from m_hCustomPool->m_BlockVector or m_hAllocator->m_pBlockVectors.
        +
        6784  VmaBlockVector* const m_pBlockVector;
        +
        6785  const uint32_t m_CurrFrameIndex;
        +
        6786  // Owner of this object.
        +
        6787  VmaDefragmentationAlgorithm* m_pAlgorithm;
        +
        6788 
        +
        6789  struct AllocInfo
        +
        6790  {
        +
        6791  VmaAllocation hAlloc;
        +
        6792  VkBool32* pChanged;
        +
        6793  };
        +
        6794  // Used between constructor and Begin.
        +
        6795  VmaVector< AllocInfo, VmaStlAllocator<AllocInfo> > m_Allocations;
        +
        6796  bool m_AllAllocations;
        +
        6797 };
        6798 
        -
        6799 private:
        -
        6800  const VmaAllocator m_hAllocator;
        -
        6801  const uint32_t m_CurrFrameIndex;
        -
        6802  const uint32_t m_Flags;
        -
        6803  VmaDefragmentationStats* const m_pStats;
        -
        6804  // Owner of these objects.
        -
        6805  VmaBlockVectorDefragmentationContext* m_DefaultPoolContexts[VK_MAX_MEMORY_TYPES];
        -
        6806  // Owner of these objects.
        -
        6807  VmaVector< VmaBlockVectorDefragmentationContext*, VmaStlAllocator<VmaBlockVectorDefragmentationContext*> > m_CustomPoolContexts;
        -
        6808 };
        -
        6809 
        -
        6810 #if VMA_RECORDING_ENABLED
        -
        6811 
        -
        6812 class VmaRecorder
        -
        6813 {
        -
        6814 public:
        -
        6815  VmaRecorder();
        -
        6816  VkResult Init(const VmaRecordSettings& settings, bool useMutex);
        -
        6817  void WriteConfiguration(
        -
        6818  const VkPhysicalDeviceProperties& devProps,
        -
        6819  const VkPhysicalDeviceMemoryProperties& memProps,
        -
        6820  bool dedicatedAllocationExtensionEnabled,
        -
        6821  bool bindMemory2ExtensionEnabled,
        -
        6822  bool memoryBudgetExtensionEnabled);
        -
        6823  ~VmaRecorder();
        -
        6824 
        -
        6825  void RecordCreateAllocator(uint32_t frameIndex);
        -
        6826  void RecordDestroyAllocator(uint32_t frameIndex);
        -
        6827  void RecordCreatePool(uint32_t frameIndex,
        -
        6828  const VmaPoolCreateInfo& createInfo,
        -
        6829  VmaPool pool);
        -
        6830  void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
        -
        6831  void RecordAllocateMemory(uint32_t frameIndex,
        -
        6832  const VkMemoryRequirements& vkMemReq,
        -
        6833  const VmaAllocationCreateInfo& createInfo,
        -
        6834  VmaAllocation allocation);
        -
        6835  void RecordAllocateMemoryPages(uint32_t frameIndex,
        -
        6836  const VkMemoryRequirements& vkMemReq,
        -
        6837  const VmaAllocationCreateInfo& createInfo,
        -
        6838  uint64_t allocationCount,
        -
        6839  const VmaAllocation* pAllocations);
        -
        6840  void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        -
        6841  const VkMemoryRequirements& vkMemReq,
        -
        6842  bool requiresDedicatedAllocation,
        -
        6843  bool prefersDedicatedAllocation,
        -
        6844  const VmaAllocationCreateInfo& createInfo,
        -
        6845  VmaAllocation allocation);
        -
        6846  void RecordAllocateMemoryForImage(uint32_t frameIndex,
        -
        6847  const VkMemoryRequirements& vkMemReq,
        -
        6848  bool requiresDedicatedAllocation,
        -
        6849  bool prefersDedicatedAllocation,
        -
        6850  const VmaAllocationCreateInfo& createInfo,
        -
        6851  VmaAllocation allocation);
        -
        6852  void RecordFreeMemory(uint32_t frameIndex,
        -
        6853  VmaAllocation allocation);
        -
        6854  void RecordFreeMemoryPages(uint32_t frameIndex,
        -
        6855  uint64_t allocationCount,
        -
        6856  const VmaAllocation* pAllocations);
        -
        6857  void RecordSetAllocationUserData(uint32_t frameIndex,
        -
        6858  VmaAllocation allocation,
        -
        6859  const void* pUserData);
        -
        6860  void RecordCreateLostAllocation(uint32_t frameIndex,
        -
        6861  VmaAllocation allocation);
        -
        6862  void RecordMapMemory(uint32_t frameIndex,
        -
        6863  VmaAllocation allocation);
        -
        6864  void RecordUnmapMemory(uint32_t frameIndex,
        -
        6865  VmaAllocation allocation);
        -
        6866  void RecordFlushAllocation(uint32_t frameIndex,
        -
        6867  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        -
        6868  void RecordInvalidateAllocation(uint32_t frameIndex,
        -
        6869  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        -
        6870  void RecordCreateBuffer(uint32_t frameIndex,
        -
        6871  const VkBufferCreateInfo& bufCreateInfo,
        -
        6872  const VmaAllocationCreateInfo& allocCreateInfo,
        -
        6873  VmaAllocation allocation);
        -
        6874  void RecordCreateImage(uint32_t frameIndex,
        -
        6875  const VkImageCreateInfo& imageCreateInfo,
        -
        6876  const VmaAllocationCreateInfo& allocCreateInfo,
        -
        6877  VmaAllocation allocation);
        -
        6878  void RecordDestroyBuffer(uint32_t frameIndex,
        -
        6879  VmaAllocation allocation);
        -
        6880  void RecordDestroyImage(uint32_t frameIndex,
        +
        6799 struct VmaDefragmentationContext_T
        +
        6800 {
        +
        6801 private:
        +
        6802  VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)
        +
        6803 public:
        +
        6804  VmaDefragmentationContext_T(
        +
        6805  VmaAllocator hAllocator,
        +
        6806  uint32_t currFrameIndex,
        +
        6807  uint32_t flags,
        +
        6808  VmaDefragmentationStats* pStats);
        +
        6809  ~VmaDefragmentationContext_T();
        +
        6810 
        +
        6811  void AddPools(uint32_t poolCount, VmaPool* pPools);
        +
        6812  void AddAllocations(
        +
        6813  uint32_t allocationCount,
        +
        6814  VmaAllocation* pAllocations,
        +
        6815  VkBool32* pAllocationsChanged);
        +
        6816 
        +
        6817  /*
        +
        6818  Returns:
        +
        6819  - `VK_SUCCESS` if succeeded and object can be destroyed immediately.
        +
        6820  - `VK_NOT_READY` if succeeded but the object must remain alive until vmaDefragmentationEnd().
        +
        6821  - Negative value if error occured and object can be destroyed immediately.
        +
        6822  */
        +
        6823  VkResult Defragment(
        +
        6824  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
        +
        6825  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
        +
        6826  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats);
        +
        6827 
        +
        6828 private:
        +
        6829  const VmaAllocator m_hAllocator;
        +
        6830  const uint32_t m_CurrFrameIndex;
        +
        6831  const uint32_t m_Flags;
        +
        6832  VmaDefragmentationStats* const m_pStats;
        +
        6833  // Owner of these objects.
        +
        6834  VmaBlockVectorDefragmentationContext* m_DefaultPoolContexts[VK_MAX_MEMORY_TYPES];
        +
        6835  // Owner of these objects.
        +
        6836  VmaVector< VmaBlockVectorDefragmentationContext*, VmaStlAllocator<VmaBlockVectorDefragmentationContext*> > m_CustomPoolContexts;
        +
        6837 };
        +
        6838 
        +
        6839 #if VMA_RECORDING_ENABLED
        +
        6840 
        +
        6841 class VmaRecorder
        +
        6842 {
        +
        6843 public:
        +
        6844  VmaRecorder();
        +
        6845  VkResult Init(const VmaRecordSettings& settings, bool useMutex);
        +
        6846  void WriteConfiguration(
        +
        6847  const VkPhysicalDeviceProperties& devProps,
        +
        6848  const VkPhysicalDeviceMemoryProperties& memProps,
        +
        6849  uint32_t vulkanApiVersion,
        +
        6850  bool dedicatedAllocationExtensionEnabled,
        +
        6851  bool bindMemory2ExtensionEnabled,
        +
        6852  bool memoryBudgetExtensionEnabled);
        +
        6853  ~VmaRecorder();
        +
        6854 
        +
        6855  void RecordCreateAllocator(uint32_t frameIndex);
        +
        6856  void RecordDestroyAllocator(uint32_t frameIndex);
        +
        6857  void RecordCreatePool(uint32_t frameIndex,
        +
        6858  const VmaPoolCreateInfo& createInfo,
        +
        6859  VmaPool pool);
        +
        6860  void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
        +
        6861  void RecordAllocateMemory(uint32_t frameIndex,
        +
        6862  const VkMemoryRequirements& vkMemReq,
        +
        6863  const VmaAllocationCreateInfo& createInfo,
        +
        6864  VmaAllocation allocation);
        +
        6865  void RecordAllocateMemoryPages(uint32_t frameIndex,
        +
        6866  const VkMemoryRequirements& vkMemReq,
        +
        6867  const VmaAllocationCreateInfo& createInfo,
        +
        6868  uint64_t allocationCount,
        +
        6869  const VmaAllocation* pAllocations);
        +
        6870  void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        +
        6871  const VkMemoryRequirements& vkMemReq,
        +
        6872  bool requiresDedicatedAllocation,
        +
        6873  bool prefersDedicatedAllocation,
        +
        6874  const VmaAllocationCreateInfo& createInfo,
        +
        6875  VmaAllocation allocation);
        +
        6876  void RecordAllocateMemoryForImage(uint32_t frameIndex,
        +
        6877  const VkMemoryRequirements& vkMemReq,
        +
        6878  bool requiresDedicatedAllocation,
        +
        6879  bool prefersDedicatedAllocation,
        +
        6880  const VmaAllocationCreateInfo& createInfo,
        6881  VmaAllocation allocation);
        -
        6882  void RecordTouchAllocation(uint32_t frameIndex,
        +
        6882  void RecordFreeMemory(uint32_t frameIndex,
        6883  VmaAllocation allocation);
        -
        6884  void RecordGetAllocationInfo(uint32_t frameIndex,
        -
        6885  VmaAllocation allocation);
        -
        6886  void RecordMakePoolAllocationsLost(uint32_t frameIndex,
        -
        6887  VmaPool pool);
        -
        6888  void RecordDefragmentationBegin(uint32_t frameIndex,
        -
        6889  const VmaDefragmentationInfo2& info,
        -
        6890  VmaDefragmentationContext ctx);
        -
        6891  void RecordDefragmentationEnd(uint32_t frameIndex,
        -
        6892  VmaDefragmentationContext ctx);
        -
        6893  void RecordSetPoolName(uint32_t frameIndex,
        -
        6894  VmaPool pool,
        -
        6895  const char* name);
        -
        6896 
        -
        6897 private:
        -
        6898  struct CallParams
        -
        6899  {
        -
        6900  uint32_t threadId;
        -
        6901  double time;
        -
        6902  };
        -
        6903 
        -
        6904  class UserDataString
        -
        6905  {
        -
        6906  public:
        -
        6907  UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
        -
        6908  const char* GetString() const { return m_Str; }
        -
        6909 
        -
        6910  private:
        -
        6911  char m_PtrStr[17];
        -
        6912  const char* m_Str;
        -
        6913  };
        -
        6914 
        -
        6915  bool m_UseMutex;
        -
        6916  VmaRecordFlags m_Flags;
        -
        6917  FILE* m_File;
        -
        6918  VMA_MUTEX m_FileMutex;
        -
        6919  int64_t m_Freq;
        -
        6920  int64_t m_StartCounter;
        -
        6921 
        -
        6922  void GetBasicParams(CallParams& outParams);
        -
        6923 
        -
        6924  // T must be a pointer type, e.g. VmaAllocation, VmaPool.
        -
        6925  template<typename T>
        -
        6926  void PrintPointerList(uint64_t count, const T* pItems)
        -
        6927  {
        -
        6928  if(count)
        -
        6929  {
        -
        6930  fprintf(m_File, "%p", pItems[0]);
        -
        6931  for(uint64_t i = 1; i < count; ++i)
        -
        6932  {
        -
        6933  fprintf(m_File, " %p", pItems[i]);
        -
        6934  }
        -
        6935  }
        -
        6936  }
        -
        6937 
        -
        6938  void PrintPointerList(uint64_t count, const VmaAllocation* pItems);
        -
        6939  void Flush();
        -
        6940 };
        -
        6941 
        -
        6942 #endif // #if VMA_RECORDING_ENABLED
        -
        6943 
        -
        6944 /*
        -
        6945 Thread-safe wrapper over VmaPoolAllocator free list, for allocation of VmaAllocation_T objects.
        -
        6946 */
        -
        6947 class VmaAllocationObjectAllocator
        -
        6948 {
        -
        6949  VMA_CLASS_NO_COPY(VmaAllocationObjectAllocator)
        -
        6950 public:
        -
        6951  VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks);
        -
        6952 
        -
        6953  VmaAllocation Allocate();
        -
        6954  void Free(VmaAllocation hAlloc);
        -
        6955 
        -
        6956 private:
        -
        6957  VMA_MUTEX m_Mutex;
        -
        6958  VmaPoolAllocator<VmaAllocation_T> m_Allocator;
        -
        6959 };
        -
        6960 
        -
        6961 struct VmaCurrentBudgetData
        -
        6962 {
        -
        6963  VMA_ATOMIC_UINT64 m_BlockBytes[VK_MAX_MEMORY_HEAPS];
        -
        6964  VMA_ATOMIC_UINT64 m_AllocationBytes[VK_MAX_MEMORY_HEAPS];
        -
        6965 
        -
        6966 #if VMA_MEMORY_BUDGET
        -
        6967  VMA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch;
        -
        6968  VMA_RW_MUTEX m_BudgetMutex;
        -
        6969  uint64_t m_VulkanUsage[VK_MAX_MEMORY_HEAPS];
        -
        6970  uint64_t m_VulkanBudget[VK_MAX_MEMORY_HEAPS];
        -
        6971  uint64_t m_BlockBytesAtBudgetFetch[VK_MAX_MEMORY_HEAPS];
        -
        6972 #endif // #if VMA_MEMORY_BUDGET
        +
        6884  void RecordFreeMemoryPages(uint32_t frameIndex,
        +
        6885  uint64_t allocationCount,
        +
        6886  const VmaAllocation* pAllocations);
        +
        6887  void RecordSetAllocationUserData(uint32_t frameIndex,
        +
        6888  VmaAllocation allocation,
        +
        6889  const void* pUserData);
        +
        6890  void RecordCreateLostAllocation(uint32_t frameIndex,
        +
        6891  VmaAllocation allocation);
        +
        6892  void RecordMapMemory(uint32_t frameIndex,
        +
        6893  VmaAllocation allocation);
        +
        6894  void RecordUnmapMemory(uint32_t frameIndex,
        +
        6895  VmaAllocation allocation);
        +
        6896  void RecordFlushAllocation(uint32_t frameIndex,
        +
        6897  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        +
        6898  void RecordInvalidateAllocation(uint32_t frameIndex,
        +
        6899  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        +
        6900  void RecordCreateBuffer(uint32_t frameIndex,
        +
        6901  const VkBufferCreateInfo& bufCreateInfo,
        +
        6902  const VmaAllocationCreateInfo& allocCreateInfo,
        +
        6903  VmaAllocation allocation);
        +
        6904  void RecordCreateImage(uint32_t frameIndex,
        +
        6905  const VkImageCreateInfo& imageCreateInfo,
        +
        6906  const VmaAllocationCreateInfo& allocCreateInfo,
        +
        6907  VmaAllocation allocation);
        +
        6908  void RecordDestroyBuffer(uint32_t frameIndex,
        +
        6909  VmaAllocation allocation);
        +
        6910  void RecordDestroyImage(uint32_t frameIndex,
        +
        6911  VmaAllocation allocation);
        +
        6912  void RecordTouchAllocation(uint32_t frameIndex,
        +
        6913  VmaAllocation allocation);
        +
        6914  void RecordGetAllocationInfo(uint32_t frameIndex,
        +
        6915  VmaAllocation allocation);
        +
        6916  void RecordMakePoolAllocationsLost(uint32_t frameIndex,
        +
        6917  VmaPool pool);
        +
        6918  void RecordDefragmentationBegin(uint32_t frameIndex,
        +
        6919  const VmaDefragmentationInfo2& info,
        +
        6920  VmaDefragmentationContext ctx);
        +
        6921  void RecordDefragmentationEnd(uint32_t frameIndex,
        +
        6922  VmaDefragmentationContext ctx);
        +
        6923  void RecordSetPoolName(uint32_t frameIndex,
        +
        6924  VmaPool pool,
        +
        6925  const char* name);
        +
        6926 
        +
        6927 private:
        +
        6928  struct CallParams
        +
        6929  {
        +
        6930  uint32_t threadId;
        +
        6931  double time;
        +
        6932  };
        +
        6933 
        +
        6934  class UserDataString
        +
        6935  {
        +
        6936  public:
        +
        6937  UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
        +
        6938  const char* GetString() const { return m_Str; }
        +
        6939 
        +
        6940  private:
        +
        6941  char m_PtrStr[17];
        +
        6942  const char* m_Str;
        +
        6943  };
        +
        6944 
        +
        6945  bool m_UseMutex;
        +
        6946  VmaRecordFlags m_Flags;
        +
        6947  FILE* m_File;
        +
        6948  VMA_MUTEX m_FileMutex;
        +
        6949  int64_t m_Freq;
        +
        6950  int64_t m_StartCounter;
        +
        6951 
        +
        6952  void GetBasicParams(CallParams& outParams);
        +
        6953 
        +
        6954  // T must be a pointer type, e.g. VmaAllocation, VmaPool.
        +
        6955  template<typename T>
        +
        6956  void PrintPointerList(uint64_t count, const T* pItems)
        +
        6957  {
        +
        6958  if(count)
        +
        6959  {
        +
        6960  fprintf(m_File, "%p", pItems[0]);
        +
        6961  for(uint64_t i = 1; i < count; ++i)
        +
        6962  {
        +
        6963  fprintf(m_File, " %p", pItems[i]);
        +
        6964  }
        +
        6965  }
        +
        6966  }
        +
        6967 
        +
        6968  void PrintPointerList(uint64_t count, const VmaAllocation* pItems);
        +
        6969  void Flush();
        +
        6970 };
        +
        6971 
        +
        6972 #endif // #if VMA_RECORDING_ENABLED
        6973 
        -
        6974  VmaCurrentBudgetData()
        -
        6975  {
        -
        6976  for(uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)
        -
        6977  {
        -
        6978  m_BlockBytes[heapIndex] = 0;
        -
        6979  m_AllocationBytes[heapIndex] = 0;
        -
        6980 #if VMA_MEMORY_BUDGET
        -
        6981  m_VulkanUsage[heapIndex] = 0;
        -
        6982  m_VulkanBudget[heapIndex] = 0;
        -
        6983  m_BlockBytesAtBudgetFetch[heapIndex] = 0;
        -
        6984 #endif
        -
        6985  }
        -
        6986 
        -
        6987 #if VMA_MEMORY_BUDGET
        -
        6988  m_OperationsSinceBudgetFetch = 0;
        -
        6989 #endif
        -
        6990  }
        -
        6991 
        -
        6992  void AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
        -
        6993  {
        -
        6994  m_AllocationBytes[heapIndex] += allocationSize;
        -
        6995 #if VMA_MEMORY_BUDGET
        -
        6996  ++m_OperationsSinceBudgetFetch;
        -
        6997 #endif
        -
        6998  }
        -
        6999 
        -
        7000  void RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
        -
        7001  {
        -
        7002  VMA_ASSERT(m_AllocationBytes[heapIndex] >= allocationSize); // DELME
        -
        7003  m_AllocationBytes[heapIndex] -= allocationSize;
        -
        7004 #if VMA_MEMORY_BUDGET
        -
        7005  ++m_OperationsSinceBudgetFetch;
        -
        7006 #endif
        -
        7007  }
        -
        7008 };
        -
        7009 
        -
        7010 // Main allocator object.
        -
        7011 struct VmaAllocator_T
        -
        7012 {
        -
        7013  VMA_CLASS_NO_COPY(VmaAllocator_T)
        -
        7014 public:
        -
        7015  bool m_UseMutex;
        -
        7016  bool m_UseKhrDedicatedAllocation;
        -
        7017  bool m_UseKhrBindMemory2;
        -
        7018  bool m_UseExtMemoryBudget;
        -
        7019  VkDevice m_hDevice;
        -
        7020  VkInstance m_hInstance;
        -
        7021  bool m_AllocationCallbacksSpecified;
        -
        7022  VkAllocationCallbacks m_AllocationCallbacks;
        -
        7023  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
        -
        7024  VmaAllocationObjectAllocator m_AllocationObjectAllocator;
        -
        7025 
        -
        7026  // Each bit (1 << i) is set if HeapSizeLimit is enabled for that heap, so cannot allocate more than the heap size.
        -
        7027  uint32_t m_HeapSizeLimitMask;
        -
        7028 
        -
        7029  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
        -
        7030  VkPhysicalDeviceMemoryProperties m_MemProps;
        -
        7031 
        -
        7032  // Default pools.
        -
        7033  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
        -
        7034 
        -
        7035  // Each vector is sorted by memory (handle value).
        -
        7036  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
        -
        7037  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
        -
        7038  VMA_RW_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
        +
        6974 /*
        +
        6975 Thread-safe wrapper over VmaPoolAllocator free list, for allocation of VmaAllocation_T objects.
        +
        6976 */
        +
        6977 class VmaAllocationObjectAllocator
        +
        6978 {
        +
        6979  VMA_CLASS_NO_COPY(VmaAllocationObjectAllocator)
        +
        6980 public:
        +
        6981  VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks);
        +
        6982 
        +
        6983  VmaAllocation Allocate();
        +
        6984  void Free(VmaAllocation hAlloc);
        +
        6985 
        +
        6986 private:
        +
        6987  VMA_MUTEX m_Mutex;
        +
        6988  VmaPoolAllocator<VmaAllocation_T> m_Allocator;
        +
        6989 };
        +
        6990 
        +
        6991 struct VmaCurrentBudgetData
        +
        6992 {
        +
        6993  VMA_ATOMIC_UINT64 m_BlockBytes[VK_MAX_MEMORY_HEAPS];
        +
        6994  VMA_ATOMIC_UINT64 m_AllocationBytes[VK_MAX_MEMORY_HEAPS];
        +
        6995 
        +
        6996 #if VMA_MEMORY_BUDGET
        +
        6997  VMA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch;
        +
        6998  VMA_RW_MUTEX m_BudgetMutex;
        +
        6999  uint64_t m_VulkanUsage[VK_MAX_MEMORY_HEAPS];
        +
        7000  uint64_t m_VulkanBudget[VK_MAX_MEMORY_HEAPS];
        +
        7001  uint64_t m_BlockBytesAtBudgetFetch[VK_MAX_MEMORY_HEAPS];
        +
        7002 #endif // #if VMA_MEMORY_BUDGET
        +
        7003 
        +
        7004  VmaCurrentBudgetData()
        +
        7005  {
        +
        7006  for(uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)
        +
        7007  {
        +
        7008  m_BlockBytes[heapIndex] = 0;
        +
        7009  m_AllocationBytes[heapIndex] = 0;
        +
        7010 #if VMA_MEMORY_BUDGET
        +
        7011  m_VulkanUsage[heapIndex] = 0;
        +
        7012  m_VulkanBudget[heapIndex] = 0;
        +
        7013  m_BlockBytesAtBudgetFetch[heapIndex] = 0;
        +
        7014 #endif
        +
        7015  }
        +
        7016 
        +
        7017 #if VMA_MEMORY_BUDGET
        +
        7018  m_OperationsSinceBudgetFetch = 0;
        +
        7019 #endif
        +
        7020  }
        +
        7021 
        +
        7022  void AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
        +
        7023  {
        +
        7024  m_AllocationBytes[heapIndex] += allocationSize;
        +
        7025 #if VMA_MEMORY_BUDGET
        +
        7026  ++m_OperationsSinceBudgetFetch;
        +
        7027 #endif
        +
        7028  }
        +
        7029 
        +
        7030  void RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
        +
        7031  {
        +
        7032  VMA_ASSERT(m_AllocationBytes[heapIndex] >= allocationSize); // DELME
        +
        7033  m_AllocationBytes[heapIndex] -= allocationSize;
        +
        7034 #if VMA_MEMORY_BUDGET
        +
        7035  ++m_OperationsSinceBudgetFetch;
        +
        7036 #endif
        +
        7037  }
        +
        7038 };
        7039 
        -
        7040  VmaCurrentBudgetData m_Budget;
        -
        7041 
        -
        7042  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
        -
        7043  VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
        -
        7044  ~VmaAllocator_T();
        -
        7045 
        -
        7046  const VkAllocationCallbacks* GetAllocationCallbacks() const
        -
        7047  {
        -
        7048  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
        -
        7049  }
        -
        7050  const VmaVulkanFunctions& GetVulkanFunctions() const
        -
        7051  {
        -
        7052  return m_VulkanFunctions;
        -
        7053  }
        -
        7054 
        -
        7055  VkDeviceSize GetBufferImageGranularity() const
        -
        7056  {
        -
        7057  return VMA_MAX(
        -
        7058  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
        -
        7059  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
        -
        7060  }
        -
        7061 
        -
        7062  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
        -
        7063  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
        -
        7064 
        -
        7065  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
        -
        7066  {
        -
        7067  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
        -
        7068  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        -
        7069  }
        -
        7070  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
        -
        7071  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
        -
        7072  {
        -
        7073  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
        -
        7074  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        -
        7075  }
        -
        7076  // Minimum alignment for all allocations in specific memory type.
        -
        7077  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
        +
        7040 // Main allocator object.
        +
        7041 struct VmaAllocator_T
        +
        7042 {
        +
        7043  VMA_CLASS_NO_COPY(VmaAllocator_T)
        +
        7044 public:
        +
        7045  bool m_UseMutex;
        +
        7046  uint32_t m_VulkanApiVersion;
        +
        7047  bool m_UseKhrDedicatedAllocation; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
        +
        7048  bool m_UseKhrBindMemory2; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
        +
        7049  bool m_UseExtMemoryBudget;
        +
        7050  VkDevice m_hDevice;
        +
        7051  VkInstance m_hInstance;
        +
        7052  bool m_AllocationCallbacksSpecified;
        +
        7053  VkAllocationCallbacks m_AllocationCallbacks;
        +
        7054  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
        +
        7055  VmaAllocationObjectAllocator m_AllocationObjectAllocator;
        +
        7056 
        +
        7057  // Each bit (1 << i) is set if HeapSizeLimit is enabled for that heap, so cannot allocate more than the heap size.
        +
        7058  uint32_t m_HeapSizeLimitMask;
        +
        7059 
        +
        7060  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
        +
        7061  VkPhysicalDeviceMemoryProperties m_MemProps;
        +
        7062 
        +
        7063  // Default pools.
        +
        7064  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
        +
        7065 
        +
        7066  // Each vector is sorted by memory (handle value).
        +
        7067  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
        +
        7068  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
        +
        7069  VMA_RW_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
        +
        7070 
        +
        7071  VmaCurrentBudgetData m_Budget;
        +
        7072 
        +
        7073  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
        +
        7074  VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
        +
        7075  ~VmaAllocator_T();
        +
        7076 
        +
        7077  const VkAllocationCallbacks* GetAllocationCallbacks() const
        7078  {
        -
        7079  return IsMemoryTypeNonCoherent(memTypeIndex) ?
        -
        7080  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
        -
        7081  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
        -
        7082  }
        -
        7083 
        -
        7084  bool IsIntegratedGpu() const
        -
        7085  {
        -
        7086  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
        -
        7087  }
        -
        7088 
        -
        7089 #if VMA_RECORDING_ENABLED
        -
        7090  VmaRecorder* GetRecorder() const { return m_pRecorder; }
        -
        7091 #endif
        +
        7079  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
        +
        7080  }
        +
        7081  const VmaVulkanFunctions& GetVulkanFunctions() const
        +
        7082  {
        +
        7083  return m_VulkanFunctions;
        +
        7084  }
        +
        7085 
        +
        7086  VkDeviceSize GetBufferImageGranularity() const
        +
        7087  {
        +
        7088  return VMA_MAX(
        +
        7089  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
        +
        7090  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
        +
        7091  }
        7092 
        -
        7093  void GetBufferMemoryRequirements(
        -
        7094  VkBuffer hBuffer,
        -
        7095  VkMemoryRequirements& memReq,
        -
        7096  bool& requiresDedicatedAllocation,
        -
        7097  bool& prefersDedicatedAllocation) const;
        -
        7098  void GetImageMemoryRequirements(
        -
        7099  VkImage hImage,
        -
        7100  VkMemoryRequirements& memReq,
        -
        7101  bool& requiresDedicatedAllocation,
        -
        7102  bool& prefersDedicatedAllocation) const;
        -
        7103 
        -
        7104  // Main allocation function.
        -
        7105  VkResult AllocateMemory(
        -
        7106  const VkMemoryRequirements& vkMemReq,
        -
        7107  bool requiresDedicatedAllocation,
        -
        7108  bool prefersDedicatedAllocation,
        -
        7109  VkBuffer dedicatedBuffer,
        -
        7110  VkImage dedicatedImage,
        -
        7111  const VmaAllocationCreateInfo& createInfo,
        -
        7112  VmaSuballocationType suballocType,
        -
        7113  size_t allocationCount,
        -
        7114  VmaAllocation* pAllocations);
        -
        7115 
        -
        7116  // Main deallocation function.
        -
        7117  void FreeMemory(
        -
        7118  size_t allocationCount,
        -
        7119  const VmaAllocation* pAllocations);
        -
        7120 
        -
        7121  VkResult ResizeAllocation(
        -
        7122  const VmaAllocation alloc,
        -
        7123  VkDeviceSize newSize);
        -
        7124 
        -
        7125  void CalculateStats(VmaStats* pStats);
        -
        7126 
        -
        7127  void GetBudget(
        -
        7128  VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount);
        -
        7129 
        -
        7130 #if VMA_STATS_STRING_ENABLED
        -
        7131  void PrintDetailedMap(class VmaJsonWriter& json);
        -
        7132 #endif
        -
        7133 
        -
        7134  VkResult DefragmentationBegin(
        -
        7135  const VmaDefragmentationInfo2& info,
        -
        7136  VmaDefragmentationStats* pStats,
        -
        7137  VmaDefragmentationContext* pContext);
        -
        7138  VkResult DefragmentationEnd(
        -
        7139  VmaDefragmentationContext context);
        -
        7140 
        -
        7141  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
        -
        7142  bool TouchAllocation(VmaAllocation hAllocation);
        -
        7143 
        -
        7144  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
        -
        7145  void DestroyPool(VmaPool pool);
        -
        7146  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
        -
        7147 
        -
        7148  void SetCurrentFrameIndex(uint32_t frameIndex);
        -
        7149  uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
        -
        7150 
        -
        7151  void MakePoolAllocationsLost(
        -
        7152  VmaPool hPool,
        -
        7153  size_t* pLostAllocationCount);
        -
        7154  VkResult CheckPoolCorruption(VmaPool hPool);
        -
        7155  VkResult CheckCorruption(uint32_t memoryTypeBits);
        -
        7156 
        -
        7157  void CreateLostAllocation(VmaAllocation* pAllocation);
        -
        7158 
        -
        7159  // Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
        -
        7160  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
        -
        7161  // Call to Vulkan function vkFreeMemory with accompanying bookkeeping.
        -
        7162  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
        -
        7163  // Call to Vulkan function vkBindBufferMemory or vkBindBufferMemory2KHR.
        -
        7164  VkResult BindVulkanBuffer(
        -
        7165  VkDeviceMemory memory,
        -
        7166  VkDeviceSize memoryOffset,
        -
        7167  VkBuffer buffer,
        -
        7168  const void* pNext);
        -
        7169  // Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
        -
        7170  VkResult BindVulkanImage(
        -
        7171  VkDeviceMemory memory,
        -
        7172  VkDeviceSize memoryOffset,
        -
        7173  VkImage image,
        -
        7174  const void* pNext);
        -
        7175 
        -
        7176  VkResult Map(VmaAllocation hAllocation, void** ppData);
        -
        7177  void Unmap(VmaAllocation hAllocation);
        +
        7093  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
        +
        7094  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
        +
        7095 
        +
        7096  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
        +
        7097  {
        +
        7098  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
        +
        7099  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        +
        7100  }
        +
        7101  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
        +
        7102  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
        +
        7103  {
        +
        7104  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
        +
        7105  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        +
        7106  }
        +
        7107  // Minimum alignment for all allocations in specific memory type.
        +
        7108  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
        +
        7109  {
        +
        7110  return IsMemoryTypeNonCoherent(memTypeIndex) ?
        +
        7111  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
        +
        7112  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
        +
        7113  }
        +
        7114 
        +
        7115  bool IsIntegratedGpu() const
        +
        7116  {
        +
        7117  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
        +
        7118  }
        +
        7119 
        +
        7120 #if VMA_RECORDING_ENABLED
        +
        7121  VmaRecorder* GetRecorder() const { return m_pRecorder; }
        +
        7122 #endif
        +
        7123 
        +
        7124  void GetBufferMemoryRequirements(
        +
        7125  VkBuffer hBuffer,
        +
        7126  VkMemoryRequirements& memReq,
        +
        7127  bool& requiresDedicatedAllocation,
        +
        7128  bool& prefersDedicatedAllocation) const;
        +
        7129  void GetImageMemoryRequirements(
        +
        7130  VkImage hImage,
        +
        7131  VkMemoryRequirements& memReq,
        +
        7132  bool& requiresDedicatedAllocation,
        +
        7133  bool& prefersDedicatedAllocation) const;
        +
        7134 
        +
        7135  // Main allocation function.
        +
        7136  VkResult AllocateMemory(
        +
        7137  const VkMemoryRequirements& vkMemReq,
        +
        7138  bool requiresDedicatedAllocation,
        +
        7139  bool prefersDedicatedAllocation,
        +
        7140  VkBuffer dedicatedBuffer,
        +
        7141  VkImage dedicatedImage,
        +
        7142  const VmaAllocationCreateInfo& createInfo,
        +
        7143  VmaSuballocationType suballocType,
        +
        7144  size_t allocationCount,
        +
        7145  VmaAllocation* pAllocations);
        +
        7146 
        +
        7147  // Main deallocation function.
        +
        7148  void FreeMemory(
        +
        7149  size_t allocationCount,
        +
        7150  const VmaAllocation* pAllocations);
        +
        7151 
        +
        7152  VkResult ResizeAllocation(
        +
        7153  const VmaAllocation alloc,
        +
        7154  VkDeviceSize newSize);
        +
        7155 
        +
        7156  void CalculateStats(VmaStats* pStats);
        +
        7157 
        +
        7158  void GetBudget(
        +
        7159  VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount);
        +
        7160 
        +
        7161 #if VMA_STATS_STRING_ENABLED
        +
        7162  void PrintDetailedMap(class VmaJsonWriter& json);
        +
        7163 #endif
        +
        7164 
        +
        7165  VkResult DefragmentationBegin(
        +
        7166  const VmaDefragmentationInfo2& info,
        +
        7167  VmaDefragmentationStats* pStats,
        +
        7168  VmaDefragmentationContext* pContext);
        +
        7169  VkResult DefragmentationEnd(
        +
        7170  VmaDefragmentationContext context);
        +
        7171 
        +
        7172  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
        +
        7173  bool TouchAllocation(VmaAllocation hAllocation);
        +
        7174 
        +
        7175  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
        +
        7176  void DestroyPool(VmaPool pool);
        +
        7177  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
        7178 
        -
        7179  VkResult BindBufferMemory(
        -
        7180  VmaAllocation hAllocation,
        -
        7181  VkDeviceSize allocationLocalOffset,
        -
        7182  VkBuffer hBuffer,
        -
        7183  const void* pNext);
        -
        7184  VkResult BindImageMemory(
        -
        7185  VmaAllocation hAllocation,
        -
        7186  VkDeviceSize allocationLocalOffset,
        -
        7187  VkImage hImage,
        -
        7188  const void* pNext);
        +
        7179  void SetCurrentFrameIndex(uint32_t frameIndex);
        +
        7180  uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
        +
        7181 
        +
        7182  void MakePoolAllocationsLost(
        +
        7183  VmaPool hPool,
        +
        7184  size_t* pLostAllocationCount);
        +
        7185  VkResult CheckPoolCorruption(VmaPool hPool);
        +
        7186  VkResult CheckCorruption(uint32_t memoryTypeBits);
        +
        7187 
        +
        7188  void CreateLostAllocation(VmaAllocation* pAllocation);
        7189 
        -
        7190  void FlushOrInvalidateAllocation(
        -
        7191  VmaAllocation hAllocation,
        -
        7192  VkDeviceSize offset, VkDeviceSize size,
        -
        7193  VMA_CACHE_OPERATION op);
        -
        7194 
        -
        7195  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
        -
        7196 
        -
        7197  /*
        -
        7198  Returns bit mask of memory types that can support defragmentation on GPU as
        -
        7199  they support creation of required buffer for copy operations.
        -
        7200  */
        -
        7201  uint32_t GetGpuDefragmentationMemoryTypeBits();
        -
        7202 
        -
        7203 private:
        -
        7204  VkDeviceSize m_PreferredLargeHeapBlockSize;
        -
        7205 
        -
        7206  VkPhysicalDevice m_PhysicalDevice;
        -
        7207  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
        -
        7208  VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.
        -
        7209 
        -
        7210  VMA_RW_MUTEX m_PoolsMutex;
        -
        7211  // Protected by m_PoolsMutex. Sorted by pointer value.
        -
        7212  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
        -
        7213  uint32_t m_NextPoolId;
        -
        7214 
        -
        7215  VmaVulkanFunctions m_VulkanFunctions;
        -
        7216 
        -
        7217 #if VMA_RECORDING_ENABLED
        -
        7218  VmaRecorder* m_pRecorder;
        -
        7219 #endif
        +
        7190  // Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
        +
        7191  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
        +
        7192  // Call to Vulkan function vkFreeMemory with accompanying bookkeeping.
        +
        7193  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
        +
        7194  // Call to Vulkan function vkBindBufferMemory or vkBindBufferMemory2KHR.
        +
        7195  VkResult BindVulkanBuffer(
        +
        7196  VkDeviceMemory memory,
        +
        7197  VkDeviceSize memoryOffset,
        +
        7198  VkBuffer buffer,
        +
        7199  const void* pNext);
        +
        7200  // Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
        +
        7201  VkResult BindVulkanImage(
        +
        7202  VkDeviceMemory memory,
        +
        7203  VkDeviceSize memoryOffset,
        +
        7204  VkImage image,
        +
        7205  const void* pNext);
        +
        7206 
        +
        7207  VkResult Map(VmaAllocation hAllocation, void** ppData);
        +
        7208  void Unmap(VmaAllocation hAllocation);
        +
        7209 
        +
        7210  VkResult BindBufferMemory(
        +
        7211  VmaAllocation hAllocation,
        +
        7212  VkDeviceSize allocationLocalOffset,
        +
        7213  VkBuffer hBuffer,
        +
        7214  const void* pNext);
        +
        7215  VkResult BindImageMemory(
        +
        7216  VmaAllocation hAllocation,
        +
        7217  VkDeviceSize allocationLocalOffset,
        +
        7218  VkImage hImage,
        +
        7219  const void* pNext);
        7220 
        -
        7221  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
        -
        7222 
        -
        7223  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
        -
        7224 
        -
        7225  VkResult AllocateMemoryOfType(
        -
        7226  VkDeviceSize size,
        -
        7227  VkDeviceSize alignment,
        -
        7228  bool dedicatedAllocation,
        -
        7229  VkBuffer dedicatedBuffer,
        -
        7230  VkImage dedicatedImage,
        -
        7231  const VmaAllocationCreateInfo& createInfo,
        -
        7232  uint32_t memTypeIndex,
        -
        7233  VmaSuballocationType suballocType,
        -
        7234  size_t allocationCount,
        -
        7235  VmaAllocation* pAllocations);
        +
        7221  void FlushOrInvalidateAllocation(
        +
        7222  VmaAllocation hAllocation,
        +
        7223  VkDeviceSize offset, VkDeviceSize size,
        +
        7224  VMA_CACHE_OPERATION op);
        +
        7225 
        +
        7226  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
        +
        7227 
        +
        7228  /*
        +
        7229  Returns bit mask of memory types that can support defragmentation on GPU as
        +
        7230  they support creation of required buffer for copy operations.
        +
        7231  */
        +
        7232  uint32_t GetGpuDefragmentationMemoryTypeBits();
        +
        7233 
        +
        7234 private:
        +
        7235  VkDeviceSize m_PreferredLargeHeapBlockSize;
        7236 
        -
        7237  // Helper function only to be used inside AllocateDedicatedMemory.
        -
        7238  VkResult AllocateDedicatedMemoryPage(
        -
        7239  VkDeviceSize size,
        -
        7240  VmaSuballocationType suballocType,
        -
        7241  uint32_t memTypeIndex,
        -
        7242  const VkMemoryAllocateInfo& allocInfo,
        -
        7243  bool map,
        -
        7244  bool isUserDataString,
        -
        7245  void* pUserData,
        -
        7246  VmaAllocation* pAllocation);
        +
        7237  VkPhysicalDevice m_PhysicalDevice;
        +
        7238  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
        +
        7239  VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.
        +
        7240 
        +
        7241  VMA_RW_MUTEX m_PoolsMutex;
        +
        7242  // Protected by m_PoolsMutex. Sorted by pointer value.
        +
        7243  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
        +
        7244  uint32_t m_NextPoolId;
        +
        7245 
        +
        7246  VmaVulkanFunctions m_VulkanFunctions;
        7247 
        -
        7248  // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.
        -
        7249  VkResult AllocateDedicatedMemory(
        -
        7250  VkDeviceSize size,
        -
        7251  VmaSuballocationType suballocType,
        -
        7252  uint32_t memTypeIndex,
        -
        7253  bool withinBudget,
        -
        7254  bool map,
        -
        7255  bool isUserDataString,
        -
        7256  void* pUserData,
        -
        7257  VkBuffer dedicatedBuffer,
        -
        7258  VkImage dedicatedImage,
        -
        7259  size_t allocationCount,
        -
        7260  VmaAllocation* pAllocations);
        -
        7261 
        -
        7262  void FreeDedicatedMemory(const VmaAllocation allocation);
        -
        7263 
        -
        7264  /*
        -
        7265  Calculates and returns bit mask of memory types that can support defragmentation
        -
        7266  on GPU as they support creation of required buffer for copy operations.
        -
        7267  */
        -
        7268  uint32_t CalculateGpuDefragmentationMemoryTypeBits() const;
        -
        7269 
        -
        7270 #if VMA_MEMORY_BUDGET
        -
        7271  void UpdateVulkanBudget();
        -
        7272 #endif // #if VMA_MEMORY_BUDGET
        -
        7273 };
        -
        7274 
        -
        7276 // Memory allocation #2 after VmaAllocator_T definition
        -
        7277 
        -
        7278 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
        -
        7279 {
        -
        7280  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
        -
        7281 }
        -
        7282 
        -
        7283 static void VmaFree(VmaAllocator hAllocator, void* ptr)
        -
        7284 {
        -
        7285  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
        -
        7286 }
        -
        7287 
        -
        7288 template<typename T>
        -
        7289 static T* VmaAllocate(VmaAllocator hAllocator)
        -
        7290 {
        -
        7291  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
        -
        7292 }
        -
        7293 
        -
        7294 template<typename T>
        -
        7295 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
        -
        7296 {
        -
        7297  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
        -
        7298 }
        -
        7299 
        -
        7300 template<typename T>
        -
        7301 static void vma_delete(VmaAllocator hAllocator, T* ptr)
        -
        7302 {
        -
        7303  if(ptr != VMA_NULL)
        -
        7304  {
        -
        7305  ptr->~T();
        -
        7306  VmaFree(hAllocator, ptr);
        -
        7307  }
        -
        7308 }
        -
        7309 
        -
        7310 template<typename T>
        -
        7311 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
        -
        7312 {
        -
        7313  if(ptr != VMA_NULL)
        -
        7314  {
        -
        7315  for(size_t i = count; i--; )
        -
        7316  ptr[i].~T();
        -
        7317  VmaFree(hAllocator, ptr);
        -
        7318  }
        -
        7319 }
        -
        7320 
        -
        7322 // VmaStringBuilder
        -
        7323 
        -
        7324 #if VMA_STATS_STRING_ENABLED
        -
        7325 
        -
        7326 class VmaStringBuilder
        +
        7248 #if VMA_RECORDING_ENABLED
        +
        7249  VmaRecorder* m_pRecorder;
        +
        7250 #endif
        +
        7251 
        +
        7252  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
        +
        7253 
        +
        7254  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
        +
        7255 
        +
        7256  VkResult AllocateMemoryOfType(
        +
        7257  VkDeviceSize size,
        +
        7258  VkDeviceSize alignment,
        +
        7259  bool dedicatedAllocation,
        +
        7260  VkBuffer dedicatedBuffer,
        +
        7261  VkImage dedicatedImage,
        +
        7262  const VmaAllocationCreateInfo& createInfo,
        +
        7263  uint32_t memTypeIndex,
        +
        7264  VmaSuballocationType suballocType,
        +
        7265  size_t allocationCount,
        +
        7266  VmaAllocation* pAllocations);
        +
        7267 
        +
        7268  // Helper function only to be used inside AllocateDedicatedMemory.
        +
        7269  VkResult AllocateDedicatedMemoryPage(
        +
        7270  VkDeviceSize size,
        +
        7271  VmaSuballocationType suballocType,
        +
        7272  uint32_t memTypeIndex,
        +
        7273  const VkMemoryAllocateInfo& allocInfo,
        +
        7274  bool map,
        +
        7275  bool isUserDataString,
        +
        7276  void* pUserData,
        +
        7277  VmaAllocation* pAllocation);
        +
        7278 
        +
        7279  // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.
        +
        7280  VkResult AllocateDedicatedMemory(
        +
        7281  VkDeviceSize size,
        +
        7282  VmaSuballocationType suballocType,
        +
        7283  uint32_t memTypeIndex,
        +
        7284  bool withinBudget,
        +
        7285  bool map,
        +
        7286  bool isUserDataString,
        +
        7287  void* pUserData,
        +
        7288  VkBuffer dedicatedBuffer,
        +
        7289  VkImage dedicatedImage,
        +
        7290  size_t allocationCount,
        +
        7291  VmaAllocation* pAllocations);
        +
        7292 
        +
        7293  void FreeDedicatedMemory(const VmaAllocation allocation);
        +
        7294 
        +
        7295  /*
        +
        7296  Calculates and returns bit mask of memory types that can support defragmentation
        +
        7297  on GPU as they support creation of required buffer for copy operations.
        +
        7298  */
        +
        7299  uint32_t CalculateGpuDefragmentationMemoryTypeBits() const;
        +
        7300 
        +
        7301 #if VMA_MEMORY_BUDGET
        +
        7302  void UpdateVulkanBudget();
        +
        7303 #endif // #if VMA_MEMORY_BUDGET
        +
        7304 };
        +
        7305 
        +
        7307 // Memory allocation #2 after VmaAllocator_T definition
        +
        7308 
        +
        7309 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
        +
        7310 {
        +
        7311  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
        +
        7312 }
        +
        7313 
        +
        7314 static void VmaFree(VmaAllocator hAllocator, void* ptr)
        +
        7315 {
        +
        7316  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
        +
        7317 }
        +
        7318 
        +
        7319 template<typename T>
        +
        7320 static T* VmaAllocate(VmaAllocator hAllocator)
        +
        7321 {
        +
        7322  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
        +
        7323 }
        +
        7324 
        +
        7325 template<typename T>
        +
        7326 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
        7327 {
        -
        7328 public:
        -
        7329  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
        -
        7330  size_t GetLength() const { return m_Data.size(); }
        -
        7331  const char* GetData() const { return m_Data.data(); }
        -
        7332 
        -
        7333  void Add(char ch) { m_Data.push_back(ch); }
        -
        7334  void Add(const char* pStr);
        -
        7335  void AddNewLine() { Add('\n'); }
        -
        7336  void AddNumber(uint32_t num);
        -
        7337  void AddNumber(uint64_t num);
        -
        7338  void AddPointer(const void* ptr);
        -
        7339 
        -
        7340 private:
        -
        7341  VmaVector< char, VmaStlAllocator<char> > m_Data;
        -
        7342 };
        -
        7343 
        -
        7344 void VmaStringBuilder::Add(const char* pStr)
        -
        7345 {
        -
        7346  const size_t strLen = strlen(pStr);
        -
        7347  if(strLen > 0)
        -
        7348  {
        -
        7349  const size_t oldCount = m_Data.size();
        -
        7350  m_Data.resize(oldCount + strLen);
        -
        7351  memcpy(m_Data.data() + oldCount, pStr, strLen);
        -
        7352  }
        -
        7353 }
        +
        7328  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
        +
        7329 }
        +
        7330 
        +
        7331 template<typename T>
        +
        7332 static void vma_delete(VmaAllocator hAllocator, T* ptr)
        +
        7333 {
        +
        7334  if(ptr != VMA_NULL)
        +
        7335  {
        +
        7336  ptr->~T();
        +
        7337  VmaFree(hAllocator, ptr);
        +
        7338  }
        +
        7339 }
        +
        7340 
        +
        7341 template<typename T>
        +
        7342 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
        +
        7343 {
        +
        7344  if(ptr != VMA_NULL)
        +
        7345  {
        +
        7346  for(size_t i = count; i--; )
        +
        7347  ptr[i].~T();
        +
        7348  VmaFree(hAllocator, ptr);
        +
        7349  }
        +
        7350 }
        +
        7351 
        +
        7353 // VmaStringBuilder
        7354 
        -
        7355 void VmaStringBuilder::AddNumber(uint32_t num)
        -
        7356 {
        -
        7357  char buf[11];
        -
        7358  buf[10] = '\0';
        -
        7359  char *p = &buf[10];
        -
        7360  do
        -
        7361  {
        -
        7362  *--p = '0' + (num % 10);
        -
        7363  num /= 10;
        -
        7364  }
        -
        7365  while(num);
        -
        7366  Add(p);
        -
        7367 }
        -
        7368 
        -
        7369 void VmaStringBuilder::AddNumber(uint64_t num)
        -
        7370 {
        -
        7371  char buf[21];
        -
        7372  buf[20] = '\0';
        -
        7373  char *p = &buf[20];
        -
        7374  do
        -
        7375  {
        -
        7376  *--p = '0' + (num % 10);
        -
        7377  num /= 10;
        -
        7378  }
        -
        7379  while(num);
        -
        7380  Add(p);
        -
        7381 }
        -
        7382 
        -
        7383 void VmaStringBuilder::AddPointer(const void* ptr)
        -
        7384 {
        -
        7385  char buf[21];
        -
        7386  VmaPtrToStr(buf, sizeof(buf), ptr);
        -
        7387  Add(buf);
        -
        7388 }
        -
        7389 
        -
        7390 #endif // #if VMA_STATS_STRING_ENABLED
        -
        7391 
        -
        7393 // VmaJsonWriter
        -
        7394 
        -
        7395 #if VMA_STATS_STRING_ENABLED
        -
        7396 
        -
        7397 class VmaJsonWriter
        -
        7398 {
        -
        7399  VMA_CLASS_NO_COPY(VmaJsonWriter)
        -
        7400 public:
        -
        7401  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
        -
        7402  ~VmaJsonWriter();
        -
        7403 
        -
        7404  void BeginObject(bool singleLine = false);
        -
        7405  void EndObject();
        -
        7406 
        -
        7407  void BeginArray(bool singleLine = false);
        -
        7408  void EndArray();
        -
        7409 
        -
        7410  void WriteString(const char* pStr);
        -
        7411  void BeginString(const char* pStr = VMA_NULL);
        -
        7412  void ContinueString(const char* pStr);
        -
        7413  void ContinueString(uint32_t n);
        -
        7414  void ContinueString(uint64_t n);
        -
        7415  void ContinueString_Pointer(const void* ptr);
        -
        7416  void EndString(const char* pStr = VMA_NULL);
        -
        7417 
        -
        7418  void WriteNumber(uint32_t n);
        -
        7419  void WriteNumber(uint64_t n);
        -
        7420  void WriteBool(bool b);
        -
        7421  void WriteNull();
        +
        7355 #if VMA_STATS_STRING_ENABLED
        +
        7356 
        +
        7357 class VmaStringBuilder
        +
        7358 {
        +
        7359 public:
        +
        7360  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
        +
        7361  size_t GetLength() const { return m_Data.size(); }
        +
        7362  const char* GetData() const { return m_Data.data(); }
        +
        7363 
        +
        7364  void Add(char ch) { m_Data.push_back(ch); }
        +
        7365  void Add(const char* pStr);
        +
        7366  void AddNewLine() { Add('\n'); }
        +
        7367  void AddNumber(uint32_t num);
        +
        7368  void AddNumber(uint64_t num);
        +
        7369  void AddPointer(const void* ptr);
        +
        7370 
        +
        7371 private:
        +
        7372  VmaVector< char, VmaStlAllocator<char> > m_Data;
        +
        7373 };
        +
        7374 
        +
        7375 void VmaStringBuilder::Add(const char* pStr)
        +
        7376 {
        +
        7377  const size_t strLen = strlen(pStr);
        +
        7378  if(strLen > 0)
        +
        7379  {
        +
        7380  const size_t oldCount = m_Data.size();
        +
        7381  m_Data.resize(oldCount + strLen);
        +
        7382  memcpy(m_Data.data() + oldCount, pStr, strLen);
        +
        7383  }
        +
        7384 }
        +
        7385 
        +
        7386 void VmaStringBuilder::AddNumber(uint32_t num)
        +
        7387 {
        +
        7388  char buf[11];
        +
        7389  buf[10] = '\0';
        +
        7390  char *p = &buf[10];
        +
        7391  do
        +
        7392  {
        +
        7393  *--p = '0' + (num % 10);
        +
        7394  num /= 10;
        +
        7395  }
        +
        7396  while(num);
        +
        7397  Add(p);
        +
        7398 }
        +
        7399 
        +
        7400 void VmaStringBuilder::AddNumber(uint64_t num)
        +
        7401 {
        +
        7402  char buf[21];
        +
        7403  buf[20] = '\0';
        +
        7404  char *p = &buf[20];
        +
        7405  do
        +
        7406  {
        +
        7407  *--p = '0' + (num % 10);
        +
        7408  num /= 10;
        +
        7409  }
        +
        7410  while(num);
        +
        7411  Add(p);
        +
        7412 }
        +
        7413 
        +
        7414 void VmaStringBuilder::AddPointer(const void* ptr)
        +
        7415 {
        +
        7416  char buf[21];
        +
        7417  VmaPtrToStr(buf, sizeof(buf), ptr);
        +
        7418  Add(buf);
        +
        7419 }
        +
        7420 
        +
        7421 #endif // #if VMA_STATS_STRING_ENABLED
        7422 
        -
        7423 private:
        -
        7424  static const char* const INDENT;
        +
        7424 // VmaJsonWriter
        7425 
        -
        7426  enum COLLECTION_TYPE
        -
        7427  {
        -
        7428  COLLECTION_TYPE_OBJECT,
        -
        7429  COLLECTION_TYPE_ARRAY,
        -
        7430  };
        -
        7431  struct StackItem
        -
        7432  {
        -
        7433  COLLECTION_TYPE type;
        -
        7434  uint32_t valueCount;
        -
        7435  bool singleLineMode;
        -
        7436  };
        -
        7437 
        -
        7438  VmaStringBuilder& m_SB;
        -
        7439  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
        -
        7440  bool m_InsideString;
        -
        7441 
        -
        7442  void BeginValue(bool isString);
        -
        7443  void WriteIndent(bool oneLess = false);
        -
        7444 };
        -
        7445 
        -
        7446 const char* const VmaJsonWriter::INDENT = " ";
        -
        7447 
        -
        7448 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
        -
        7449  m_SB(sb),
        -
        7450  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
        -
        7451  m_InsideString(false)
        -
        7452 {
        -
        7453 }
        -
        7454 
        -
        7455 VmaJsonWriter::~VmaJsonWriter()
        -
        7456 {
        -
        7457  VMA_ASSERT(!m_InsideString);
        -
        7458  VMA_ASSERT(m_Stack.empty());
        -
        7459 }
        -
        7460 
        -
        7461 void VmaJsonWriter::BeginObject(bool singleLine)
        -
        7462 {
        -
        7463  VMA_ASSERT(!m_InsideString);
        -
        7464 
        -
        7465  BeginValue(false);
        -
        7466  m_SB.Add('{');
        -
        7467 
        -
        7468  StackItem item;
        -
        7469  item.type = COLLECTION_TYPE_OBJECT;
        -
        7470  item.valueCount = 0;
        -
        7471  item.singleLineMode = singleLine;
        -
        7472  m_Stack.push_back(item);
        -
        7473 }
        -
        7474 
        -
        7475 void VmaJsonWriter::EndObject()
        -
        7476 {
        -
        7477  VMA_ASSERT(!m_InsideString);
        +
        7426 #if VMA_STATS_STRING_ENABLED
        +
        7427 
        +
        7428 class VmaJsonWriter
        +
        7429 {
        +
        7430  VMA_CLASS_NO_COPY(VmaJsonWriter)
        +
        7431 public:
        +
        7432  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
        +
        7433  ~VmaJsonWriter();
        +
        7434 
        +
        7435  void BeginObject(bool singleLine = false);
        +
        7436  void EndObject();
        +
        7437 
        +
        7438  void BeginArray(bool singleLine = false);
        +
        7439  void EndArray();
        +
        7440 
        +
        7441  void WriteString(const char* pStr);
        +
        7442  void BeginString(const char* pStr = VMA_NULL);
        +
        7443  void ContinueString(const char* pStr);
        +
        7444  void ContinueString(uint32_t n);
        +
        7445  void ContinueString(uint64_t n);
        +
        7446  void ContinueString_Pointer(const void* ptr);
        +
        7447  void EndString(const char* pStr = VMA_NULL);
        +
        7448 
        +
        7449  void WriteNumber(uint32_t n);
        +
        7450  void WriteNumber(uint64_t n);
        +
        7451  void WriteBool(bool b);
        +
        7452  void WriteNull();
        +
        7453 
        +
        7454 private:
        +
        7455  static const char* const INDENT;
        +
        7456 
        +
        7457  enum COLLECTION_TYPE
        +
        7458  {
        +
        7459  COLLECTION_TYPE_OBJECT,
        +
        7460  COLLECTION_TYPE_ARRAY,
        +
        7461  };
        +
        7462  struct StackItem
        +
        7463  {
        +
        7464  COLLECTION_TYPE type;
        +
        7465  uint32_t valueCount;
        +
        7466  bool singleLineMode;
        +
        7467  };
        +
        7468 
        +
        7469  VmaStringBuilder& m_SB;
        +
        7470  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
        +
        7471  bool m_InsideString;
        +
        7472 
        +
        7473  void BeginValue(bool isString);
        +
        7474  void WriteIndent(bool oneLess = false);
        +
        7475 };
        +
        7476 
        +
        7477 const char* const VmaJsonWriter::INDENT = " ";
        7478 
        -
        7479  WriteIndent(true);
        -
        7480  m_SB.Add('}');
        -
        7481 
        -
        7482  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
        -
        7483  m_Stack.pop_back();
        +
        7479 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
        +
        7480  m_SB(sb),
        +
        7481  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
        +
        7482  m_InsideString(false)
        +
        7483 {
        7484 }
        7485 
        -
        7486 void VmaJsonWriter::BeginArray(bool singleLine)
        +
        7486 VmaJsonWriter::~VmaJsonWriter()
        7487 {
        7488  VMA_ASSERT(!m_InsideString);
        -
        7489 
        -
        7490  BeginValue(false);
        -
        7491  m_SB.Add('[');
        -
        7492 
        -
        7493  StackItem item;
        -
        7494  item.type = COLLECTION_TYPE_ARRAY;
        -
        7495  item.valueCount = 0;
        -
        7496  item.singleLineMode = singleLine;
        -
        7497  m_Stack.push_back(item);
        -
        7498 }
        -
        7499 
        -
        7500 void VmaJsonWriter::EndArray()
        -
        7501 {
        -
        7502  VMA_ASSERT(!m_InsideString);
        -
        7503 
        -
        7504  WriteIndent(true);
        -
        7505  m_SB.Add(']');
        -
        7506 
        -
        7507  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
        -
        7508  m_Stack.pop_back();
        -
        7509 }
        -
        7510 
        -
        7511 void VmaJsonWriter::WriteString(const char* pStr)
        -
        7512 {
        -
        7513  BeginString(pStr);
        -
        7514  EndString();
        +
        7489  VMA_ASSERT(m_Stack.empty());
        +
        7490 }
        +
        7491 
        +
        7492 void VmaJsonWriter::BeginObject(bool singleLine)
        +
        7493 {
        +
        7494  VMA_ASSERT(!m_InsideString);
        +
        7495 
        +
        7496  BeginValue(false);
        +
        7497  m_SB.Add('{');
        +
        7498 
        +
        7499  StackItem item;
        +
        7500  item.type = COLLECTION_TYPE_OBJECT;
        +
        7501  item.valueCount = 0;
        +
        7502  item.singleLineMode = singleLine;
        +
        7503  m_Stack.push_back(item);
        +
        7504 }
        +
        7505 
        +
        7506 void VmaJsonWriter::EndObject()
        +
        7507 {
        +
        7508  VMA_ASSERT(!m_InsideString);
        +
        7509 
        +
        7510  WriteIndent(true);
        +
        7511  m_SB.Add('}');
        +
        7512 
        +
        7513  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
        +
        7514  m_Stack.pop_back();
        7515 }
        7516 
        -
        7517 void VmaJsonWriter::BeginString(const char* pStr)
        +
        7517 void VmaJsonWriter::BeginArray(bool singleLine)
        7518 {
        7519  VMA_ASSERT(!m_InsideString);
        7520 
        -
        7521  BeginValue(true);
        -
        7522  m_SB.Add('"');
        -
        7523  m_InsideString = true;
        -
        7524  if(pStr != VMA_NULL && pStr[0] != '\0')
        -
        7525  {
        -
        7526  ContinueString(pStr);
        -
        7527  }
        -
        7528 }
        -
        7529 
        -
        7530 void VmaJsonWriter::ContinueString(const char* pStr)
        -
        7531 {
        -
        7532  VMA_ASSERT(m_InsideString);
        -
        7533 
        -
        7534  const size_t strLen = strlen(pStr);
        -
        7535  for(size_t i = 0; i < strLen; ++i)
        -
        7536  {
        -
        7537  char ch = pStr[i];
        -
        7538  if(ch == '\\')
        -
        7539  {
        -
        7540  m_SB.Add("\\\\");
        -
        7541  }
        -
        7542  else if(ch == '"')
        -
        7543  {
        -
        7544  m_SB.Add("\\\"");
        -
        7545  }
        -
        7546  else if(ch >= 32)
        -
        7547  {
        -
        7548  m_SB.Add(ch);
        -
        7549  }
        -
        7550  else switch(ch)
        -
        7551  {
        -
        7552  case '\b':
        -
        7553  m_SB.Add("\\b");
        -
        7554  break;
        -
        7555  case '\f':
        -
        7556  m_SB.Add("\\f");
        -
        7557  break;
        -
        7558  case '\n':
        -
        7559  m_SB.Add("\\n");
        -
        7560  break;
        -
        7561  case '\r':
        -
        7562  m_SB.Add("\\r");
        -
        7563  break;
        -
        7564  case '\t':
        -
        7565  m_SB.Add("\\t");
        -
        7566  break;
        -
        7567  default:
        -
        7568  VMA_ASSERT(0 && "Character not currently supported.");
        -
        7569  break;
        -
        7570  }
        -
        7571  }
        -
        7572 }
        -
        7573 
        -
        7574 void VmaJsonWriter::ContinueString(uint32_t n)
        -
        7575 {
        -
        7576  VMA_ASSERT(m_InsideString);
        -
        7577  m_SB.AddNumber(n);
        -
        7578 }
        -
        7579 
        -
        7580 void VmaJsonWriter::ContinueString(uint64_t n)
        -
        7581 {
        -
        7582  VMA_ASSERT(m_InsideString);
        -
        7583  m_SB.AddNumber(n);
        -
        7584 }
        -
        7585 
        -
        7586 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
        -
        7587 {
        -
        7588  VMA_ASSERT(m_InsideString);
        -
        7589  m_SB.AddPointer(ptr);
        -
        7590 }
        -
        7591 
        -
        7592 void VmaJsonWriter::EndString(const char* pStr)
        -
        7593 {
        -
        7594  VMA_ASSERT(m_InsideString);
        -
        7595  if(pStr != VMA_NULL && pStr[0] != '\0')
        -
        7596  {
        -
        7597  ContinueString(pStr);
        -
        7598  }
        -
        7599  m_SB.Add('"');
        -
        7600  m_InsideString = false;
        -
        7601 }
        -
        7602 
        -
        7603 void VmaJsonWriter::WriteNumber(uint32_t n)
        -
        7604 {
        -
        7605  VMA_ASSERT(!m_InsideString);
        -
        7606  BeginValue(false);
        -
        7607  m_SB.AddNumber(n);
        -
        7608 }
        -
        7609 
        -
        7610 void VmaJsonWriter::WriteNumber(uint64_t n)
        -
        7611 {
        -
        7612  VMA_ASSERT(!m_InsideString);
        -
        7613  BeginValue(false);
        +
        7521  BeginValue(false);
        +
        7522  m_SB.Add('[');
        +
        7523 
        +
        7524  StackItem item;
        +
        7525  item.type = COLLECTION_TYPE_ARRAY;
        +
        7526  item.valueCount = 0;
        +
        7527  item.singleLineMode = singleLine;
        +
        7528  m_Stack.push_back(item);
        +
        7529 }
        +
        7530 
        +
        7531 void VmaJsonWriter::EndArray()
        +
        7532 {
        +
        7533  VMA_ASSERT(!m_InsideString);
        +
        7534 
        +
        7535  WriteIndent(true);
        +
        7536  m_SB.Add(']');
        +
        7537 
        +
        7538  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
        +
        7539  m_Stack.pop_back();
        +
        7540 }
        +
        7541 
        +
        7542 void VmaJsonWriter::WriteString(const char* pStr)
        +
        7543 {
        +
        7544  BeginString(pStr);
        +
        7545  EndString();
        +
        7546 }
        +
        7547 
        +
        7548 void VmaJsonWriter::BeginString(const char* pStr)
        +
        7549 {
        +
        7550  VMA_ASSERT(!m_InsideString);
        +
        7551 
        +
        7552  BeginValue(true);
        +
        7553  m_SB.Add('"');
        +
        7554  m_InsideString = true;
        +
        7555  if(pStr != VMA_NULL && pStr[0] != '\0')
        +
        7556  {
        +
        7557  ContinueString(pStr);
        +
        7558  }
        +
        7559 }
        +
        7560 
        +
        7561 void VmaJsonWriter::ContinueString(const char* pStr)
        +
        7562 {
        +
        7563  VMA_ASSERT(m_InsideString);
        +
        7564 
        +
        7565  const size_t strLen = strlen(pStr);
        +
        7566  for(size_t i = 0; i < strLen; ++i)
        +
        7567  {
        +
        7568  char ch = pStr[i];
        +
        7569  if(ch == '\\')
        +
        7570  {
        +
        7571  m_SB.Add("\\\\");
        +
        7572  }
        +
        7573  else if(ch == '"')
        +
        7574  {
        +
        7575  m_SB.Add("\\\"");
        +
        7576  }
        +
        7577  else if(ch >= 32)
        +
        7578  {
        +
        7579  m_SB.Add(ch);
        +
        7580  }
        +
        7581  else switch(ch)
        +
        7582  {
        +
        7583  case '\b':
        +
        7584  m_SB.Add("\\b");
        +
        7585  break;
        +
        7586  case '\f':
        +
        7587  m_SB.Add("\\f");
        +
        7588  break;
        +
        7589  case '\n':
        +
        7590  m_SB.Add("\\n");
        +
        7591  break;
        +
        7592  case '\r':
        +
        7593  m_SB.Add("\\r");
        +
        7594  break;
        +
        7595  case '\t':
        +
        7596  m_SB.Add("\\t");
        +
        7597  break;
        +
        7598  default:
        +
        7599  VMA_ASSERT(0 && "Character not currently supported.");
        +
        7600  break;
        +
        7601  }
        +
        7602  }
        +
        7603 }
        +
        7604 
        +
        7605 void VmaJsonWriter::ContinueString(uint32_t n)
        +
        7606 {
        +
        7607  VMA_ASSERT(m_InsideString);
        +
        7608  m_SB.AddNumber(n);
        +
        7609 }
        +
        7610 
        +
        7611 void VmaJsonWriter::ContinueString(uint64_t n)
        +
        7612 {
        +
        7613  VMA_ASSERT(m_InsideString);
        7614  m_SB.AddNumber(n);
        7615 }
        7616 
        -
        7617 void VmaJsonWriter::WriteBool(bool b)
        +
        7617 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
        7618 {
        -
        7619  VMA_ASSERT(!m_InsideString);
        -
        7620  BeginValue(false);
        -
        7621  m_SB.Add(b ? "true" : "false");
        -
        7622 }
        -
        7623 
        -
        7624 void VmaJsonWriter::WriteNull()
        -
        7625 {
        -
        7626  VMA_ASSERT(!m_InsideString);
        -
        7627  BeginValue(false);
        -
        7628  m_SB.Add("null");
        -
        7629 }
        -
        7630 
        -
        7631 void VmaJsonWriter::BeginValue(bool isString)
        -
        7632 {
        -
        7633  if(!m_Stack.empty())
        -
        7634  {
        -
        7635  StackItem& currItem = m_Stack.back();
        -
        7636  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        -
        7637  currItem.valueCount % 2 == 0)
        -
        7638  {
        -
        7639  VMA_ASSERT(isString);
        -
        7640  }
        -
        7641 
        -
        7642  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        -
        7643  currItem.valueCount % 2 != 0)
        -
        7644  {
        -
        7645  m_SB.Add(": ");
        -
        7646  }
        -
        7647  else if(currItem.valueCount > 0)
        -
        7648  {
        -
        7649  m_SB.Add(", ");
        -
        7650  WriteIndent();
        -
        7651  }
        -
        7652  else
        -
        7653  {
        -
        7654  WriteIndent();
        -
        7655  }
        -
        7656  ++currItem.valueCount;
        -
        7657  }
        -
        7658 }
        -
        7659 
        -
        7660 void VmaJsonWriter::WriteIndent(bool oneLess)
        -
        7661 {
        -
        7662  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
        -
        7663  {
        -
        7664  m_SB.AddNewLine();
        -
        7665 
        -
        7666  size_t count = m_Stack.size();
        -
        7667  if(count > 0 && oneLess)
        -
        7668  {
        -
        7669  --count;
        -
        7670  }
        -
        7671  for(size_t i = 0; i < count; ++i)
        -
        7672  {
        -
        7673  m_SB.Add(INDENT);
        -
        7674  }
        -
        7675  }
        -
        7676 }
        -
        7677 
        -
        7678 #endif // #if VMA_STATS_STRING_ENABLED
        -
        7679 
        -
        7681 
        -
        7682 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
        -
        7683 {
        -
        7684  if(IsUserDataString())
        -
        7685  {
        -
        7686  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
        -
        7687 
        -
        7688  FreeUserDataString(hAllocator);
        -
        7689 
        -
        7690  if(pUserData != VMA_NULL)
        -
        7691  {
        -
        7692  m_pUserData = VmaCreateStringCopy(hAllocator->GetAllocationCallbacks(), (const char*)pUserData);
        -
        7693  }
        -
        7694  }
        -
        7695  else
        -
        7696  {
        -
        7697  m_pUserData = pUserData;
        -
        7698  }
        -
        7699 }
        -
        7700 
        -
        7701 void VmaAllocation_T::ChangeBlockAllocation(
        -
        7702  VmaAllocator hAllocator,
        -
        7703  VmaDeviceMemoryBlock* block,
        -
        7704  VkDeviceSize offset)
        -
        7705 {
        -
        7706  VMA_ASSERT(block != VMA_NULL);
        -
        7707  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        +
        7619  VMA_ASSERT(m_InsideString);
        +
        7620  m_SB.AddPointer(ptr);
        +
        7621 }
        +
        7622 
        +
        7623 void VmaJsonWriter::EndString(const char* pStr)
        +
        7624 {
        +
        7625  VMA_ASSERT(m_InsideString);
        +
        7626  if(pStr != VMA_NULL && pStr[0] != '\0')
        +
        7627  {
        +
        7628  ContinueString(pStr);
        +
        7629  }
        +
        7630  m_SB.Add('"');
        +
        7631  m_InsideString = false;
        +
        7632 }
        +
        7633 
        +
        7634 void VmaJsonWriter::WriteNumber(uint32_t n)
        +
        7635 {
        +
        7636  VMA_ASSERT(!m_InsideString);
        +
        7637  BeginValue(false);
        +
        7638  m_SB.AddNumber(n);
        +
        7639 }
        +
        7640 
        +
        7641 void VmaJsonWriter::WriteNumber(uint64_t n)
        +
        7642 {
        +
        7643  VMA_ASSERT(!m_InsideString);
        +
        7644  BeginValue(false);
        +
        7645  m_SB.AddNumber(n);
        +
        7646 }
        +
        7647 
        +
        7648 void VmaJsonWriter::WriteBool(bool b)
        +
        7649 {
        +
        7650  VMA_ASSERT(!m_InsideString);
        +
        7651  BeginValue(false);
        +
        7652  m_SB.Add(b ? "true" : "false");
        +
        7653 }
        +
        7654 
        +
        7655 void VmaJsonWriter::WriteNull()
        +
        7656 {
        +
        7657  VMA_ASSERT(!m_InsideString);
        +
        7658  BeginValue(false);
        +
        7659  m_SB.Add("null");
        +
        7660 }
        +
        7661 
        +
        7662 void VmaJsonWriter::BeginValue(bool isString)
        +
        7663 {
        +
        7664  if(!m_Stack.empty())
        +
        7665  {
        +
        7666  StackItem& currItem = m_Stack.back();
        +
        7667  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        +
        7668  currItem.valueCount % 2 == 0)
        +
        7669  {
        +
        7670  VMA_ASSERT(isString);
        +
        7671  }
        +
        7672 
        +
        7673  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        +
        7674  currItem.valueCount % 2 != 0)
        +
        7675  {
        +
        7676  m_SB.Add(": ");
        +
        7677  }
        +
        7678  else if(currItem.valueCount > 0)
        +
        7679  {
        +
        7680  m_SB.Add(", ");
        +
        7681  WriteIndent();
        +
        7682  }
        +
        7683  else
        +
        7684  {
        +
        7685  WriteIndent();
        +
        7686  }
        +
        7687  ++currItem.valueCount;
        +
        7688  }
        +
        7689 }
        +
        7690 
        +
        7691 void VmaJsonWriter::WriteIndent(bool oneLess)
        +
        7692 {
        +
        7693  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
        +
        7694  {
        +
        7695  m_SB.AddNewLine();
        +
        7696 
        +
        7697  size_t count = m_Stack.size();
        +
        7698  if(count > 0 && oneLess)
        +
        7699  {
        +
        7700  --count;
        +
        7701  }
        +
        7702  for(size_t i = 0; i < count; ++i)
        +
        7703  {
        +
        7704  m_SB.Add(INDENT);
        +
        7705  }
        +
        7706  }
        +
        7707 }
        7708 
        -
        7709  // Move mapping reference counter from old block to new block.
        -
        7710  if(block != m_BlockAllocation.m_Block)
        -
        7711  {
        -
        7712  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
        -
        7713  if(IsPersistentMap())
        -
        7714  ++mapRefCount;
        -
        7715  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
        -
        7716  block->Map(hAllocator, mapRefCount, VMA_NULL);
        -
        7717  }
        +
        7709 #endif // #if VMA_STATS_STRING_ENABLED
        +
        7710 
        +
        7712 
        +
        7713 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
        +
        7714 {
        +
        7715  if(IsUserDataString())
        +
        7716  {
        +
        7717  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
        7718 
        -
        7719  m_BlockAllocation.m_Block = block;
        -
        7720  m_BlockAllocation.m_Offset = offset;
        -
        7721 }
        -
        7722 
        -
        7723 void VmaAllocation_T::ChangeOffset(VkDeviceSize newOffset)
        -
        7724 {
        -
        7725  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        -
        7726  m_BlockAllocation.m_Offset = newOffset;
        -
        7727 }
        -
        7728 
        -
        7729 VkDeviceSize VmaAllocation_T::GetOffset() const
        -
        7730 {
        -
        7731  switch(m_Type)
        -
        7732  {
        -
        7733  case ALLOCATION_TYPE_BLOCK:
        -
        7734  return m_BlockAllocation.m_Offset;
        -
        7735  case ALLOCATION_TYPE_DEDICATED:
        -
        7736  return 0;
        -
        7737  default:
        -
        7738  VMA_ASSERT(0);
        -
        7739  return 0;
        -
        7740  }
        -
        7741 }
        -
        7742 
        -
        7743 VkDeviceMemory VmaAllocation_T::GetMemory() const
        -
        7744 {
        -
        7745  switch(m_Type)
        -
        7746  {
        -
        7747  case ALLOCATION_TYPE_BLOCK:
        -
        7748  return m_BlockAllocation.m_Block->GetDeviceMemory();
        -
        7749  case ALLOCATION_TYPE_DEDICATED:
        -
        7750  return m_DedicatedAllocation.m_hMemory;
        -
        7751  default:
        -
        7752  VMA_ASSERT(0);
        -
        7753  return VK_NULL_HANDLE;
        -
        7754  }
        -
        7755 }
        -
        7756 
        -
        7757 void* VmaAllocation_T::GetMappedData() const
        -
        7758 {
        -
        7759  switch(m_Type)
        -
        7760  {
        -
        7761  case ALLOCATION_TYPE_BLOCK:
        -
        7762  if(m_MapCount != 0)
        -
        7763  {
        -
        7764  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
        -
        7765  VMA_ASSERT(pBlockData != VMA_NULL);
        -
        7766  return (char*)pBlockData + m_BlockAllocation.m_Offset;
        -
        7767  }
        -
        7768  else
        -
        7769  {
        -
        7770  return VMA_NULL;
        -
        7771  }
        -
        7772  break;
        -
        7773  case ALLOCATION_TYPE_DEDICATED:
        -
        7774  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
        -
        7775  return m_DedicatedAllocation.m_pMappedData;
        -
        7776  default:
        -
        7777  VMA_ASSERT(0);
        -
        7778  return VMA_NULL;
        -
        7779  }
        -
        7780 }
        -
        7781 
        -
        7782 bool VmaAllocation_T::CanBecomeLost() const
        -
        7783 {
        -
        7784  switch(m_Type)
        -
        7785  {
        -
        7786  case ALLOCATION_TYPE_BLOCK:
        -
        7787  return m_BlockAllocation.m_CanBecomeLost;
        -
        7788  case ALLOCATION_TYPE_DEDICATED:
        -
        7789  return false;
        -
        7790  default:
        -
        7791  VMA_ASSERT(0);
        -
        7792  return false;
        -
        7793  }
        -
        7794 }
        -
        7795 
        -
        7796 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        -
        7797 {
        -
        7798  VMA_ASSERT(CanBecomeLost());
        -
        7799 
        -
        7800  /*
        -
        7801  Warning: This is a carefully designed algorithm.
        -
        7802  Do not modify unless you really know what you're doing :)
        -
        7803  */
        -
        7804  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
        -
        7805  for(;;)
        -
        7806  {
        -
        7807  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        -
        7808  {
        -
        7809  VMA_ASSERT(0);
        -
        7810  return false;
        -
        7811  }
        -
        7812  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
        -
        7813  {
        -
        7814  return false;
        -
        7815  }
        -
        7816  else // Last use time earlier than current time.
        -
        7817  {
        -
        7818  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
        -
        7819  {
        -
        7820  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
        -
        7821  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
        -
        7822  return true;
        -
        7823  }
        -
        7824  }
        -
        7825  }
        -
        7826 }
        -
        7827 
        -
        7828 #if VMA_STATS_STRING_ENABLED
        -
        7829 
        -
        7830 // Correspond to values of enum VmaSuballocationType.
        -
        7831 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
        -
        7832  "FREE",
        -
        7833  "UNKNOWN",
        -
        7834  "BUFFER",
        -
        7835  "IMAGE_UNKNOWN",
        -
        7836  "IMAGE_LINEAR",
        -
        7837  "IMAGE_OPTIMAL",
        -
        7838 };
        -
        7839 
        -
        7840 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
        -
        7841 {
        -
        7842  json.WriteString("Type");
        -
        7843  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
        -
        7844 
        -
        7845  json.WriteString("Size");
        -
        7846  json.WriteNumber(m_Size);
        -
        7847 
        -
        7848  if(m_pUserData != VMA_NULL)
        -
        7849  {
        -
        7850  json.WriteString("UserData");
        -
        7851  if(IsUserDataString())
        -
        7852  {
        -
        7853  json.WriteString((const char*)m_pUserData);
        -
        7854  }
        -
        7855  else
        -
        7856  {
        -
        7857  json.BeginString();
        -
        7858  json.ContinueString_Pointer(m_pUserData);
        -
        7859  json.EndString();
        -
        7860  }
        -
        7861  }
        -
        7862 
        -
        7863  json.WriteString("CreationFrameIndex");
        -
        7864  json.WriteNumber(m_CreationFrameIndex);
        -
        7865 
        -
        7866  json.WriteString("LastUseFrameIndex");
        -
        7867  json.WriteNumber(GetLastUseFrameIndex());
        -
        7868 
        -
        7869  if(m_BufferImageUsage != 0)
        -
        7870  {
        -
        7871  json.WriteString("Usage");
        -
        7872  json.WriteNumber(m_BufferImageUsage);
        -
        7873  }
        -
        7874 }
        +
        7719  FreeUserDataString(hAllocator);
        +
        7720 
        +
        7721  if(pUserData != VMA_NULL)
        +
        7722  {
        +
        7723  m_pUserData = VmaCreateStringCopy(hAllocator->GetAllocationCallbacks(), (const char*)pUserData);
        +
        7724  }
        +
        7725  }
        +
        7726  else
        +
        7727  {
        +
        7728  m_pUserData = pUserData;
        +
        7729  }
        +
        7730 }
        +
        7731 
        +
        7732 void VmaAllocation_T::ChangeBlockAllocation(
        +
        7733  VmaAllocator hAllocator,
        +
        7734  VmaDeviceMemoryBlock* block,
        +
        7735  VkDeviceSize offset)
        +
        7736 {
        +
        7737  VMA_ASSERT(block != VMA_NULL);
        +
        7738  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        +
        7739 
        +
        7740  // Move mapping reference counter from old block to new block.
        +
        7741  if(block != m_BlockAllocation.m_Block)
        +
        7742  {
        +
        7743  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
        +
        7744  if(IsPersistentMap())
        +
        7745  ++mapRefCount;
        +
        7746  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
        +
        7747  block->Map(hAllocator, mapRefCount, VMA_NULL);
        +
        7748  }
        +
        7749 
        +
        7750  m_BlockAllocation.m_Block = block;
        +
        7751  m_BlockAllocation.m_Offset = offset;
        +
        7752 }
        +
        7753 
        +
        7754 void VmaAllocation_T::ChangeOffset(VkDeviceSize newOffset)
        +
        7755 {
        +
        7756  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        +
        7757  m_BlockAllocation.m_Offset = newOffset;
        +
        7758 }
        +
        7759 
        +
        7760 VkDeviceSize VmaAllocation_T::GetOffset() const
        +
        7761 {
        +
        7762  switch(m_Type)
        +
        7763  {
        +
        7764  case ALLOCATION_TYPE_BLOCK:
        +
        7765  return m_BlockAllocation.m_Offset;
        +
        7766  case ALLOCATION_TYPE_DEDICATED:
        +
        7767  return 0;
        +
        7768  default:
        +
        7769  VMA_ASSERT(0);
        +
        7770  return 0;
        +
        7771  }
        +
        7772 }
        +
        7773 
        +
        7774 VkDeviceMemory VmaAllocation_T::GetMemory() const
        +
        7775 {
        +
        7776  switch(m_Type)
        +
        7777  {
        +
        7778  case ALLOCATION_TYPE_BLOCK:
        +
        7779  return m_BlockAllocation.m_Block->GetDeviceMemory();
        +
        7780  case ALLOCATION_TYPE_DEDICATED:
        +
        7781  return m_DedicatedAllocation.m_hMemory;
        +
        7782  default:
        +
        7783  VMA_ASSERT(0);
        +
        7784  return VK_NULL_HANDLE;
        +
        7785  }
        +
        7786 }
        +
        7787 
        +
        7788 void* VmaAllocation_T::GetMappedData() const
        +
        7789 {
        +
        7790  switch(m_Type)
        +
        7791  {
        +
        7792  case ALLOCATION_TYPE_BLOCK:
        +
        7793  if(m_MapCount != 0)
        +
        7794  {
        +
        7795  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
        +
        7796  VMA_ASSERT(pBlockData != VMA_NULL);
        +
        7797  return (char*)pBlockData + m_BlockAllocation.m_Offset;
        +
        7798  }
        +
        7799  else
        +
        7800  {
        +
        7801  return VMA_NULL;
        +
        7802  }
        +
        7803  break;
        +
        7804  case ALLOCATION_TYPE_DEDICATED:
        +
        7805  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
        +
        7806  return m_DedicatedAllocation.m_pMappedData;
        +
        7807  default:
        +
        7808  VMA_ASSERT(0);
        +
        7809  return VMA_NULL;
        +
        7810  }
        +
        7811 }
        +
        7812 
        +
        7813 bool VmaAllocation_T::CanBecomeLost() const
        +
        7814 {
        +
        7815  switch(m_Type)
        +
        7816  {
        +
        7817  case ALLOCATION_TYPE_BLOCK:
        +
        7818  return m_BlockAllocation.m_CanBecomeLost;
        +
        7819  case ALLOCATION_TYPE_DEDICATED:
        +
        7820  return false;
        +
        7821  default:
        +
        7822  VMA_ASSERT(0);
        +
        7823  return false;
        +
        7824  }
        +
        7825 }
        +
        7826 
        +
        7827 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        +
        7828 {
        +
        7829  VMA_ASSERT(CanBecomeLost());
        +
        7830 
        +
        7831  /*
        +
        7832  Warning: This is a carefully designed algorithm.
        +
        7833  Do not modify unless you really know what you're doing :)
        +
        7834  */
        +
        7835  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
        +
        7836  for(;;)
        +
        7837  {
        +
        7838  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        +
        7839  {
        +
        7840  VMA_ASSERT(0);
        +
        7841  return false;
        +
        7842  }
        +
        7843  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
        +
        7844  {
        +
        7845  return false;
        +
        7846  }
        +
        7847  else // Last use time earlier than current time.
        +
        7848  {
        +
        7849  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
        +
        7850  {
        +
        7851  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
        +
        7852  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
        +
        7853  return true;
        +
        7854  }
        +
        7855  }
        +
        7856  }
        +
        7857 }
        +
        7858 
        +
        7859 #if VMA_STATS_STRING_ENABLED
        +
        7860 
        +
        7861 // Correspond to values of enum VmaSuballocationType.
        +
        7862 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
        +
        7863  "FREE",
        +
        7864  "UNKNOWN",
        +
        7865  "BUFFER",
        +
        7866  "IMAGE_UNKNOWN",
        +
        7867  "IMAGE_LINEAR",
        +
        7868  "IMAGE_OPTIMAL",
        +
        7869 };
        +
        7870 
        +
        7871 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
        +
        7872 {
        +
        7873  json.WriteString("Type");
        +
        7874  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
        7875 
        -
        7876 #endif
        -
        7877 
        -
        7878 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
        -
        7879 {
        -
        7880  VMA_ASSERT(IsUserDataString());
        -
        7881  VmaFreeString(hAllocator->GetAllocationCallbacks(), (char*)m_pUserData);
        -
        7882  m_pUserData = VMA_NULL;
        -
        7883 }
        -
        7884 
        -
        7885 void VmaAllocation_T::BlockAllocMap()
        -
        7886 {
        -
        7887  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        -
        7888 
        -
        7889  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        -
        7890  {
        -
        7891  ++m_MapCount;
        +
        7876  json.WriteString("Size");
        +
        7877  json.WriteNumber(m_Size);
        +
        7878 
        +
        7879  if(m_pUserData != VMA_NULL)
        +
        7880  {
        +
        7881  json.WriteString("UserData");
        +
        7882  if(IsUserDataString())
        +
        7883  {
        +
        7884  json.WriteString((const char*)m_pUserData);
        +
        7885  }
        +
        7886  else
        +
        7887  {
        +
        7888  json.BeginString();
        +
        7889  json.ContinueString_Pointer(m_pUserData);
        +
        7890  json.EndString();
        +
        7891  }
        7892  }
        -
        7893  else
        -
        7894  {
        -
        7895  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
        -
        7896  }
        -
        7897 }
        -
        7898 
        -
        7899 void VmaAllocation_T::BlockAllocUnmap()
        -
        7900 {
        -
        7901  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        -
        7902 
        -
        7903  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        -
        7904  {
        -
        7905  --m_MapCount;
        -
        7906  }
        -
        7907  else
        -
        7908  {
        -
        7909  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
        -
        7910  }
        -
        7911 }
        -
        7912 
        -
        7913 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
        -
        7914 {
        -
        7915  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        -
        7916 
        -
        7917  if(m_MapCount != 0)
        -
        7918  {
        -
        7919  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        -
        7920  {
        -
        7921  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
        -
        7922  *ppData = m_DedicatedAllocation.m_pMappedData;
        -
        7923  ++m_MapCount;
        -
        7924  return VK_SUCCESS;
        -
        7925  }
        -
        7926  else
        -
        7927  {
        -
        7928  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
        -
        7929  return VK_ERROR_MEMORY_MAP_FAILED;
        -
        7930  }
        -
        7931  }
        -
        7932  else
        -
        7933  {
        -
        7934  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        -
        7935  hAllocator->m_hDevice,
        -
        7936  m_DedicatedAllocation.m_hMemory,
        -
        7937  0, // offset
        -
        7938  VK_WHOLE_SIZE,
        -
        7939  0, // flags
        -
        7940  ppData);
        -
        7941  if(result == VK_SUCCESS)
        -
        7942  {
        -
        7943  m_DedicatedAllocation.m_pMappedData = *ppData;
        -
        7944  m_MapCount = 1;
        -
        7945  }
        -
        7946  return result;
        -
        7947  }
        -
        7948 }
        -
        7949 
        -
        7950 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
        -
        7951 {
        -
        7952  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        -
        7953 
        -
        7954  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        -
        7955  {
        -
        7956  --m_MapCount;
        -
        7957  if(m_MapCount == 0)
        +
        7893 
        +
        7894  json.WriteString("CreationFrameIndex");
        +
        7895  json.WriteNumber(m_CreationFrameIndex);
        +
        7896 
        +
        7897  json.WriteString("LastUseFrameIndex");
        +
        7898  json.WriteNumber(GetLastUseFrameIndex());
        +
        7899 
        +
        7900  if(m_BufferImageUsage != 0)
        +
        7901  {
        +
        7902  json.WriteString("Usage");
        +
        7903  json.WriteNumber(m_BufferImageUsage);
        +
        7904  }
        +
        7905 }
        +
        7906 
        +
        7907 #endif
        +
        7908 
        +
        7909 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
        +
        7910 {
        +
        7911  VMA_ASSERT(IsUserDataString());
        +
        7912  VmaFreeString(hAllocator->GetAllocationCallbacks(), (char*)m_pUserData);
        +
        7913  m_pUserData = VMA_NULL;
        +
        7914 }
        +
        7915 
        +
        7916 void VmaAllocation_T::BlockAllocMap()
        +
        7917 {
        +
        7918  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        +
        7919 
        +
        7920  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        +
        7921  {
        +
        7922  ++m_MapCount;
        +
        7923  }
        +
        7924  else
        +
        7925  {
        +
        7926  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
        +
        7927  }
        +
        7928 }
        +
        7929 
        +
        7930 void VmaAllocation_T::BlockAllocUnmap()
        +
        7931 {
        +
        7932  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        +
        7933 
        +
        7934  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        +
        7935  {
        +
        7936  --m_MapCount;
        +
        7937  }
        +
        7938  else
        +
        7939  {
        +
        7940  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
        +
        7941  }
        +
        7942 }
        +
        7943 
        +
        7944 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
        +
        7945 {
        +
        7946  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        +
        7947 
        +
        7948  if(m_MapCount != 0)
        +
        7949  {
        +
        7950  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        +
        7951  {
        +
        7952  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
        +
        7953  *ppData = m_DedicatedAllocation.m_pMappedData;
        +
        7954  ++m_MapCount;
        +
        7955  return VK_SUCCESS;
        +
        7956  }
        +
        7957  else
        7958  {
        -
        7959  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
        -
        7960  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
        -
        7961  hAllocator->m_hDevice,
        -
        7962  m_DedicatedAllocation.m_hMemory);
        -
        7963  }
        -
        7964  }
        -
        7965  else
        -
        7966  {
        -
        7967  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
        -
        7968  }
        -
        7969 }
        -
        7970 
        -
        7971 #if VMA_STATS_STRING_ENABLED
        -
        7972 
        -
        7973 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
        -
        7974 {
        -
        7975  json.BeginObject();
        -
        7976 
        -
        7977  json.WriteString("Blocks");
        -
        7978  json.WriteNumber(stat.blockCount);
        -
        7979 
        -
        7980  json.WriteString("Allocations");
        -
        7981  json.WriteNumber(stat.allocationCount);
        -
        7982 
        -
        7983  json.WriteString("UnusedRanges");
        -
        7984  json.WriteNumber(stat.unusedRangeCount);
        -
        7985 
        -
        7986  json.WriteString("UsedBytes");
        -
        7987  json.WriteNumber(stat.usedBytes);
        -
        7988 
        -
        7989  json.WriteString("UnusedBytes");
        -
        7990  json.WriteNumber(stat.unusedBytes);
        -
        7991 
        -
        7992  if(stat.allocationCount > 1)
        -
        7993  {
        -
        7994  json.WriteString("AllocationSize");
        -
        7995  json.BeginObject(true);
        -
        7996  json.WriteString("Min");
        -
        7997  json.WriteNumber(stat.allocationSizeMin);
        -
        7998  json.WriteString("Avg");
        -
        7999  json.WriteNumber(stat.allocationSizeAvg);
        -
        8000  json.WriteString("Max");
        -
        8001  json.WriteNumber(stat.allocationSizeMax);
        -
        8002  json.EndObject();
        -
        8003  }
        -
        8004 
        -
        8005  if(stat.unusedRangeCount > 1)
        -
        8006  {
        -
        8007  json.WriteString("UnusedRangeSize");
        -
        8008  json.BeginObject(true);
        -
        8009  json.WriteString("Min");
        -
        8010  json.WriteNumber(stat.unusedRangeSizeMin);
        -
        8011  json.WriteString("Avg");
        -
        8012  json.WriteNumber(stat.unusedRangeSizeAvg);
        -
        8013  json.WriteString("Max");
        -
        8014  json.WriteNumber(stat.unusedRangeSizeMax);
        -
        8015  json.EndObject();
        -
        8016  }
        -
        8017 
        -
        8018  json.EndObject();
        -
        8019 }
        -
        8020 
        -
        8021 #endif // #if VMA_STATS_STRING_ENABLED
        +
        7959  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
        +
        7960  return VK_ERROR_MEMORY_MAP_FAILED;
        +
        7961  }
        +
        7962  }
        +
        7963  else
        +
        7964  {
        +
        7965  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        +
        7966  hAllocator->m_hDevice,
        +
        7967  m_DedicatedAllocation.m_hMemory,
        +
        7968  0, // offset
        +
        7969  VK_WHOLE_SIZE,
        +
        7970  0, // flags
        +
        7971  ppData);
        +
        7972  if(result == VK_SUCCESS)
        +
        7973  {
        +
        7974  m_DedicatedAllocation.m_pMappedData = *ppData;
        +
        7975  m_MapCount = 1;
        +
        7976  }
        +
        7977  return result;
        +
        7978  }
        +
        7979 }
        +
        7980 
        +
        7981 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
        +
        7982 {
        +
        7983  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        +
        7984 
        +
        7985  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        +
        7986  {
        +
        7987  --m_MapCount;
        +
        7988  if(m_MapCount == 0)
        +
        7989  {
        +
        7990  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
        +
        7991  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
        +
        7992  hAllocator->m_hDevice,
        +
        7993  m_DedicatedAllocation.m_hMemory);
        +
        7994  }
        +
        7995  }
        +
        7996  else
        +
        7997  {
        +
        7998  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
        +
        7999  }
        +
        8000 }
        +
        8001 
        +
        8002 #if VMA_STATS_STRING_ENABLED
        +
        8003 
        +
        8004 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
        +
        8005 {
        +
        8006  json.BeginObject();
        +
        8007 
        +
        8008  json.WriteString("Blocks");
        +
        8009  json.WriteNumber(stat.blockCount);
        +
        8010 
        +
        8011  json.WriteString("Allocations");
        +
        8012  json.WriteNumber(stat.allocationCount);
        +
        8013 
        +
        8014  json.WriteString("UnusedRanges");
        +
        8015  json.WriteNumber(stat.unusedRangeCount);
        +
        8016 
        +
        8017  json.WriteString("UsedBytes");
        +
        8018  json.WriteNumber(stat.usedBytes);
        +
        8019 
        +
        8020  json.WriteString("UnusedBytes");
        +
        8021  json.WriteNumber(stat.unusedBytes);
        8022 
        -
        8023 struct VmaSuballocationItemSizeLess
        -
        8024 {
        -
        8025  bool operator()(
        -
        8026  const VmaSuballocationList::iterator lhs,
        -
        8027  const VmaSuballocationList::iterator rhs) const
        -
        8028  {
        -
        8029  return lhs->size < rhs->size;
        -
        8030  }
        -
        8031  bool operator()(
        -
        8032  const VmaSuballocationList::iterator lhs,
        -
        8033  VkDeviceSize rhsSize) const
        -
        8034  {
        -
        8035  return lhs->size < rhsSize;
        -
        8036  }
        -
        8037 };
        -
        8038 
        -
        8039 
        -
        8041 // class VmaBlockMetadata
        -
        8042 
        -
        8043 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
        -
        8044  m_Size(0),
        -
        8045  m_pAllocationCallbacks(hAllocator->GetAllocationCallbacks())
        -
        8046 {
        -
        8047 }
        +
        8023  if(stat.allocationCount > 1)
        +
        8024  {
        +
        8025  json.WriteString("AllocationSize");
        +
        8026  json.BeginObject(true);
        +
        8027  json.WriteString("Min");
        +
        8028  json.WriteNumber(stat.allocationSizeMin);
        +
        8029  json.WriteString("Avg");
        +
        8030  json.WriteNumber(stat.allocationSizeAvg);
        +
        8031  json.WriteString("Max");
        +
        8032  json.WriteNumber(stat.allocationSizeMax);
        +
        8033  json.EndObject();
        +
        8034  }
        +
        8035 
        +
        8036  if(stat.unusedRangeCount > 1)
        +
        8037  {
        +
        8038  json.WriteString("UnusedRangeSize");
        +
        8039  json.BeginObject(true);
        +
        8040  json.WriteString("Min");
        +
        8041  json.WriteNumber(stat.unusedRangeSizeMin);
        +
        8042  json.WriteString("Avg");
        +
        8043  json.WriteNumber(stat.unusedRangeSizeAvg);
        +
        8044  json.WriteString("Max");
        +
        8045  json.WriteNumber(stat.unusedRangeSizeMax);
        +
        8046  json.EndObject();
        +
        8047  }
        8048 
        -
        8049 #if VMA_STATS_STRING_ENABLED
        -
        8050 
        -
        8051 void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
        -
        8052  VkDeviceSize unusedBytes,
        -
        8053  size_t allocationCount,
        -
        8054  size_t unusedRangeCount) const
        -
        8055 {
        -
        8056  json.BeginObject();
        -
        8057 
        -
        8058  json.WriteString("TotalBytes");
        -
        8059  json.WriteNumber(GetSize());
        -
        8060 
        -
        8061  json.WriteString("UnusedBytes");
        -
        8062  json.WriteNumber(unusedBytes);
        -
        8063 
        -
        8064  json.WriteString("Allocations");
        -
        8065  json.WriteNumber((uint64_t)allocationCount);
        -
        8066 
        -
        8067  json.WriteString("UnusedRanges");
        -
        8068  json.WriteNumber((uint64_t)unusedRangeCount);
        +
        8049  json.EndObject();
        +
        8050 }
        +
        8051 
        +
        8052 #endif // #if VMA_STATS_STRING_ENABLED
        +
        8053 
        +
        8054 struct VmaSuballocationItemSizeLess
        +
        8055 {
        +
        8056  bool operator()(
        +
        8057  const VmaSuballocationList::iterator lhs,
        +
        8058  const VmaSuballocationList::iterator rhs) const
        +
        8059  {
        +
        8060  return lhs->size < rhs->size;
        +
        8061  }
        +
        8062  bool operator()(
        +
        8063  const VmaSuballocationList::iterator lhs,
        +
        8064  VkDeviceSize rhsSize) const
        +
        8065  {
        +
        8066  return lhs->size < rhsSize;
        +
        8067  }
        +
        8068 };
        8069 
        -
        8070  json.WriteString("Suballocations");
        -
        8071  json.BeginArray();
        -
        8072 }
        +
        8070 
        +
        8072 // class VmaBlockMetadata
        8073 
        -
        8074 void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        -
        8075  VkDeviceSize offset,
        -
        8076  VmaAllocation hAllocation) const
        -
        8077 {
        -
        8078  json.BeginObject(true);
        -
        8079 
        -
        8080  json.WriteString("Offset");
        -
        8081  json.WriteNumber(offset);
        -
        8082 
        -
        8083  hAllocation->PrintParameters(json);
        -
        8084 
        -
        8085  json.EndObject();
        -
        8086 }
        -
        8087 
        -
        8088 void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        -
        8089  VkDeviceSize offset,
        -
        8090  VkDeviceSize size) const
        -
        8091 {
        -
        8092  json.BeginObject(true);
        -
        8093 
        -
        8094  json.WriteString("Offset");
        -
        8095  json.WriteNumber(offset);
        -
        8096 
        -
        8097  json.WriteString("Type");
        -
        8098  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
        -
        8099 
        -
        8100  json.WriteString("Size");
        -
        8101  json.WriteNumber(size);
        -
        8102 
        -
        8103  json.EndObject();
        -
        8104 }
        -
        8105 
        -
        8106 void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
        -
        8107 {
        -
        8108  json.EndArray();
        -
        8109  json.EndObject();
        -
        8110 }
        -
        8111 
        -
        8112 #endif // #if VMA_STATS_STRING_ENABLED
        +
        8074 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
        +
        8075  m_Size(0),
        +
        8076  m_pAllocationCallbacks(hAllocator->GetAllocationCallbacks())
        +
        8077 {
        +
        8078 }
        +
        8079 
        +
        8080 #if VMA_STATS_STRING_ENABLED
        +
        8081 
        +
        8082 void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
        +
        8083  VkDeviceSize unusedBytes,
        +
        8084  size_t allocationCount,
        +
        8085  size_t unusedRangeCount) const
        +
        8086 {
        +
        8087  json.BeginObject();
        +
        8088 
        +
        8089  json.WriteString("TotalBytes");
        +
        8090  json.WriteNumber(GetSize());
        +
        8091 
        +
        8092  json.WriteString("UnusedBytes");
        +
        8093  json.WriteNumber(unusedBytes);
        +
        8094 
        +
        8095  json.WriteString("Allocations");
        +
        8096  json.WriteNumber((uint64_t)allocationCount);
        +
        8097 
        +
        8098  json.WriteString("UnusedRanges");
        +
        8099  json.WriteNumber((uint64_t)unusedRangeCount);
        +
        8100 
        +
        8101  json.WriteString("Suballocations");
        +
        8102  json.BeginArray();
        +
        8103 }
        +
        8104 
        +
        8105 void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        +
        8106  VkDeviceSize offset,
        +
        8107  VmaAllocation hAllocation) const
        +
        8108 {
        +
        8109  json.BeginObject(true);
        +
        8110 
        +
        8111  json.WriteString("Offset");
        +
        8112  json.WriteNumber(offset);
        8113 
        -
        8115 // class VmaBlockMetadata_Generic
        -
        8116 
        -
        8117 VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :
        -
        8118  VmaBlockMetadata(hAllocator),
        -
        8119  m_FreeCount(0),
        -
        8120  m_SumFreeSize(0),
        -
        8121  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        -
        8122  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
        -
        8123 {
        -
        8124 }
        -
        8125 
        -
        8126 VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()
        -
        8127 {
        -
        8128 }
        -
        8129 
        -
        8130 void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
        -
        8131 {
        -
        8132  VmaBlockMetadata::Init(size);
        +
        8114  hAllocation->PrintParameters(json);
        +
        8115 
        +
        8116  json.EndObject();
        +
        8117 }
        +
        8118 
        +
        8119 void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        +
        8120  VkDeviceSize offset,
        +
        8121  VkDeviceSize size) const
        +
        8122 {
        +
        8123  json.BeginObject(true);
        +
        8124 
        +
        8125  json.WriteString("Offset");
        +
        8126  json.WriteNumber(offset);
        +
        8127 
        +
        8128  json.WriteString("Type");
        +
        8129  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
        +
        8130 
        +
        8131  json.WriteString("Size");
        +
        8132  json.WriteNumber(size);
        8133 
        -
        8134  m_FreeCount = 1;
        -
        8135  m_SumFreeSize = size;
        +
        8134  json.EndObject();
        +
        8135 }
        8136 
        -
        8137  VmaSuballocation suballoc = {};
        -
        8138  suballoc.offset = 0;
        -
        8139  suballoc.size = size;
        -
        8140  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        8141  suballoc.hAllocation = VK_NULL_HANDLE;
        +
        8137 void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
        +
        8138 {
        +
        8139  json.EndArray();
        +
        8140  json.EndObject();
        +
        8141 }
        8142 
        -
        8143  VMA_ASSERT(size > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
        -
        8144  m_Suballocations.push_back(suballoc);
        -
        8145  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
        -
        8146  --suballocItem;
        -
        8147  m_FreeSuballocationsBySize.push_back(suballocItem);
        -
        8148 }
        -
        8149 
        -
        8150 bool VmaBlockMetadata_Generic::Validate() const
        -
        8151 {
        -
        8152  VMA_VALIDATE(!m_Suballocations.empty());
        -
        8153 
        -
        8154  // Expected offset of new suballocation as calculated from previous ones.
        -
        8155  VkDeviceSize calculatedOffset = 0;
        -
        8156  // Expected number of free suballocations as calculated from traversing their list.
        -
        8157  uint32_t calculatedFreeCount = 0;
        -
        8158  // Expected sum size of free suballocations as calculated from traversing their list.
        -
        8159  VkDeviceSize calculatedSumFreeSize = 0;
        -
        8160  // Expected number of free suballocations that should be registered in
        -
        8161  // m_FreeSuballocationsBySize calculated from traversing their list.
        -
        8162  size_t freeSuballocationsToRegister = 0;
        -
        8163  // True if previous visited suballocation was free.
        -
        8164  bool prevFree = false;
        -
        8165 
        -
        8166  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        -
        8167  suballocItem != m_Suballocations.cend();
        -
        8168  ++suballocItem)
        -
        8169  {
        -
        8170  const VmaSuballocation& subAlloc = *suballocItem;
        -
        8171 
        -
        8172  // Actual offset of this suballocation doesn't match expected one.
        -
        8173  VMA_VALIDATE(subAlloc.offset == calculatedOffset);
        -
        8174 
        -
        8175  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8176  // Two adjacent free suballocations are invalid. They should be merged.
        -
        8177  VMA_VALIDATE(!prevFree || !currFree);
        -
        8178 
        -
        8179  VMA_VALIDATE(currFree == (subAlloc.hAllocation == VK_NULL_HANDLE));
        +
        8143 #endif // #if VMA_STATS_STRING_ENABLED
        +
        8144 
        +
        8146 // class VmaBlockMetadata_Generic
        +
        8147 
        +
        8148 VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :
        +
        8149  VmaBlockMetadata(hAllocator),
        +
        8150  m_FreeCount(0),
        +
        8151  m_SumFreeSize(0),
        +
        8152  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        +
        8153  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
        +
        8154 {
        +
        8155 }
        +
        8156 
        +
        8157 VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()
        +
        8158 {
        +
        8159 }
        +
        8160 
        +
        8161 void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
        +
        8162 {
        +
        8163  VmaBlockMetadata::Init(size);
        +
        8164 
        +
        8165  m_FreeCount = 1;
        +
        8166  m_SumFreeSize = size;
        +
        8167 
        +
        8168  VmaSuballocation suballoc = {};
        +
        8169  suballoc.offset = 0;
        +
        8170  suballoc.size = size;
        +
        8171  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        8172  suballoc.hAllocation = VK_NULL_HANDLE;
        +
        8173 
        +
        8174  VMA_ASSERT(size > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
        +
        8175  m_Suballocations.push_back(suballoc);
        +
        8176  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
        +
        8177  --suballocItem;
        +
        8178  m_FreeSuballocationsBySize.push_back(suballocItem);
        +
        8179 }
        8180 
        -
        8181  if(currFree)
        -
        8182  {
        -
        8183  calculatedSumFreeSize += subAlloc.size;
        -
        8184  ++calculatedFreeCount;
        -
        8185  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        -
        8186  {
        -
        8187  ++freeSuballocationsToRegister;
        -
        8188  }
        -
        8189 
        -
        8190  // Margin required between allocations - every free space must be at least that large.
        -
        8191  VMA_VALIDATE(subAlloc.size >= VMA_DEBUG_MARGIN);
        -
        8192  }
        -
        8193  else
        -
        8194  {
        -
        8195  VMA_VALIDATE(subAlloc.hAllocation->GetOffset() == subAlloc.offset);
        -
        8196  VMA_VALIDATE(subAlloc.hAllocation->GetSize() == subAlloc.size);
        -
        8197 
        -
        8198  // Margin required between allocations - previous allocation must be free.
        -
        8199  VMA_VALIDATE(VMA_DEBUG_MARGIN == 0 || prevFree);
        -
        8200  }
        -
        8201 
        -
        8202  calculatedOffset += subAlloc.size;
        -
        8203  prevFree = currFree;
        -
        8204  }
        +
        8181 bool VmaBlockMetadata_Generic::Validate() const
        +
        8182 {
        +
        8183  VMA_VALIDATE(!m_Suballocations.empty());
        +
        8184 
        +
        8185  // Expected offset of new suballocation as calculated from previous ones.
        +
        8186  VkDeviceSize calculatedOffset = 0;
        +
        8187  // Expected number of free suballocations as calculated from traversing their list.
        +
        8188  uint32_t calculatedFreeCount = 0;
        +
        8189  // Expected sum size of free suballocations as calculated from traversing their list.
        +
        8190  VkDeviceSize calculatedSumFreeSize = 0;
        +
        8191  // Expected number of free suballocations that should be registered in
        +
        8192  // m_FreeSuballocationsBySize calculated from traversing their list.
        +
        8193  size_t freeSuballocationsToRegister = 0;
        +
        8194  // True if previous visited suballocation was free.
        +
        8195  bool prevFree = false;
        +
        8196 
        +
        8197  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        +
        8198  suballocItem != m_Suballocations.cend();
        +
        8199  ++suballocItem)
        +
        8200  {
        +
        8201  const VmaSuballocation& subAlloc = *suballocItem;
        +
        8202 
        +
        8203  // Actual offset of this suballocation doesn't match expected one.
        +
        8204  VMA_VALIDATE(subAlloc.offset == calculatedOffset);
        8205 
        -
        8206  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
        -
        8207  // match expected one.
        -
        8208  VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
        +
        8206  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8207  // Two adjacent free suballocations are invalid. They should be merged.
        +
        8208  VMA_VALIDATE(!prevFree || !currFree);
        8209 
        -
        8210  VkDeviceSize lastSize = 0;
        -
        8211  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
        -
        8212  {
        -
        8213  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
        -
        8214 
        -
        8215  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
        -
        8216  VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8217  // They must be sorted by size ascending.
        -
        8218  VMA_VALIDATE(suballocItem->size >= lastSize);
        -
        8219 
        -
        8220  lastSize = suballocItem->size;
        -
        8221  }
        -
        8222 
        -
        8223  // Check if totals match calculacted values.
        -
        8224  VMA_VALIDATE(ValidateFreeSuballocationList());
        -
        8225  VMA_VALIDATE(calculatedOffset == GetSize());
        -
        8226  VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
        -
        8227  VMA_VALIDATE(calculatedFreeCount == m_FreeCount);
        +
        8210  VMA_VALIDATE(currFree == (subAlloc.hAllocation == VK_NULL_HANDLE));
        +
        8211 
        +
        8212  if(currFree)
        +
        8213  {
        +
        8214  calculatedSumFreeSize += subAlloc.size;
        +
        8215  ++calculatedFreeCount;
        +
        8216  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        8217  {
        +
        8218  ++freeSuballocationsToRegister;
        +
        8219  }
        +
        8220 
        +
        8221  // Margin required between allocations - every free space must be at least that large.
        +
        8222  VMA_VALIDATE(subAlloc.size >= VMA_DEBUG_MARGIN);
        +
        8223  }
        +
        8224  else
        +
        8225  {
        +
        8226  VMA_VALIDATE(subAlloc.hAllocation->GetOffset() == subAlloc.offset);
        +
        8227  VMA_VALIDATE(subAlloc.hAllocation->GetSize() == subAlloc.size);
        8228 
        -
        8229  return true;
        -
        8230 }
        -
        8231 
        -
        8232 VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const
        -
        8233 {
        -
        8234  if(!m_FreeSuballocationsBySize.empty())
        -
        8235  {
        -
        8236  return m_FreeSuballocationsBySize.back()->size;
        -
        8237  }
        -
        8238  else
        -
        8239  {
        -
        8240  return 0;
        -
        8241  }
        -
        8242 }
        -
        8243 
        -
        8244 bool VmaBlockMetadata_Generic::IsEmpty() const
        -
        8245 {
        -
        8246  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
        -
        8247 }
        -
        8248 
        -
        8249 void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        -
        8250 {
        -
        8251  outInfo.blockCount = 1;
        -
        8252 
        -
        8253  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        -
        8254  outInfo.allocationCount = rangeCount - m_FreeCount;
        -
        8255  outInfo.unusedRangeCount = m_FreeCount;
        -
        8256 
        -
        8257  outInfo.unusedBytes = m_SumFreeSize;
        -
        8258  outInfo.usedBytes = GetSize() - outInfo.unusedBytes;
        +
        8229  // Margin required between allocations - previous allocation must be free.
        +
        8230  VMA_VALIDATE(VMA_DEBUG_MARGIN == 0 || prevFree);
        +
        8231  }
        +
        8232 
        +
        8233  calculatedOffset += subAlloc.size;
        +
        8234  prevFree = currFree;
        +
        8235  }
        +
        8236 
        +
        8237  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
        +
        8238  // match expected one.
        +
        8239  VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
        +
        8240 
        +
        8241  VkDeviceSize lastSize = 0;
        +
        8242  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
        +
        8243  {
        +
        8244  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
        +
        8245 
        +
        8246  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
        +
        8247  VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8248  // They must be sorted by size ascending.
        +
        8249  VMA_VALIDATE(suballocItem->size >= lastSize);
        +
        8250 
        +
        8251  lastSize = suballocItem->size;
        +
        8252  }
        +
        8253 
        +
        8254  // Check if totals match calculacted values.
        +
        8255  VMA_VALIDATE(ValidateFreeSuballocationList());
        +
        8256  VMA_VALIDATE(calculatedOffset == GetSize());
        +
        8257  VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
        +
        8258  VMA_VALIDATE(calculatedFreeCount == m_FreeCount);
        8259 
        -
        8260  outInfo.allocationSizeMin = UINT64_MAX;
        -
        8261  outInfo.allocationSizeMax = 0;
        -
        8262  outInfo.unusedRangeSizeMin = UINT64_MAX;
        -
        8263  outInfo.unusedRangeSizeMax = 0;
        -
        8264 
        -
        8265  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        -
        8266  suballocItem != m_Suballocations.cend();
        -
        8267  ++suballocItem)
        -
        8268  {
        -
        8269  const VmaSuballocation& suballoc = *suballocItem;
        -
        8270  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        -
        8271  {
        -
        8272  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        -
        8273  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
        -
        8274  }
        -
        8275  else
        -
        8276  {
        -
        8277  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
        -
        8278  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
        -
        8279  }
        -
        8280  }
        -
        8281 }
        -
        8282 
        -
        8283 void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const
        -
        8284 {
        -
        8285  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        -
        8286 
        -
        8287  inoutStats.size += GetSize();
        -
        8288  inoutStats.unusedSize += m_SumFreeSize;
        -
        8289  inoutStats.allocationCount += rangeCount - m_FreeCount;
        -
        8290  inoutStats.unusedRangeCount += m_FreeCount;
        -
        8291  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
        -
        8292 }
        -
        8293 
        -
        8294 #if VMA_STATS_STRING_ENABLED
        +
        8260  return true;
        +
        8261 }
        +
        8262 
        +
        8263 VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const
        +
        8264 {
        +
        8265  if(!m_FreeSuballocationsBySize.empty())
        +
        8266  {
        +
        8267  return m_FreeSuballocationsBySize.back()->size;
        +
        8268  }
        +
        8269  else
        +
        8270  {
        +
        8271  return 0;
        +
        8272  }
        +
        8273 }
        +
        8274 
        +
        8275 bool VmaBlockMetadata_Generic::IsEmpty() const
        +
        8276 {
        +
        8277  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
        +
        8278 }
        +
        8279 
        +
        8280 void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        +
        8281 {
        +
        8282  outInfo.blockCount = 1;
        +
        8283 
        +
        8284  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        +
        8285  outInfo.allocationCount = rangeCount - m_FreeCount;
        +
        8286  outInfo.unusedRangeCount = m_FreeCount;
        +
        8287 
        +
        8288  outInfo.unusedBytes = m_SumFreeSize;
        +
        8289  outInfo.usedBytes = GetSize() - outInfo.unusedBytes;
        +
        8290 
        +
        8291  outInfo.allocationSizeMin = UINT64_MAX;
        +
        8292  outInfo.allocationSizeMax = 0;
        +
        8293  outInfo.unusedRangeSizeMin = UINT64_MAX;
        +
        8294  outInfo.unusedRangeSizeMax = 0;
        8295 
        -
        8296 void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const
        -
        8297 {
        -
        8298  PrintDetailedMap_Begin(json,
        -
        8299  m_SumFreeSize, // unusedBytes
        -
        8300  m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
        -
        8301  m_FreeCount); // unusedRangeCount
        -
        8302 
        -
        8303  size_t i = 0;
        -
        8304  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        -
        8305  suballocItem != m_Suballocations.cend();
        -
        8306  ++suballocItem, ++i)
        -
        8307  {
        -
        8308  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        -
        8309  {
        -
        8310  PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);
        -
        8311  }
        -
        8312  else
        -
        8313  {
        -
        8314  PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);
        -
        8315  }
        -
        8316  }
        +
        8296  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        +
        8297  suballocItem != m_Suballocations.cend();
        +
        8298  ++suballocItem)
        +
        8299  {
        +
        8300  const VmaSuballocation& suballoc = *suballocItem;
        +
        8301  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        +
        8302  {
        +
        8303  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        +
        8304  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
        +
        8305  }
        +
        8306  else
        +
        8307  {
        +
        8308  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
        +
        8309  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
        +
        8310  }
        +
        8311  }
        +
        8312 }
        +
        8313 
        +
        8314 void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const
        +
        8315 {
        +
        8316  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        8317 
        -
        8318  PrintDetailedMap_End(json);
        -
        8319 }
        -
        8320 
        -
        8321 #endif // #if VMA_STATS_STRING_ENABLED
        -
        8322 
        -
        8323 bool VmaBlockMetadata_Generic::CreateAllocationRequest(
        -
        8324  uint32_t currentFrameIndex,
        -
        8325  uint32_t frameInUseCount,
        -
        8326  VkDeviceSize bufferImageGranularity,
        -
        8327  VkDeviceSize allocSize,
        -
        8328  VkDeviceSize allocAlignment,
        -
        8329  bool upperAddress,
        -
        8330  VmaSuballocationType allocType,
        -
        8331  bool canMakeOtherLost,
        -
        8332  uint32_t strategy,
        -
        8333  VmaAllocationRequest* pAllocationRequest)
        -
        8334 {
        -
        8335  VMA_ASSERT(allocSize > 0);
        -
        8336  VMA_ASSERT(!upperAddress);
        -
        8337  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        -
        8338  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        -
        8339  VMA_HEAVY_ASSERT(Validate());
        -
        8340 
        -
        8341  pAllocationRequest->type = VmaAllocationRequestType::Normal;
        -
        8342 
        -
        8343  // There is not enough total free space in this block to fullfill the request: Early return.
        -
        8344  if(canMakeOtherLost == false &&
        -
        8345  m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
        -
        8346  {
        -
        8347  return false;
        -
        8348  }
        -
        8349 
        -
        8350  // New algorithm, efficiently searching freeSuballocationsBySize.
        -
        8351  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
        -
        8352  if(freeSuballocCount > 0)
        -
        8353  {
        -
        8354  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
        -
        8355  {
        -
        8356  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
        -
        8357  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        -
        8358  m_FreeSuballocationsBySize.data(),
        -
        8359  m_FreeSuballocationsBySize.data() + freeSuballocCount,
        -
        8360  allocSize + 2 * VMA_DEBUG_MARGIN,
        -
        8361  VmaSuballocationItemSizeLess());
        -
        8362  size_t index = it - m_FreeSuballocationsBySize.data();
        -
        8363  for(; index < freeSuballocCount; ++index)
        -
        8364  {
        -
        8365  if(CheckAllocation(
        -
        8366  currentFrameIndex,
        -
        8367  frameInUseCount,
        -
        8368  bufferImageGranularity,
        -
        8369  allocSize,
        -
        8370  allocAlignment,
        -
        8371  allocType,
        -
        8372  m_FreeSuballocationsBySize[index],
        -
        8373  false, // canMakeOtherLost
        -
        8374  &pAllocationRequest->offset,
        -
        8375  &pAllocationRequest->itemsToMakeLostCount,
        -
        8376  &pAllocationRequest->sumFreeSize,
        -
        8377  &pAllocationRequest->sumItemSize))
        -
        8378  {
        -
        8379  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        -
        8380  return true;
        -
        8381  }
        -
        8382  }
        -
        8383  }
        -
        8384  else if(strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
        -
        8385  {
        -
        8386  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        -
        8387  it != m_Suballocations.end();
        -
        8388  ++it)
        -
        8389  {
        -
        8390  if(it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
        -
        8391  currentFrameIndex,
        -
        8392  frameInUseCount,
        -
        8393  bufferImageGranularity,
        -
        8394  allocSize,
        -
        8395  allocAlignment,
        -
        8396  allocType,
        -
        8397  it,
        -
        8398  false, // canMakeOtherLost
        -
        8399  &pAllocationRequest->offset,
        -
        8400  &pAllocationRequest->itemsToMakeLostCount,
        -
        8401  &pAllocationRequest->sumFreeSize,
        -
        8402  &pAllocationRequest->sumItemSize))
        -
        8403  {
        -
        8404  pAllocationRequest->item = it;
        -
        8405  return true;
        -
        8406  }
        -
        8407  }
        -
        8408  }
        -
        8409  else // WORST_FIT, FIRST_FIT
        -
        8410  {
        -
        8411  // Search staring from biggest suballocations.
        -
        8412  for(size_t index = freeSuballocCount; index--; )
        -
        8413  {
        -
        8414  if(CheckAllocation(
        -
        8415  currentFrameIndex,
        -
        8416  frameInUseCount,
        -
        8417  bufferImageGranularity,
        -
        8418  allocSize,
        -
        8419  allocAlignment,
        -
        8420  allocType,
        -
        8421  m_FreeSuballocationsBySize[index],
        -
        8422  false, // canMakeOtherLost
        -
        8423  &pAllocationRequest->offset,
        -
        8424  &pAllocationRequest->itemsToMakeLostCount,
        -
        8425  &pAllocationRequest->sumFreeSize,
        -
        8426  &pAllocationRequest->sumItemSize))
        -
        8427  {
        -
        8428  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        -
        8429  return true;
        -
        8430  }
        -
        8431  }
        -
        8432  }
        -
        8433  }
        -
        8434 
        -
        8435  if(canMakeOtherLost)
        -
        8436  {
        -
        8437  // Brute-force algorithm. TODO: Come up with something better.
        -
        8438 
        -
        8439  bool found = false;
        -
        8440  VmaAllocationRequest tmpAllocRequest = {};
        -
        8441  tmpAllocRequest.type = VmaAllocationRequestType::Normal;
        -
        8442  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
        -
        8443  suballocIt != m_Suballocations.end();
        -
        8444  ++suballocIt)
        -
        8445  {
        -
        8446  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
        -
        8447  suballocIt->hAllocation->CanBecomeLost())
        -
        8448  {
        -
        8449  if(CheckAllocation(
        -
        8450  currentFrameIndex,
        -
        8451  frameInUseCount,
        -
        8452  bufferImageGranularity,
        -
        8453  allocSize,
        -
        8454  allocAlignment,
        -
        8455  allocType,
        -
        8456  suballocIt,
        -
        8457  canMakeOtherLost,
        -
        8458  &tmpAllocRequest.offset,
        -
        8459  &tmpAllocRequest.itemsToMakeLostCount,
        -
        8460  &tmpAllocRequest.sumFreeSize,
        -
        8461  &tmpAllocRequest.sumItemSize))
        -
        8462  {
        -
        8463  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
        -
        8464  {
        -
        8465  *pAllocationRequest = tmpAllocRequest;
        -
        8466  pAllocationRequest->item = suballocIt;
        -
        8467  break;
        -
        8468  }
        -
        8469  if(!found || tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
        -
        8470  {
        -
        8471  *pAllocationRequest = tmpAllocRequest;
        -
        8472  pAllocationRequest->item = suballocIt;
        -
        8473  found = true;
        -
        8474  }
        -
        8475  }
        -
        8476  }
        -
        8477  }
        -
        8478 
        -
        8479  return found;
        -
        8480  }
        -
        8481 
        -
        8482  return false;
        -
        8483 }
        -
        8484 
        -
        8485 bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(
        -
        8486  uint32_t currentFrameIndex,
        -
        8487  uint32_t frameInUseCount,
        -
        8488  VmaAllocationRequest* pAllocationRequest)
        -
        8489 {
        -
        8490  VMA_ASSERT(pAllocationRequest && pAllocationRequest->type == VmaAllocationRequestType::Normal);
        -
        8491 
        -
        8492  while(pAllocationRequest->itemsToMakeLostCount > 0)
        -
        8493  {
        -
        8494  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
        -
        8495  {
        -
        8496  ++pAllocationRequest->item;
        -
        8497  }
        -
        8498  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        -
        8499  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
        -
        8500  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
        -
        8501  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        -
        8502  {
        -
        8503  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
        -
        8504  --pAllocationRequest->itemsToMakeLostCount;
        -
        8505  }
        -
        8506  else
        -
        8507  {
        -
        8508  return false;
        -
        8509  }
        -
        8510  }
        -
        8511 
        -
        8512  VMA_HEAVY_ASSERT(Validate());
        -
        8513  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        -
        8514  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8515 
        -
        8516  return true;
        -
        8517 }
        -
        8518 
        -
        8519 uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        +
        8318  inoutStats.size += GetSize();
        +
        8319  inoutStats.unusedSize += m_SumFreeSize;
        +
        8320  inoutStats.allocationCount += rangeCount - m_FreeCount;
        +
        8321  inoutStats.unusedRangeCount += m_FreeCount;
        +
        8322  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
        +
        8323 }
        +
        8324 
        +
        8325 #if VMA_STATS_STRING_ENABLED
        +
        8326 
        +
        8327 void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const
        +
        8328 {
        +
        8329  PrintDetailedMap_Begin(json,
        +
        8330  m_SumFreeSize, // unusedBytes
        +
        8331  m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
        +
        8332  m_FreeCount); // unusedRangeCount
        +
        8333 
        +
        8334  size_t i = 0;
        +
        8335  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        +
        8336  suballocItem != m_Suballocations.cend();
        +
        8337  ++suballocItem, ++i)
        +
        8338  {
        +
        8339  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        +
        8340  {
        +
        8341  PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);
        +
        8342  }
        +
        8343  else
        +
        8344  {
        +
        8345  PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);
        +
        8346  }
        +
        8347  }
        +
        8348 
        +
        8349  PrintDetailedMap_End(json);
        +
        8350 }
        +
        8351 
        +
        8352 #endif // #if VMA_STATS_STRING_ENABLED
        +
        8353 
        +
        8354 bool VmaBlockMetadata_Generic::CreateAllocationRequest(
        +
        8355  uint32_t currentFrameIndex,
        +
        8356  uint32_t frameInUseCount,
        +
        8357  VkDeviceSize bufferImageGranularity,
        +
        8358  VkDeviceSize allocSize,
        +
        8359  VkDeviceSize allocAlignment,
        +
        8360  bool upperAddress,
        +
        8361  VmaSuballocationType allocType,
        +
        8362  bool canMakeOtherLost,
        +
        8363  uint32_t strategy,
        +
        8364  VmaAllocationRequest* pAllocationRequest)
        +
        8365 {
        +
        8366  VMA_ASSERT(allocSize > 0);
        +
        8367  VMA_ASSERT(!upperAddress);
        +
        8368  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        +
        8369  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        +
        8370  VMA_HEAVY_ASSERT(Validate());
        +
        8371 
        +
        8372  pAllocationRequest->type = VmaAllocationRequestType::Normal;
        +
        8373 
        +
        8374  // There is not enough total free space in this block to fullfill the request: Early return.
        +
        8375  if(canMakeOtherLost == false &&
        +
        8376  m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
        +
        8377  {
        +
        8378  return false;
        +
        8379  }
        +
        8380 
        +
        8381  // New algorithm, efficiently searching freeSuballocationsBySize.
        +
        8382  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
        +
        8383  if(freeSuballocCount > 0)
        +
        8384  {
        +
        8385  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
        +
        8386  {
        +
        8387  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
        +
        8388  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        +
        8389  m_FreeSuballocationsBySize.data(),
        +
        8390  m_FreeSuballocationsBySize.data() + freeSuballocCount,
        +
        8391  allocSize + 2 * VMA_DEBUG_MARGIN,
        +
        8392  VmaSuballocationItemSizeLess());
        +
        8393  size_t index = it - m_FreeSuballocationsBySize.data();
        +
        8394  for(; index < freeSuballocCount; ++index)
        +
        8395  {
        +
        8396  if(CheckAllocation(
        +
        8397  currentFrameIndex,
        +
        8398  frameInUseCount,
        +
        8399  bufferImageGranularity,
        +
        8400  allocSize,
        +
        8401  allocAlignment,
        +
        8402  allocType,
        +
        8403  m_FreeSuballocationsBySize[index],
        +
        8404  false, // canMakeOtherLost
        +
        8405  &pAllocationRequest->offset,
        +
        8406  &pAllocationRequest->itemsToMakeLostCount,
        +
        8407  &pAllocationRequest->sumFreeSize,
        +
        8408  &pAllocationRequest->sumItemSize))
        +
        8409  {
        +
        8410  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        +
        8411  return true;
        +
        8412  }
        +
        8413  }
        +
        8414  }
        +
        8415  else if(strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
        +
        8416  {
        +
        8417  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        +
        8418  it != m_Suballocations.end();
        +
        8419  ++it)
        +
        8420  {
        +
        8421  if(it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
        +
        8422  currentFrameIndex,
        +
        8423  frameInUseCount,
        +
        8424  bufferImageGranularity,
        +
        8425  allocSize,
        +
        8426  allocAlignment,
        +
        8427  allocType,
        +
        8428  it,
        +
        8429  false, // canMakeOtherLost
        +
        8430  &pAllocationRequest->offset,
        +
        8431  &pAllocationRequest->itemsToMakeLostCount,
        +
        8432  &pAllocationRequest->sumFreeSize,
        +
        8433  &pAllocationRequest->sumItemSize))
        +
        8434  {
        +
        8435  pAllocationRequest->item = it;
        +
        8436  return true;
        +
        8437  }
        +
        8438  }
        +
        8439  }
        +
        8440  else // WORST_FIT, FIRST_FIT
        +
        8441  {
        +
        8442  // Search staring from biggest suballocations.
        +
        8443  for(size_t index = freeSuballocCount; index--; )
        +
        8444  {
        +
        8445  if(CheckAllocation(
        +
        8446  currentFrameIndex,
        +
        8447  frameInUseCount,
        +
        8448  bufferImageGranularity,
        +
        8449  allocSize,
        +
        8450  allocAlignment,
        +
        8451  allocType,
        +
        8452  m_FreeSuballocationsBySize[index],
        +
        8453  false, // canMakeOtherLost
        +
        8454  &pAllocationRequest->offset,
        +
        8455  &pAllocationRequest->itemsToMakeLostCount,
        +
        8456  &pAllocationRequest->sumFreeSize,
        +
        8457  &pAllocationRequest->sumItemSize))
        +
        8458  {
        +
        8459  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        +
        8460  return true;
        +
        8461  }
        +
        8462  }
        +
        8463  }
        +
        8464  }
        +
        8465 
        +
        8466  if(canMakeOtherLost)
        +
        8467  {
        +
        8468  // Brute-force algorithm. TODO: Come up with something better.
        +
        8469 
        +
        8470  bool found = false;
        +
        8471  VmaAllocationRequest tmpAllocRequest = {};
        +
        8472  tmpAllocRequest.type = VmaAllocationRequestType::Normal;
        +
        8473  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
        +
        8474  suballocIt != m_Suballocations.end();
        +
        8475  ++suballocIt)
        +
        8476  {
        +
        8477  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
        +
        8478  suballocIt->hAllocation->CanBecomeLost())
        +
        8479  {
        +
        8480  if(CheckAllocation(
        +
        8481  currentFrameIndex,
        +
        8482  frameInUseCount,
        +
        8483  bufferImageGranularity,
        +
        8484  allocSize,
        +
        8485  allocAlignment,
        +
        8486  allocType,
        +
        8487  suballocIt,
        +
        8488  canMakeOtherLost,
        +
        8489  &tmpAllocRequest.offset,
        +
        8490  &tmpAllocRequest.itemsToMakeLostCount,
        +
        8491  &tmpAllocRequest.sumFreeSize,
        +
        8492  &tmpAllocRequest.sumItemSize))
        +
        8493  {
        +
        8494  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
        +
        8495  {
        +
        8496  *pAllocationRequest = tmpAllocRequest;
        +
        8497  pAllocationRequest->item = suballocIt;
        +
        8498  break;
        +
        8499  }
        +
        8500  if(!found || tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
        +
        8501  {
        +
        8502  *pAllocationRequest = tmpAllocRequest;
        +
        8503  pAllocationRequest->item = suballocIt;
        +
        8504  found = true;
        +
        8505  }
        +
        8506  }
        +
        8507  }
        +
        8508  }
        +
        8509 
        +
        8510  return found;
        +
        8511  }
        +
        8512 
        +
        8513  return false;
        +
        8514 }
        +
        8515 
        +
        8516 bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(
        +
        8517  uint32_t currentFrameIndex,
        +
        8518  uint32_t frameInUseCount,
        +
        8519  VmaAllocationRequest* pAllocationRequest)
        8520 {
        -
        8521  uint32_t lostAllocationCount = 0;
        -
        8522  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        -
        8523  it != m_Suballocations.end();
        -
        8524  ++it)
        -
        8525  {
        -
        8526  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
        -
        8527  it->hAllocation->CanBecomeLost() &&
        -
        8528  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        -
        8529  {
        -
        8530  it = FreeSuballocation(it);
        -
        8531  ++lostAllocationCount;
        -
        8532  }
        -
        8533  }
        -
        8534  return lostAllocationCount;
        -
        8535 }
        -
        8536 
        -
        8537 VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
        -
        8538 {
        -
        8539  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        -
        8540  it != m_Suballocations.end();
        -
        8541  ++it)
        -
        8542  {
        -
        8543  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        -
        8544  {
        -
        8545  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
        -
        8546  {
        -
        8547  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        -
        8548  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        8549  }
        -
        8550  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
        -
        8551  {
        -
        8552  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        -
        8553  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        8554  }
        -
        8555  }
        -
        8556  }
        -
        8557 
        -
        8558  return VK_SUCCESS;
        -
        8559 }
        -
        8560 
        -
        8561 void VmaBlockMetadata_Generic::Alloc(
        -
        8562  const VmaAllocationRequest& request,
        -
        8563  VmaSuballocationType type,
        -
        8564  VkDeviceSize allocSize,
        -
        8565  VmaAllocation hAllocation)
        -
        8566 {
        -
        8567  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
        -
        8568  VMA_ASSERT(request.item != m_Suballocations.end());
        -
        8569  VmaSuballocation& suballoc = *request.item;
        -
        8570  // Given suballocation is a free block.
        -
        8571  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8572  // Given offset is inside this suballocation.
        -
        8573  VMA_ASSERT(request.offset >= suballoc.offset);
        -
        8574  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
        -
        8575  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
        -
        8576  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
        -
        8577 
        -
        8578  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
        -
        8579  // it to become used.
        -
        8580  UnregisterFreeSuballocation(request.item);
        -
        8581 
        -
        8582  suballoc.offset = request.offset;
        -
        8583  suballoc.size = allocSize;
        -
        8584  suballoc.type = type;
        -
        8585  suballoc.hAllocation = hAllocation;
        -
        8586 
        -
        8587  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
        -
        8588  if(paddingEnd)
        -
        8589  {
        -
        8590  VmaSuballocation paddingSuballoc = {};
        -
        8591  paddingSuballoc.offset = request.offset + allocSize;
        -
        8592  paddingSuballoc.size = paddingEnd;
        -
        8593  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        8594  VmaSuballocationList::iterator next = request.item;
        -
        8595  ++next;
        -
        8596  const VmaSuballocationList::iterator paddingEndItem =
        -
        8597  m_Suballocations.insert(next, paddingSuballoc);
        -
        8598  RegisterFreeSuballocation(paddingEndItem);
        -
        8599  }
        -
        8600 
        -
        8601  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
        -
        8602  if(paddingBegin)
        -
        8603  {
        -
        8604  VmaSuballocation paddingSuballoc = {};
        -
        8605  paddingSuballoc.offset = request.offset - paddingBegin;
        -
        8606  paddingSuballoc.size = paddingBegin;
        -
        8607  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        8608  const VmaSuballocationList::iterator paddingBeginItem =
        -
        8609  m_Suballocations.insert(request.item, paddingSuballoc);
        -
        8610  RegisterFreeSuballocation(paddingBeginItem);
        -
        8611  }
        +
        8521  VMA_ASSERT(pAllocationRequest && pAllocationRequest->type == VmaAllocationRequestType::Normal);
        +
        8522 
        +
        8523  while(pAllocationRequest->itemsToMakeLostCount > 0)
        +
        8524  {
        +
        8525  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
        +
        8526  {
        +
        8527  ++pAllocationRequest->item;
        +
        8528  }
        +
        8529  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        +
        8530  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
        +
        8531  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
        +
        8532  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        +
        8533  {
        +
        8534  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
        +
        8535  --pAllocationRequest->itemsToMakeLostCount;
        +
        8536  }
        +
        8537  else
        +
        8538  {
        +
        8539  return false;
        +
        8540  }
        +
        8541  }
        +
        8542 
        +
        8543  VMA_HEAVY_ASSERT(Validate());
        +
        8544  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        +
        8545  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8546 
        +
        8547  return true;
        +
        8548 }
        +
        8549 
        +
        8550 uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        +
        8551 {
        +
        8552  uint32_t lostAllocationCount = 0;
        +
        8553  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        +
        8554  it != m_Suballocations.end();
        +
        8555  ++it)
        +
        8556  {
        +
        8557  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
        +
        8558  it->hAllocation->CanBecomeLost() &&
        +
        8559  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        +
        8560  {
        +
        8561  it = FreeSuballocation(it);
        +
        8562  ++lostAllocationCount;
        +
        8563  }
        +
        8564  }
        +
        8565  return lostAllocationCount;
        +
        8566 }
        +
        8567 
        +
        8568 VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
        +
        8569 {
        +
        8570  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        +
        8571  it != m_Suballocations.end();
        +
        8572  ++it)
        +
        8573  {
        +
        8574  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        +
        8575  {
        +
        8576  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
        +
        8577  {
        +
        8578  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        +
        8579  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        8580  }
        +
        8581  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
        +
        8582  {
        +
        8583  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        +
        8584  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        8585  }
        +
        8586  }
        +
        8587  }
        +
        8588 
        +
        8589  return VK_SUCCESS;
        +
        8590 }
        +
        8591 
        +
        8592 void VmaBlockMetadata_Generic::Alloc(
        +
        8593  const VmaAllocationRequest& request,
        +
        8594  VmaSuballocationType type,
        +
        8595  VkDeviceSize allocSize,
        +
        8596  VmaAllocation hAllocation)
        +
        8597 {
        +
        8598  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
        +
        8599  VMA_ASSERT(request.item != m_Suballocations.end());
        +
        8600  VmaSuballocation& suballoc = *request.item;
        +
        8601  // Given suballocation is a free block.
        +
        8602  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8603  // Given offset is inside this suballocation.
        +
        8604  VMA_ASSERT(request.offset >= suballoc.offset);
        +
        8605  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
        +
        8606  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
        +
        8607  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
        +
        8608 
        +
        8609  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
        +
        8610  // it to become used.
        +
        8611  UnregisterFreeSuballocation(request.item);
        8612 
        -
        8613  // Update totals.
        -
        8614  m_FreeCount = m_FreeCount - 1;
        -
        8615  if(paddingBegin > 0)
        -
        8616  {
        -
        8617  ++m_FreeCount;
        -
        8618  }
        -
        8619  if(paddingEnd > 0)
        +
        8613  suballoc.offset = request.offset;
        +
        8614  suballoc.size = allocSize;
        +
        8615  suballoc.type = type;
        +
        8616  suballoc.hAllocation = hAllocation;
        +
        8617 
        +
        8618  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
        +
        8619  if(paddingEnd)
        8620  {
        -
        8621  ++m_FreeCount;
        -
        8622  }
        -
        8623  m_SumFreeSize -= allocSize;
        -
        8624 }
        -
        8625 
        -
        8626 void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)
        -
        8627 {
        -
        8628  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        -
        8629  suballocItem != m_Suballocations.end();
        -
        8630  ++suballocItem)
        -
        8631  {
        -
        8632  VmaSuballocation& suballoc = *suballocItem;
        -
        8633  if(suballoc.hAllocation == allocation)
        -
        8634  {
        -
        8635  FreeSuballocation(suballocItem);
        -
        8636  VMA_HEAVY_ASSERT(Validate());
        -
        8637  return;
        -
        8638  }
        -
        8639  }
        -
        8640  VMA_ASSERT(0 && "Not found!");
        -
        8641 }
        -
        8642 
        -
        8643 void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)
        -
        8644 {
        -
        8645  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        -
        8646  suballocItem != m_Suballocations.end();
        -
        8647  ++suballocItem)
        -
        8648  {
        -
        8649  VmaSuballocation& suballoc = *suballocItem;
        -
        8650  if(suballoc.offset == offset)
        -
        8651  {
        -
        8652  FreeSuballocation(suballocItem);
        -
        8653  return;
        -
        8654  }
        -
        8655  }
        -
        8656  VMA_ASSERT(0 && "Not found!");
        -
        8657 }
        -
        8658 
        -
        8659 bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
        -
        8660 {
        -
        8661  VkDeviceSize lastSize = 0;
        -
        8662  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
        -
        8663  {
        -
        8664  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
        -
        8665 
        -
        8666  VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8667  VMA_VALIDATE(it->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
        -
        8668  VMA_VALIDATE(it->size >= lastSize);
        -
        8669  lastSize = it->size;
        +
        8621  VmaSuballocation paddingSuballoc = {};
        +
        8622  paddingSuballoc.offset = request.offset + allocSize;
        +
        8623  paddingSuballoc.size = paddingEnd;
        +
        8624  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        8625  VmaSuballocationList::iterator next = request.item;
        +
        8626  ++next;
        +
        8627  const VmaSuballocationList::iterator paddingEndItem =
        +
        8628  m_Suballocations.insert(next, paddingSuballoc);
        +
        8629  RegisterFreeSuballocation(paddingEndItem);
        +
        8630  }
        +
        8631 
        +
        8632  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
        +
        8633  if(paddingBegin)
        +
        8634  {
        +
        8635  VmaSuballocation paddingSuballoc = {};
        +
        8636  paddingSuballoc.offset = request.offset - paddingBegin;
        +
        8637  paddingSuballoc.size = paddingBegin;
        +
        8638  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        8639  const VmaSuballocationList::iterator paddingBeginItem =
        +
        8640  m_Suballocations.insert(request.item, paddingSuballoc);
        +
        8641  RegisterFreeSuballocation(paddingBeginItem);
        +
        8642  }
        +
        8643 
        +
        8644  // Update totals.
        +
        8645  m_FreeCount = m_FreeCount - 1;
        +
        8646  if(paddingBegin > 0)
        +
        8647  {
        +
        8648  ++m_FreeCount;
        +
        8649  }
        +
        8650  if(paddingEnd > 0)
        +
        8651  {
        +
        8652  ++m_FreeCount;
        +
        8653  }
        +
        8654  m_SumFreeSize -= allocSize;
        +
        8655 }
        +
        8656 
        +
        8657 void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)
        +
        8658 {
        +
        8659  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        +
        8660  suballocItem != m_Suballocations.end();
        +
        8661  ++suballocItem)
        +
        8662  {
        +
        8663  VmaSuballocation& suballoc = *suballocItem;
        +
        8664  if(suballoc.hAllocation == allocation)
        +
        8665  {
        +
        8666  FreeSuballocation(suballocItem);
        +
        8667  VMA_HEAVY_ASSERT(Validate());
        +
        8668  return;
        +
        8669  }
        8670  }
        -
        8671  return true;
        +
        8671  VMA_ASSERT(0 && "Not found!");
        8672 }
        8673 
        -
        8674 bool VmaBlockMetadata_Generic::CheckAllocation(
        -
        8675  uint32_t currentFrameIndex,
        -
        8676  uint32_t frameInUseCount,
        -
        8677  VkDeviceSize bufferImageGranularity,
        -
        8678  VkDeviceSize allocSize,
        -
        8679  VkDeviceSize allocAlignment,
        -
        8680  VmaSuballocationType allocType,
        -
        8681  VmaSuballocationList::const_iterator suballocItem,
        -
        8682  bool canMakeOtherLost,
        -
        8683  VkDeviceSize* pOffset,
        -
        8684  size_t* itemsToMakeLostCount,
        -
        8685  VkDeviceSize* pSumFreeSize,
        -
        8686  VkDeviceSize* pSumItemSize) const
        -
        8687 {
        -
        8688  VMA_ASSERT(allocSize > 0);
        -
        8689  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        -
        8690  VMA_ASSERT(suballocItem != m_Suballocations.cend());
        -
        8691  VMA_ASSERT(pOffset != VMA_NULL);
        -
        8692 
        -
        8693  *itemsToMakeLostCount = 0;
        -
        8694  *pSumFreeSize = 0;
        -
        8695  *pSumItemSize = 0;
        +
        8674 void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)
        +
        8675 {
        +
        8676  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        +
        8677  suballocItem != m_Suballocations.end();
        +
        8678  ++suballocItem)
        +
        8679  {
        +
        8680  VmaSuballocation& suballoc = *suballocItem;
        +
        8681  if(suballoc.offset == offset)
        +
        8682  {
        +
        8683  FreeSuballocation(suballocItem);
        +
        8684  return;
        +
        8685  }
        +
        8686  }
        +
        8687  VMA_ASSERT(0 && "Not found!");
        +
        8688 }
        +
        8689 
        +
        8690 bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
        +
        8691 {
        +
        8692  VkDeviceSize lastSize = 0;
        +
        8693  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
        +
        8694  {
        +
        8695  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
        8696 
        -
        8697  if(canMakeOtherLost)
        -
        8698  {
        -
        8699  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        -
        8700  {
        -
        8701  *pSumFreeSize = suballocItem->size;
        -
        8702  }
        -
        8703  else
        -
        8704  {
        -
        8705  if(suballocItem->hAllocation->CanBecomeLost() &&
        -
        8706  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        -
        8707  {
        -
        8708  ++*itemsToMakeLostCount;
        -
        8709  *pSumItemSize = suballocItem->size;
        -
        8710  }
        -
        8711  else
        -
        8712  {
        -
        8713  return false;
        -
        8714  }
        -
        8715  }
        -
        8716 
        -
        8717  // Remaining size is too small for this request: Early return.
        -
        8718  if(GetSize() - suballocItem->offset < allocSize)
        -
        8719  {
        -
        8720  return false;
        -
        8721  }
        -
        8722 
        -
        8723  // Start from offset equal to beginning of this suballocation.
        -
        8724  *pOffset = suballocItem->offset;
        -
        8725 
        -
        8726  // Apply VMA_DEBUG_MARGIN at the beginning.
        -
        8727  if(VMA_DEBUG_MARGIN > 0)
        -
        8728  {
        -
        8729  *pOffset += VMA_DEBUG_MARGIN;
        -
        8730  }
        -
        8731 
        -
        8732  // Apply alignment.
        -
        8733  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        -
        8734 
        -
        8735  // Check previous suballocations for BufferImageGranularity conflicts.
        -
        8736  // Make bigger alignment if necessary.
        -
        8737  if(bufferImageGranularity > 1)
        -
        8738  {
        -
        8739  bool bufferImageGranularityConflict = false;
        -
        8740  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        -
        8741  while(prevSuballocItem != m_Suballocations.cbegin())
        -
        8742  {
        -
        8743  --prevSuballocItem;
        -
        8744  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        -
        8745  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        -
        8746  {
        -
        8747  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        -
        8748  {
        -
        8749  bufferImageGranularityConflict = true;
        -
        8750  break;
        -
        8751  }
        -
        8752  }
        -
        8753  else
        -
        8754  // Already on previous page.
        -
        8755  break;
        -
        8756  }
        -
        8757  if(bufferImageGranularityConflict)
        -
        8758  {
        -
        8759  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        -
        8760  }
        +
        8697  VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8698  VMA_VALIDATE(it->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
        +
        8699  VMA_VALIDATE(it->size >= lastSize);
        +
        8700  lastSize = it->size;
        +
        8701  }
        +
        8702  return true;
        +
        8703 }
        +
        8704 
        +
        8705 bool VmaBlockMetadata_Generic::CheckAllocation(
        +
        8706  uint32_t currentFrameIndex,
        +
        8707  uint32_t frameInUseCount,
        +
        8708  VkDeviceSize bufferImageGranularity,
        +
        8709  VkDeviceSize allocSize,
        +
        8710  VkDeviceSize allocAlignment,
        +
        8711  VmaSuballocationType allocType,
        +
        8712  VmaSuballocationList::const_iterator suballocItem,
        +
        8713  bool canMakeOtherLost,
        +
        8714  VkDeviceSize* pOffset,
        +
        8715  size_t* itemsToMakeLostCount,
        +
        8716  VkDeviceSize* pSumFreeSize,
        +
        8717  VkDeviceSize* pSumItemSize) const
        +
        8718 {
        +
        8719  VMA_ASSERT(allocSize > 0);
        +
        8720  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        +
        8721  VMA_ASSERT(suballocItem != m_Suballocations.cend());
        +
        8722  VMA_ASSERT(pOffset != VMA_NULL);
        +
        8723 
        +
        8724  *itemsToMakeLostCount = 0;
        +
        8725  *pSumFreeSize = 0;
        +
        8726  *pSumItemSize = 0;
        +
        8727 
        +
        8728  if(canMakeOtherLost)
        +
        8729  {
        +
        8730  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        +
        8731  {
        +
        8732  *pSumFreeSize = suballocItem->size;
        +
        8733  }
        +
        8734  else
        +
        8735  {
        +
        8736  if(suballocItem->hAllocation->CanBecomeLost() &&
        +
        8737  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        +
        8738  {
        +
        8739  ++*itemsToMakeLostCount;
        +
        8740  *pSumItemSize = suballocItem->size;
        +
        8741  }
        +
        8742  else
        +
        8743  {
        +
        8744  return false;
        +
        8745  }
        +
        8746  }
        +
        8747 
        +
        8748  // Remaining size is too small for this request: Early return.
        +
        8749  if(GetSize() - suballocItem->offset < allocSize)
        +
        8750  {
        +
        8751  return false;
        +
        8752  }
        +
        8753 
        +
        8754  // Start from offset equal to beginning of this suballocation.
        +
        8755  *pOffset = suballocItem->offset;
        +
        8756 
        +
        8757  // Apply VMA_DEBUG_MARGIN at the beginning.
        +
        8758  if(VMA_DEBUG_MARGIN > 0)
        +
        8759  {
        +
        8760  *pOffset += VMA_DEBUG_MARGIN;
        8761  }
        8762 
        -
        8763  // Now that we have final *pOffset, check if we are past suballocItem.
        -
        8764  // If yes, return false - this function should be called for another suballocItem as starting point.
        -
        8765  if(*pOffset >= suballocItem->offset + suballocItem->size)
        -
        8766  {
        -
        8767  return false;
        -
        8768  }
        -
        8769 
        -
        8770  // Calculate padding at the beginning based on current offset.
        -
        8771  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
        -
        8772 
        -
        8773  // Calculate required margin at the end.
        -
        8774  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        -
        8775 
        -
        8776  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
        -
        8777  // Another early return check.
        -
        8778  if(suballocItem->offset + totalSize > GetSize())
        -
        8779  {
        -
        8780  return false;
        -
        8781  }
        -
        8782 
        -
        8783  // Advance lastSuballocItem until desired size is reached.
        -
        8784  // Update itemsToMakeLostCount.
        -
        8785  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
        -
        8786  if(totalSize > suballocItem->size)
        -
        8787  {
        -
        8788  VkDeviceSize remainingSize = totalSize - suballocItem->size;
        -
        8789  while(remainingSize > 0)
        -
        8790  {
        -
        8791  ++lastSuballocItem;
        -
        8792  if(lastSuballocItem == m_Suballocations.cend())
        -
        8793  {
        -
        8794  return false;
        -
        8795  }
        -
        8796  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        -
        8797  {
        -
        8798  *pSumFreeSize += lastSuballocItem->size;
        -
        8799  }
        -
        8800  else
        -
        8801  {
        -
        8802  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
        -
        8803  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
        -
        8804  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        -
        8805  {
        -
        8806  ++*itemsToMakeLostCount;
        -
        8807  *pSumItemSize += lastSuballocItem->size;
        -
        8808  }
        -
        8809  else
        -
        8810  {
        -
        8811  return false;
        -
        8812  }
        -
        8813  }
        -
        8814  remainingSize = (lastSuballocItem->size < remainingSize) ?
        -
        8815  remainingSize - lastSuballocItem->size : 0;
        -
        8816  }
        -
        8817  }
        -
        8818 
        -
        8819  // Check next suballocations for BufferImageGranularity conflicts.
        -
        8820  // If conflict exists, we must mark more allocations lost or fail.
        -
        8821  if(bufferImageGranularity > 1)
        -
        8822  {
        -
        8823  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
        -
        8824  ++nextSuballocItem;
        -
        8825  while(nextSuballocItem != m_Suballocations.cend())
        -
        8826  {
        -
        8827  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        -
        8828  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        -
        8829  {
        -
        8830  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        -
        8831  {
        -
        8832  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
        -
        8833  if(nextSuballoc.hAllocation->CanBecomeLost() &&
        -
        8834  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        -
        8835  {
        -
        8836  ++*itemsToMakeLostCount;
        -
        8837  }
        -
        8838  else
        -
        8839  {
        -
        8840  return false;
        -
        8841  }
        -
        8842  }
        -
        8843  }
        -
        8844  else
        -
        8845  {
        -
        8846  // Already on next page.
        -
        8847  break;
        -
        8848  }
        -
        8849  ++nextSuballocItem;
        -
        8850  }
        -
        8851  }
        -
        8852  }
        -
        8853  else
        -
        8854  {
        -
        8855  const VmaSuballocation& suballoc = *suballocItem;
        -
        8856  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8857 
        -
        8858  *pSumFreeSize = suballoc.size;
        -
        8859 
        -
        8860  // Size of this suballocation is too small for this request: Early return.
        -
        8861  if(suballoc.size < allocSize)
        -
        8862  {
        -
        8863  return false;
        -
        8864  }
        -
        8865 
        -
        8866  // Start from offset equal to beginning of this suballocation.
        -
        8867  *pOffset = suballoc.offset;
        -
        8868 
        -
        8869  // Apply VMA_DEBUG_MARGIN at the beginning.
        -
        8870  if(VMA_DEBUG_MARGIN > 0)
        -
        8871  {
        -
        8872  *pOffset += VMA_DEBUG_MARGIN;
        -
        8873  }
        -
        8874 
        -
        8875  // Apply alignment.
        -
        8876  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        -
        8877 
        -
        8878  // Check previous suballocations for BufferImageGranularity conflicts.
        -
        8879  // Make bigger alignment if necessary.
        -
        8880  if(bufferImageGranularity > 1)
        -
        8881  {
        -
        8882  bool bufferImageGranularityConflict = false;
        -
        8883  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        -
        8884  while(prevSuballocItem != m_Suballocations.cbegin())
        -
        8885  {
        -
        8886  --prevSuballocItem;
        -
        8887  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        -
        8888  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        -
        8889  {
        -
        8890  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        -
        8891  {
        -
        8892  bufferImageGranularityConflict = true;
        -
        8893  break;
        -
        8894  }
        -
        8895  }
        -
        8896  else
        -
        8897  // Already on previous page.
        -
        8898  break;
        -
        8899  }
        -
        8900  if(bufferImageGranularityConflict)
        -
        8901  {
        -
        8902  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        -
        8903  }
        +
        8763  // Apply alignment.
        +
        8764  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        +
        8765 
        +
        8766  // Check previous suballocations for BufferImageGranularity conflicts.
        +
        8767  // Make bigger alignment if necessary.
        +
        8768  if(bufferImageGranularity > 1)
        +
        8769  {
        +
        8770  bool bufferImageGranularityConflict = false;
        +
        8771  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        +
        8772  while(prevSuballocItem != m_Suballocations.cbegin())
        +
        8773  {
        +
        8774  --prevSuballocItem;
        +
        8775  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        +
        8776  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        +
        8777  {
        +
        8778  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        +
        8779  {
        +
        8780  bufferImageGranularityConflict = true;
        +
        8781  break;
        +
        8782  }
        +
        8783  }
        +
        8784  else
        +
        8785  // Already on previous page.
        +
        8786  break;
        +
        8787  }
        +
        8788  if(bufferImageGranularityConflict)
        +
        8789  {
        +
        8790  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        +
        8791  }
        +
        8792  }
        +
        8793 
        +
        8794  // Now that we have final *pOffset, check if we are past suballocItem.
        +
        8795  // If yes, return false - this function should be called for another suballocItem as starting point.
        +
        8796  if(*pOffset >= suballocItem->offset + suballocItem->size)
        +
        8797  {
        +
        8798  return false;
        +
        8799  }
        +
        8800 
        +
        8801  // Calculate padding at the beginning based on current offset.
        +
        8802  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
        +
        8803 
        +
        8804  // Calculate required margin at the end.
        +
        8805  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        +
        8806 
        +
        8807  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
        +
        8808  // Another early return check.
        +
        8809  if(suballocItem->offset + totalSize > GetSize())
        +
        8810  {
        +
        8811  return false;
        +
        8812  }
        +
        8813 
        +
        8814  // Advance lastSuballocItem until desired size is reached.
        +
        8815  // Update itemsToMakeLostCount.
        +
        8816  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
        +
        8817  if(totalSize > suballocItem->size)
        +
        8818  {
        +
        8819  VkDeviceSize remainingSize = totalSize - suballocItem->size;
        +
        8820  while(remainingSize > 0)
        +
        8821  {
        +
        8822  ++lastSuballocItem;
        +
        8823  if(lastSuballocItem == m_Suballocations.cend())
        +
        8824  {
        +
        8825  return false;
        +
        8826  }
        +
        8827  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        +
        8828  {
        +
        8829  *pSumFreeSize += lastSuballocItem->size;
        +
        8830  }
        +
        8831  else
        +
        8832  {
        +
        8833  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
        +
        8834  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
        +
        8835  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        +
        8836  {
        +
        8837  ++*itemsToMakeLostCount;
        +
        8838  *pSumItemSize += lastSuballocItem->size;
        +
        8839  }
        +
        8840  else
        +
        8841  {
        +
        8842  return false;
        +
        8843  }
        +
        8844  }
        +
        8845  remainingSize = (lastSuballocItem->size < remainingSize) ?
        +
        8846  remainingSize - lastSuballocItem->size : 0;
        +
        8847  }
        +
        8848  }
        +
        8849 
        +
        8850  // Check next suballocations for BufferImageGranularity conflicts.
        +
        8851  // If conflict exists, we must mark more allocations lost or fail.
        +
        8852  if(bufferImageGranularity > 1)
        +
        8853  {
        +
        8854  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
        +
        8855  ++nextSuballocItem;
        +
        8856  while(nextSuballocItem != m_Suballocations.cend())
        +
        8857  {
        +
        8858  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        +
        8859  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        +
        8860  {
        +
        8861  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        +
        8862  {
        +
        8863  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
        +
        8864  if(nextSuballoc.hAllocation->CanBecomeLost() &&
        +
        8865  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        +
        8866  {
        +
        8867  ++*itemsToMakeLostCount;
        +
        8868  }
        +
        8869  else
        +
        8870  {
        +
        8871  return false;
        +
        8872  }
        +
        8873  }
        +
        8874  }
        +
        8875  else
        +
        8876  {
        +
        8877  // Already on next page.
        +
        8878  break;
        +
        8879  }
        +
        8880  ++nextSuballocItem;
        +
        8881  }
        +
        8882  }
        +
        8883  }
        +
        8884  else
        +
        8885  {
        +
        8886  const VmaSuballocation& suballoc = *suballocItem;
        +
        8887  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8888 
        +
        8889  *pSumFreeSize = suballoc.size;
        +
        8890 
        +
        8891  // Size of this suballocation is too small for this request: Early return.
        +
        8892  if(suballoc.size < allocSize)
        +
        8893  {
        +
        8894  return false;
        +
        8895  }
        +
        8896 
        +
        8897  // Start from offset equal to beginning of this suballocation.
        +
        8898  *pOffset = suballoc.offset;
        +
        8899 
        +
        8900  // Apply VMA_DEBUG_MARGIN at the beginning.
        +
        8901  if(VMA_DEBUG_MARGIN > 0)
        +
        8902  {
        +
        8903  *pOffset += VMA_DEBUG_MARGIN;
        8904  }
        8905 
        -
        8906  // Calculate padding at the beginning based on current offset.
        -
        8907  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
        -
        8908 
        -
        8909  // Calculate required margin at the end.
        -
        8910  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        -
        8911 
        -
        8912  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
        -
        8913  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
        -
        8914  {
        -
        8915  return false;
        -
        8916  }
        -
        8917 
        -
        8918  // Check next suballocations for BufferImageGranularity conflicts.
        -
        8919  // If conflict exists, allocation cannot be made here.
        -
        8920  if(bufferImageGranularity > 1)
        -
        8921  {
        -
        8922  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
        -
        8923  ++nextSuballocItem;
        -
        8924  while(nextSuballocItem != m_Suballocations.cend())
        -
        8925  {
        -
        8926  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        -
        8927  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        -
        8928  {
        -
        8929  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        -
        8930  {
        -
        8931  return false;
        -
        8932  }
        -
        8933  }
        -
        8934  else
        -
        8935  {
        -
        8936  // Already on next page.
        -
        8937  break;
        -
        8938  }
        -
        8939  ++nextSuballocItem;
        -
        8940  }
        -
        8941  }
        -
        8942  }
        -
        8943 
        -
        8944  // All tests passed: Success. pOffset is already filled.
        -
        8945  return true;
        -
        8946 }
        -
        8947 
        -
        8948 void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
        -
        8949 {
        -
        8950  VMA_ASSERT(item != m_Suballocations.end());
        -
        8951  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8952 
        -
        8953  VmaSuballocationList::iterator nextItem = item;
        -
        8954  ++nextItem;
        -
        8955  VMA_ASSERT(nextItem != m_Suballocations.end());
        -
        8956  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        8957 
        -
        8958  item->size += nextItem->size;
        -
        8959  --m_FreeCount;
        -
        8960  m_Suballocations.erase(nextItem);
        -
        8961 }
        -
        8962 
        -
        8963 VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
        -
        8964 {
        -
        8965  // Change this suballocation to be marked as free.
        -
        8966  VmaSuballocation& suballoc = *suballocItem;
        -
        8967  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        8968  suballoc.hAllocation = VK_NULL_HANDLE;
        -
        8969 
        -
        8970  // Update totals.
        -
        8971  ++m_FreeCount;
        -
        8972  m_SumFreeSize += suballoc.size;
        -
        8973 
        -
        8974  // Merge with previous and/or next suballocation if it's also free.
        -
        8975  bool mergeWithNext = false;
        -
        8976  bool mergeWithPrev = false;
        -
        8977 
        -
        8978  VmaSuballocationList::iterator nextItem = suballocItem;
        -
        8979  ++nextItem;
        -
        8980  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
        -
        8981  {
        -
        8982  mergeWithNext = true;
        -
        8983  }
        -
        8984 
        -
        8985  VmaSuballocationList::iterator prevItem = suballocItem;
        -
        8986  if(suballocItem != m_Suballocations.begin())
        -
        8987  {
        -
        8988  --prevItem;
        -
        8989  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        -
        8990  {
        -
        8991  mergeWithPrev = true;
        -
        8992  }
        -
        8993  }
        -
        8994 
        -
        8995  if(mergeWithNext)
        -
        8996  {
        -
        8997  UnregisterFreeSuballocation(nextItem);
        -
        8998  MergeFreeWithNext(suballocItem);
        -
        8999  }
        -
        9000 
        -
        9001  if(mergeWithPrev)
        -
        9002  {
        -
        9003  UnregisterFreeSuballocation(prevItem);
        -
        9004  MergeFreeWithNext(prevItem);
        -
        9005  RegisterFreeSuballocation(prevItem);
        -
        9006  return prevItem;
        -
        9007  }
        -
        9008  else
        -
        9009  {
        -
        9010  RegisterFreeSuballocation(suballocItem);
        -
        9011  return suballocItem;
        -
        9012  }
        -
        9013 }
        -
        9014 
        -
        9015 void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
        -
        9016 {
        -
        9017  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        9018  VMA_ASSERT(item->size > 0);
        -
        9019 
        -
        9020  // You may want to enable this validation at the beginning or at the end of
        -
        9021  // this function, depending on what do you want to check.
        -
        9022  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        -
        9023 
        -
        9024  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        -
        9025  {
        -
        9026  if(m_FreeSuballocationsBySize.empty())
        -
        9027  {
        -
        9028  m_FreeSuballocationsBySize.push_back(item);
        -
        9029  }
        -
        9030  else
        -
        9031  {
        -
        9032  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
        -
        9033  }
        -
        9034  }
        -
        9035 
        -
        9036  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        -
        9037 }
        -
        9038 
        -
        9039 
        -
        9040 void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
        -
        9041 {
        -
        9042  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        9043  VMA_ASSERT(item->size > 0);
        -
        9044 
        -
        9045  // You may want to enable this validation at the beginning or at the end of
        -
        9046  // this function, depending on what do you want to check.
        -
        9047  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        -
        9048 
        -
        9049  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        -
        9050  {
        -
        9051  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        -
        9052  m_FreeSuballocationsBySize.data(),
        -
        9053  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
        -
        9054  item,
        -
        9055  VmaSuballocationItemSizeLess());
        -
        9056  for(size_t index = it - m_FreeSuballocationsBySize.data();
        -
        9057  index < m_FreeSuballocationsBySize.size();
        -
        9058  ++index)
        -
        9059  {
        -
        9060  if(m_FreeSuballocationsBySize[index] == item)
        -
        9061  {
        -
        9062  VmaVectorRemove(m_FreeSuballocationsBySize, index);
        -
        9063  return;
        -
        9064  }
        -
        9065  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
        -
        9066  }
        -
        9067  VMA_ASSERT(0 && "Not found.");
        -
        9068  }
        +
        8906  // Apply alignment.
        +
        8907  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        +
        8908 
        +
        8909  // Check previous suballocations for BufferImageGranularity conflicts.
        +
        8910  // Make bigger alignment if necessary.
        +
        8911  if(bufferImageGranularity > 1)
        +
        8912  {
        +
        8913  bool bufferImageGranularityConflict = false;
        +
        8914  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        +
        8915  while(prevSuballocItem != m_Suballocations.cbegin())
        +
        8916  {
        +
        8917  --prevSuballocItem;
        +
        8918  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        +
        8919  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        +
        8920  {
        +
        8921  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        +
        8922  {
        +
        8923  bufferImageGranularityConflict = true;
        +
        8924  break;
        +
        8925  }
        +
        8926  }
        +
        8927  else
        +
        8928  // Already on previous page.
        +
        8929  break;
        +
        8930  }
        +
        8931  if(bufferImageGranularityConflict)
        +
        8932  {
        +
        8933  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        +
        8934  }
        +
        8935  }
        +
        8936 
        +
        8937  // Calculate padding at the beginning based on current offset.
        +
        8938  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
        +
        8939 
        +
        8940  // Calculate required margin at the end.
        +
        8941  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        +
        8942 
        +
        8943  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
        +
        8944  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
        +
        8945  {
        +
        8946  return false;
        +
        8947  }
        +
        8948 
        +
        8949  // Check next suballocations for BufferImageGranularity conflicts.
        +
        8950  // If conflict exists, allocation cannot be made here.
        +
        8951  if(bufferImageGranularity > 1)
        +
        8952  {
        +
        8953  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
        +
        8954  ++nextSuballocItem;
        +
        8955  while(nextSuballocItem != m_Suballocations.cend())
        +
        8956  {
        +
        8957  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        +
        8958  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        +
        8959  {
        +
        8960  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        +
        8961  {
        +
        8962  return false;
        +
        8963  }
        +
        8964  }
        +
        8965  else
        +
        8966  {
        +
        8967  // Already on next page.
        +
        8968  break;
        +
        8969  }
        +
        8970  ++nextSuballocItem;
        +
        8971  }
        +
        8972  }
        +
        8973  }
        +
        8974 
        +
        8975  // All tests passed: Success. pOffset is already filled.
        +
        8976  return true;
        +
        8977 }
        +
        8978 
        +
        8979 void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
        +
        8980 {
        +
        8981  VMA_ASSERT(item != m_Suballocations.end());
        +
        8982  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8983 
        +
        8984  VmaSuballocationList::iterator nextItem = item;
        +
        8985  ++nextItem;
        +
        8986  VMA_ASSERT(nextItem != m_Suballocations.end());
        +
        8987  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        8988 
        +
        8989  item->size += nextItem->size;
        +
        8990  --m_FreeCount;
        +
        8991  m_Suballocations.erase(nextItem);
        +
        8992 }
        +
        8993 
        +
        8994 VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
        +
        8995 {
        +
        8996  // Change this suballocation to be marked as free.
        +
        8997  VmaSuballocation& suballoc = *suballocItem;
        +
        8998  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        8999  suballoc.hAllocation = VK_NULL_HANDLE;
        +
        9000 
        +
        9001  // Update totals.
        +
        9002  ++m_FreeCount;
        +
        9003  m_SumFreeSize += suballoc.size;
        +
        9004 
        +
        9005  // Merge with previous and/or next suballocation if it's also free.
        +
        9006  bool mergeWithNext = false;
        +
        9007  bool mergeWithPrev = false;
        +
        9008 
        +
        9009  VmaSuballocationList::iterator nextItem = suballocItem;
        +
        9010  ++nextItem;
        +
        9011  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
        +
        9012  {
        +
        9013  mergeWithNext = true;
        +
        9014  }
        +
        9015 
        +
        9016  VmaSuballocationList::iterator prevItem = suballocItem;
        +
        9017  if(suballocItem != m_Suballocations.begin())
        +
        9018  {
        +
        9019  --prevItem;
        +
        9020  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        +
        9021  {
        +
        9022  mergeWithPrev = true;
        +
        9023  }
        +
        9024  }
        +
        9025 
        +
        9026  if(mergeWithNext)
        +
        9027  {
        +
        9028  UnregisterFreeSuballocation(nextItem);
        +
        9029  MergeFreeWithNext(suballocItem);
        +
        9030  }
        +
        9031 
        +
        9032  if(mergeWithPrev)
        +
        9033  {
        +
        9034  UnregisterFreeSuballocation(prevItem);
        +
        9035  MergeFreeWithNext(prevItem);
        +
        9036  RegisterFreeSuballocation(prevItem);
        +
        9037  return prevItem;
        +
        9038  }
        +
        9039  else
        +
        9040  {
        +
        9041  RegisterFreeSuballocation(suballocItem);
        +
        9042  return suballocItem;
        +
        9043  }
        +
        9044 }
        +
        9045 
        +
        9046 void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
        +
        9047 {
        +
        9048  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        9049  VMA_ASSERT(item->size > 0);
        +
        9050 
        +
        9051  // You may want to enable this validation at the beginning or at the end of
        +
        9052  // this function, depending on what do you want to check.
        +
        9053  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        +
        9054 
        +
        9055  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        9056  {
        +
        9057  if(m_FreeSuballocationsBySize.empty())
        +
        9058  {
        +
        9059  m_FreeSuballocationsBySize.push_back(item);
        +
        9060  }
        +
        9061  else
        +
        9062  {
        +
        9063  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
        +
        9064  }
        +
        9065  }
        +
        9066 
        +
        9067  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        +
        9068 }
        9069 
        -
        9070  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        -
        9071 }
        -
        9072 
        -
        9073 bool VmaBlockMetadata_Generic::IsBufferImageGranularityConflictPossible(
        -
        9074  VkDeviceSize bufferImageGranularity,
        -
        9075  VmaSuballocationType& inOutPrevSuballocType) const
        -
        9076 {
        -
        9077  if(bufferImageGranularity == 1 || IsEmpty())
        -
        9078  {
        -
        9079  return false;
        -
        9080  }
        -
        9081 
        -
        9082  VkDeviceSize minAlignment = VK_WHOLE_SIZE;
        -
        9083  bool typeConflictFound = false;
        -
        9084  for(VmaSuballocationList::const_iterator it = m_Suballocations.cbegin();
        -
        9085  it != m_Suballocations.cend();
        -
        9086  ++it)
        -
        9087  {
        -
        9088  const VmaSuballocationType suballocType = it->type;
        -
        9089  if(suballocType != VMA_SUBALLOCATION_TYPE_FREE)
        +
        9070 
        +
        9071 void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
        +
        9072 {
        +
        9073  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        9074  VMA_ASSERT(item->size > 0);
        +
        9075 
        +
        9076  // You may want to enable this validation at the beginning or at the end of
        +
        9077  // this function, depending on what do you want to check.
        +
        9078  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        +
        9079 
        +
        9080  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        9081  {
        +
        9082  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        +
        9083  m_FreeSuballocationsBySize.data(),
        +
        9084  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
        +
        9085  item,
        +
        9086  VmaSuballocationItemSizeLess());
        +
        9087  for(size_t index = it - m_FreeSuballocationsBySize.data();
        +
        9088  index < m_FreeSuballocationsBySize.size();
        +
        9089  ++index)
        9090  {
        -
        9091  minAlignment = VMA_MIN(minAlignment, it->hAllocation->GetAlignment());
        -
        9092  if(VmaIsBufferImageGranularityConflict(inOutPrevSuballocType, suballocType))
        -
        9093  {
        -
        9094  typeConflictFound = true;
        +
        9091  if(m_FreeSuballocationsBySize[index] == item)
        +
        9092  {
        +
        9093  VmaVectorRemove(m_FreeSuballocationsBySize, index);
        +
        9094  return;
        9095  }
        -
        9096  inOutPrevSuballocType = suballocType;
        +
        9096  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
        9097  }
        -
        9098  }
        -
        9099 
        -
        9100  return typeConflictFound || minAlignment >= bufferImageGranularity;
        -
        9101 }
        -
        9102 
        -
        9104 // class VmaBlockMetadata_Linear
        -
        9105 
        -
        9106 VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :
        -
        9107  VmaBlockMetadata(hAllocator),
        -
        9108  m_SumFreeSize(0),
        -
        9109  m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        -
        9110  m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        -
        9111  m_1stVectorIndex(0),
        -
        9112  m_2ndVectorMode(SECOND_VECTOR_EMPTY),
        -
        9113  m_1stNullItemsBeginCount(0),
        -
        9114  m_1stNullItemsMiddleCount(0),
        -
        9115  m_2ndNullItemsCount(0)
        -
        9116 {
        -
        9117 }
        -
        9118 
        -
        9119 VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()
        -
        9120 {
        -
        9121 }
        -
        9122 
        -
        9123 void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
        -
        9124 {
        -
        9125  VmaBlockMetadata::Init(size);
        -
        9126  m_SumFreeSize = size;
        -
        9127 }
        -
        9128 
        -
        9129 bool VmaBlockMetadata_Linear::Validate() const
        -
        9130 {
        -
        9131  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        9132  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        9098  VMA_ASSERT(0 && "Not found.");
        +
        9099  }
        +
        9100 
        +
        9101  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        +
        9102 }
        +
        9103 
        +
        9104 bool VmaBlockMetadata_Generic::IsBufferImageGranularityConflictPossible(
        +
        9105  VkDeviceSize bufferImageGranularity,
        +
        9106  VmaSuballocationType& inOutPrevSuballocType) const
        +
        9107 {
        +
        9108  if(bufferImageGranularity == 1 || IsEmpty())
        +
        9109  {
        +
        9110  return false;
        +
        9111  }
        +
        9112 
        +
        9113  VkDeviceSize minAlignment = VK_WHOLE_SIZE;
        +
        9114  bool typeConflictFound = false;
        +
        9115  for(VmaSuballocationList::const_iterator it = m_Suballocations.cbegin();
        +
        9116  it != m_Suballocations.cend();
        +
        9117  ++it)
        +
        9118  {
        +
        9119  const VmaSuballocationType suballocType = it->type;
        +
        9120  if(suballocType != VMA_SUBALLOCATION_TYPE_FREE)
        +
        9121  {
        +
        9122  minAlignment = VMA_MIN(minAlignment, it->hAllocation->GetAlignment());
        +
        9123  if(VmaIsBufferImageGranularityConflict(inOutPrevSuballocType, suballocType))
        +
        9124  {
        +
        9125  typeConflictFound = true;
        +
        9126  }
        +
        9127  inOutPrevSuballocType = suballocType;
        +
        9128  }
        +
        9129  }
        +
        9130 
        +
        9131  return typeConflictFound || minAlignment >= bufferImageGranularity;
        +
        9132 }
        9133 
        -
        9134  VMA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
        -
        9135  VMA_VALIDATE(!suballocations1st.empty() ||
        -
        9136  suballocations2nd.empty() ||
        -
        9137  m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);
        -
        9138 
        -
        9139  if(!suballocations1st.empty())
        -
        9140  {
        -
        9141  // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
        -
        9142  VMA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].hAllocation != VK_NULL_HANDLE);
        -
        9143  // Null item at the end should be just pop_back().
        -
        9144  VMA_VALIDATE(suballocations1st.back().hAllocation != VK_NULL_HANDLE);
        -
        9145  }
        -
        9146  if(!suballocations2nd.empty())
        -
        9147  {
        -
        9148  // Null item at the end should be just pop_back().
        -
        9149  VMA_VALIDATE(suballocations2nd.back().hAllocation != VK_NULL_HANDLE);
        -
        9150  }
        -
        9151 
        -
        9152  VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
        -
        9153  VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());
        -
        9154 
        -
        9155  VkDeviceSize sumUsedSize = 0;
        -
        9156  const size_t suballoc1stCount = suballocations1st.size();
        -
        9157  VkDeviceSize offset = VMA_DEBUG_MARGIN;
        -
        9158 
        -
        9159  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        9160  {
        -
        9161  const size_t suballoc2ndCount = suballocations2nd.size();
        -
        9162  size_t nullItem2ndCount = 0;
        -
        9163  for(size_t i = 0; i < suballoc2ndCount; ++i)
        -
        9164  {
        -
        9165  const VmaSuballocation& suballoc = suballocations2nd[i];
        -
        9166  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        9167 
        -
        9168  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
        -
        9169  VMA_VALIDATE(suballoc.offset >= offset);
        -
        9170 
        -
        9171  if(!currFree)
        -
        9172  {
        -
        9173  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
        -
        9174  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
        -
        9175  sumUsedSize += suballoc.size;
        -
        9176  }
        -
        9177  else
        -
        9178  {
        -
        9179  ++nullItem2ndCount;
        -
        9180  }
        -
        9181 
        -
        9182  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        -
        9183  }
        -
        9184 
        -
        9185  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
        -
        9186  }
        -
        9187 
        -
        9188  for(size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
        -
        9189  {
        -
        9190  const VmaSuballocation& suballoc = suballocations1st[i];
        -
        9191  VMA_VALIDATE(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE &&
        -
        9192  suballoc.hAllocation == VK_NULL_HANDLE);
        -
        9193  }
        -
        9194 
        -
        9195  size_t nullItem1stCount = m_1stNullItemsBeginCount;
        -
        9196 
        -
        9197  for(size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
        -
        9198  {
        -
        9199  const VmaSuballocation& suballoc = suballocations1st[i];
        -
        9200  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        9135 // class VmaBlockMetadata_Linear
        +
        9136 
        +
        9137 VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :
        +
        9138  VmaBlockMetadata(hAllocator),
        +
        9139  m_SumFreeSize(0),
        +
        9140  m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        +
        9141  m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        +
        9142  m_1stVectorIndex(0),
        +
        9143  m_2ndVectorMode(SECOND_VECTOR_EMPTY),
        +
        9144  m_1stNullItemsBeginCount(0),
        +
        9145  m_1stNullItemsMiddleCount(0),
        +
        9146  m_2ndNullItemsCount(0)
        +
        9147 {
        +
        9148 }
        +
        9149 
        +
        9150 VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()
        +
        9151 {
        +
        9152 }
        +
        9153 
        +
        9154 void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
        +
        9155 {
        +
        9156  VmaBlockMetadata::Init(size);
        +
        9157  m_SumFreeSize = size;
        +
        9158 }
        +
        9159 
        +
        9160 bool VmaBlockMetadata_Linear::Validate() const
        +
        9161 {
        +
        9162  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        9163  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        9164 
        +
        9165  VMA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
        +
        9166  VMA_VALIDATE(!suballocations1st.empty() ||
        +
        9167  suballocations2nd.empty() ||
        +
        9168  m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);
        +
        9169 
        +
        9170  if(!suballocations1st.empty())
        +
        9171  {
        +
        9172  // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
        +
        9173  VMA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].hAllocation != VK_NULL_HANDLE);
        +
        9174  // Null item at the end should be just pop_back().
        +
        9175  VMA_VALIDATE(suballocations1st.back().hAllocation != VK_NULL_HANDLE);
        +
        9176  }
        +
        9177  if(!suballocations2nd.empty())
        +
        9178  {
        +
        9179  // Null item at the end should be just pop_back().
        +
        9180  VMA_VALIDATE(suballocations2nd.back().hAllocation != VK_NULL_HANDLE);
        +
        9181  }
        +
        9182 
        +
        9183  VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
        +
        9184  VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());
        +
        9185 
        +
        9186  VkDeviceSize sumUsedSize = 0;
        +
        9187  const size_t suballoc1stCount = suballocations1st.size();
        +
        9188  VkDeviceSize offset = VMA_DEBUG_MARGIN;
        +
        9189 
        +
        9190  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        9191  {
        +
        9192  const size_t suballoc2ndCount = suballocations2nd.size();
        +
        9193  size_t nullItem2ndCount = 0;
        +
        9194  for(size_t i = 0; i < suballoc2ndCount; ++i)
        +
        9195  {
        +
        9196  const VmaSuballocation& suballoc = suballocations2nd[i];
        +
        9197  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        9198 
        +
        9199  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
        +
        9200  VMA_VALIDATE(suballoc.offset >= offset);
        9201 
        -
        9202  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
        -
        9203  VMA_VALIDATE(suballoc.offset >= offset);
        -
        9204  VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);
        -
        9205 
        -
        9206  if(!currFree)
        -
        9207  {
        -
        9208  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
        -
        9209  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
        -
        9210  sumUsedSize += suballoc.size;
        -
        9211  }
        -
        9212  else
        -
        9213  {
        -
        9214  ++nullItem1stCount;
        -
        9215  }
        -
        9216 
        -
        9217  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        -
        9218  }
        -
        9219  VMA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);
        -
        9220 
        -
        9221  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        9222  {
        -
        9223  const size_t suballoc2ndCount = suballocations2nd.size();
        -
        9224  size_t nullItem2ndCount = 0;
        -
        9225  for(size_t i = suballoc2ndCount; i--; )
        -
        9226  {
        -
        9227  const VmaSuballocation& suballoc = suballocations2nd[i];
        -
        9228  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        -
        9229 
        -
        9230  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
        -
        9231  VMA_VALIDATE(suballoc.offset >= offset);
        +
        9202  if(!currFree)
        +
        9203  {
        +
        9204  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
        +
        9205  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
        +
        9206  sumUsedSize += suballoc.size;
        +
        9207  }
        +
        9208  else
        +
        9209  {
        +
        9210  ++nullItem2ndCount;
        +
        9211  }
        +
        9212 
        +
        9213  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        +
        9214  }
        +
        9215 
        +
        9216  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
        +
        9217  }
        +
        9218 
        +
        9219  for(size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
        +
        9220  {
        +
        9221  const VmaSuballocation& suballoc = suballocations1st[i];
        +
        9222  VMA_VALIDATE(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE &&
        +
        9223  suballoc.hAllocation == VK_NULL_HANDLE);
        +
        9224  }
        +
        9225 
        +
        9226  size_t nullItem1stCount = m_1stNullItemsBeginCount;
        +
        9227 
        +
        9228  for(size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
        +
        9229  {
        +
        9230  const VmaSuballocation& suballoc = suballocations1st[i];
        +
        9231  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        9232 
        -
        9233  if(!currFree)
        -
        9234  {
        -
        9235  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
        -
        9236  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
        -
        9237  sumUsedSize += suballoc.size;
        -
        9238  }
        -
        9239  else
        -
        9240  {
        -
        9241  ++nullItem2ndCount;
        -
        9242  }
        -
        9243 
        -
        9244  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        -
        9245  }
        -
        9246 
        -
        9247  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
        -
        9248  }
        -
        9249 
        -
        9250  VMA_VALIDATE(offset <= GetSize());
        -
        9251  VMA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);
        -
        9252 
        -
        9253  return true;
        -
        9254 }
        -
        9255 
        -
        9256 size_t VmaBlockMetadata_Linear::GetAllocationCount() const
        -
        9257 {
        -
        9258  return AccessSuballocations1st().size() - (m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount) +
        -
        9259  AccessSuballocations2nd().size() - m_2ndNullItemsCount;
        -
        9260 }
        -
        9261 
        -
        9262 VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const
        -
        9263 {
        -
        9264  const VkDeviceSize size = GetSize();
        -
        9265 
        -
        9266  /*
        -
        9267  We don't consider gaps inside allocation vectors with freed allocations because
        -
        9268  they are not suitable for reuse in linear allocator. We consider only space that
        -
        9269  is available for new allocations.
        -
        9270  */
        -
        9271  if(IsEmpty())
        -
        9272  {
        -
        9273  return size;
        -
        9274  }
        -
        9275 
        -
        9276  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        9233  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
        +
        9234  VMA_VALIDATE(suballoc.offset >= offset);
        +
        9235  VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);
        +
        9236 
        +
        9237  if(!currFree)
        +
        9238  {
        +
        9239  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
        +
        9240  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
        +
        9241  sumUsedSize += suballoc.size;
        +
        9242  }
        +
        9243  else
        +
        9244  {
        +
        9245  ++nullItem1stCount;
        +
        9246  }
        +
        9247 
        +
        9248  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        +
        9249  }
        +
        9250  VMA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);
        +
        9251 
        +
        9252  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        9253  {
        +
        9254  const size_t suballoc2ndCount = suballocations2nd.size();
        +
        9255  size_t nullItem2ndCount = 0;
        +
        9256  for(size_t i = suballoc2ndCount; i--; )
        +
        9257  {
        +
        9258  const VmaSuballocation& suballoc = suballocations2nd[i];
        +
        9259  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        +
        9260 
        +
        9261  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
        +
        9262  VMA_VALIDATE(suballoc.offset >= offset);
        +
        9263 
        +
        9264  if(!currFree)
        +
        9265  {
        +
        9266  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
        +
        9267  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
        +
        9268  sumUsedSize += suballoc.size;
        +
        9269  }
        +
        9270  else
        +
        9271  {
        +
        9272  ++nullItem2ndCount;
        +
        9273  }
        +
        9274 
        +
        9275  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        +
        9276  }
        9277 
        -
        9278  switch(m_2ndVectorMode)
        -
        9279  {
        -
        9280  case SECOND_VECTOR_EMPTY:
        -
        9281  /*
        -
        9282  Available space is after end of 1st, as well as before beginning of 1st (which
        -
        9283  whould make it a ring buffer).
        -
        9284  */
        -
        9285  {
        -
        9286  const size_t suballocations1stCount = suballocations1st.size();
        -
        9287  VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);
        -
        9288  const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        -
        9289  const VmaSuballocation& lastSuballoc = suballocations1st[suballocations1stCount - 1];
        -
        9290  return VMA_MAX(
        -
        9291  firstSuballoc.offset,
        -
        9292  size - (lastSuballoc.offset + lastSuballoc.size));
        -
        9293  }
        -
        9294  break;
        -
        9295 
        -
        9296  case SECOND_VECTOR_RING_BUFFER:
        -
        9297  /*
        -
        9298  Available space is only between end of 2nd and beginning of 1st.
        -
        9299  */
        -
        9300  {
        -
        9301  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        9302  const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();
        -
        9303  const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];
        -
        9304  return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);
        -
        9305  }
        -
        9306  break;
        -
        9307 
        -
        9308  case SECOND_VECTOR_DOUBLE_STACK:
        -
        9309  /*
        -
        9310  Available space is only between end of 1st and top of 2nd.
        -
        9311  */
        -
        9312  {
        -
        9313  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        9314  const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();
        -
        9315  const VmaSuballocation& lastSuballoc1st = suballocations1st.back();
        -
        9316  return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);
        -
        9317  }
        -
        9318  break;
        -
        9319 
        -
        9320  default:
        -
        9321  VMA_ASSERT(0);
        -
        9322  return 0;
        -
        9323  }
        -
        9324 }
        -
        9325 
        -
        9326 void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        -
        9327 {
        -
        9328  const VkDeviceSize size = GetSize();
        -
        9329  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        9330  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        9331  const size_t suballoc1stCount = suballocations1st.size();
        -
        9332  const size_t suballoc2ndCount = suballocations2nd.size();
        -
        9333 
        -
        9334  outInfo.blockCount = 1;
        -
        9335  outInfo.allocationCount = (uint32_t)GetAllocationCount();
        -
        9336  outInfo.unusedRangeCount = 0;
        -
        9337  outInfo.usedBytes = 0;
        -
        9338  outInfo.allocationSizeMin = UINT64_MAX;
        -
        9339  outInfo.allocationSizeMax = 0;
        -
        9340  outInfo.unusedRangeSizeMin = UINT64_MAX;
        -
        9341  outInfo.unusedRangeSizeMax = 0;
        -
        9342 
        -
        9343  VkDeviceSize lastOffset = 0;
        -
        9344 
        -
        9345  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        9346  {
        -
        9347  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        -
        9348  size_t nextAlloc2ndIndex = 0;
        -
        9349  while(lastOffset < freeSpace2ndTo1stEnd)
        -
        9350  {
        -
        9351  // Find next non-null allocation or move nextAllocIndex to the end.
        -
        9352  while(nextAlloc2ndIndex < suballoc2ndCount &&
        -
        9353  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9354  {
        -
        9355  ++nextAlloc2ndIndex;
        -
        9356  }
        -
        9357 
        -
        9358  // Found non-null allocation.
        -
        9359  if(nextAlloc2ndIndex < suballoc2ndCount)
        -
        9360  {
        -
        9361  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9362 
        -
        9363  // 1. Process free space before this allocation.
        -
        9364  if(lastOffset < suballoc.offset)
        -
        9365  {
        -
        9366  // There is free space from lastOffset to suballoc.offset.
        -
        9367  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9368  ++outInfo.unusedRangeCount;
        -
        9369  outInfo.unusedBytes += unusedRangeSize;
        -
        9370  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        -
        9371  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        -
        9372  }
        -
        9373 
        -
        9374  // 2. Process this allocation.
        -
        9375  // There is allocation with suballoc.offset, suballoc.size.
        -
        9376  outInfo.usedBytes += suballoc.size;
        -
        9377  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        -
        9378  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        -
        9379 
        -
        9380  // 3. Prepare for next iteration.
        -
        9381  lastOffset = suballoc.offset + suballoc.size;
        -
        9382  ++nextAlloc2ndIndex;
        -
        9383  }
        -
        9384  // We are at the end.
        -
        9385  else
        -
        9386  {
        -
        9387  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        -
        9388  if(lastOffset < freeSpace2ndTo1stEnd)
        -
        9389  {
        -
        9390  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        -
        9391  ++outInfo.unusedRangeCount;
        -
        9392  outInfo.unusedBytes += unusedRangeSize;
        -
        9393  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        -
        9394  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        -
        9395  }
        -
        9396 
        -
        9397  // End of loop.
        -
        9398  lastOffset = freeSpace2ndTo1stEnd;
        -
        9399  }
        -
        9400  }
        -
        9401  }
        -
        9402 
        -
        9403  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        -
        9404  const VkDeviceSize freeSpace1stTo2ndEnd =
        -
        9405  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        -
        9406  while(lastOffset < freeSpace1stTo2ndEnd)
        -
        9407  {
        -
        9408  // Find next non-null allocation or move nextAllocIndex to the end.
        -
        9409  while(nextAlloc1stIndex < suballoc1stCount &&
        -
        9410  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        -
        9411  {
        -
        9412  ++nextAlloc1stIndex;
        -
        9413  }
        -
        9414 
        -
        9415  // Found non-null allocation.
        -
        9416  if(nextAlloc1stIndex < suballoc1stCount)
        -
        9417  {
        -
        9418  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        -
        9419 
        -
        9420  // 1. Process free space before this allocation.
        -
        9421  if(lastOffset < suballoc.offset)
        -
        9422  {
        -
        9423  // There is free space from lastOffset to suballoc.offset.
        -
        9424  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9425  ++outInfo.unusedRangeCount;
        -
        9426  outInfo.unusedBytes += unusedRangeSize;
        -
        9427  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        -
        9428  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        -
        9429  }
        -
        9430 
        -
        9431  // 2. Process this allocation.
        -
        9432  // There is allocation with suballoc.offset, suballoc.size.
        -
        9433  outInfo.usedBytes += suballoc.size;
        -
        9434  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        -
        9435  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        -
        9436 
        -
        9437  // 3. Prepare for next iteration.
        -
        9438  lastOffset = suballoc.offset + suballoc.size;
        -
        9439  ++nextAlloc1stIndex;
        -
        9440  }
        -
        9441  // We are at the end.
        -
        9442  else
        -
        9443  {
        -
        9444  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        -
        9445  if(lastOffset < freeSpace1stTo2ndEnd)
        -
        9446  {
        -
        9447  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        -
        9448  ++outInfo.unusedRangeCount;
        -
        9449  outInfo.unusedBytes += unusedRangeSize;
        -
        9450  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        -
        9451  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        -
        9452  }
        -
        9453 
        -
        9454  // End of loop.
        -
        9455  lastOffset = freeSpace1stTo2ndEnd;
        -
        9456  }
        -
        9457  }
        -
        9458 
        -
        9459  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        9460  {
        -
        9461  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        -
        9462  while(lastOffset < size)
        -
        9463  {
        -
        9464  // Find next non-null allocation or move nextAllocIndex to the end.
        -
        9465  while(nextAlloc2ndIndex != SIZE_MAX &&
        -
        9466  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9467  {
        -
        9468  --nextAlloc2ndIndex;
        -
        9469  }
        -
        9470 
        -
        9471  // Found non-null allocation.
        -
        9472  if(nextAlloc2ndIndex != SIZE_MAX)
        -
        9473  {
        -
        9474  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9475 
        -
        9476  // 1. Process free space before this allocation.
        -
        9477  if(lastOffset < suballoc.offset)
        -
        9478  {
        -
        9479  // There is free space from lastOffset to suballoc.offset.
        -
        9480  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9481  ++outInfo.unusedRangeCount;
        -
        9482  outInfo.unusedBytes += unusedRangeSize;
        -
        9483  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        -
        9484  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        -
        9485  }
        -
        9486 
        -
        9487  // 2. Process this allocation.
        -
        9488  // There is allocation with suballoc.offset, suballoc.size.
        -
        9489  outInfo.usedBytes += suballoc.size;
        -
        9490  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        -
        9491  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        -
        9492 
        -
        9493  // 3. Prepare for next iteration.
        -
        9494  lastOffset = suballoc.offset + suballoc.size;
        -
        9495  --nextAlloc2ndIndex;
        -
        9496  }
        -
        9497  // We are at the end.
        -
        9498  else
        -
        9499  {
        -
        9500  // There is free space from lastOffset to size.
        -
        9501  if(lastOffset < size)
        -
        9502  {
        -
        9503  const VkDeviceSize unusedRangeSize = size - lastOffset;
        -
        9504  ++outInfo.unusedRangeCount;
        -
        9505  outInfo.unusedBytes += unusedRangeSize;
        -
        9506  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        -
        9507  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        -
        9508  }
        -
        9509 
        -
        9510  // End of loop.
        -
        9511  lastOffset = size;
        -
        9512  }
        -
        9513  }
        -
        9514  }
        -
        9515 
        -
        9516  outInfo.unusedBytes = size - outInfo.usedBytes;
        -
        9517 }
        -
        9518 
        -
        9519 void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& inoutStats) const
        -
        9520 {
        -
        9521  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        9522  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        9523  const VkDeviceSize size = GetSize();
        -
        9524  const size_t suballoc1stCount = suballocations1st.size();
        -
        9525  const size_t suballoc2ndCount = suballocations2nd.size();
        -
        9526 
        -
        9527  inoutStats.size += size;
        -
        9528 
        -
        9529  VkDeviceSize lastOffset = 0;
        -
        9530 
        -
        9531  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        9532  {
        -
        9533  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        -
        9534  size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
        -
        9535  while(lastOffset < freeSpace2ndTo1stEnd)
        -
        9536  {
        -
        9537  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        -
        9538  while(nextAlloc2ndIndex < suballoc2ndCount &&
        -
        9539  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9540  {
        -
        9541  ++nextAlloc2ndIndex;
        -
        9542  }
        -
        9543 
        -
        9544  // Found non-null allocation.
        -
        9545  if(nextAlloc2ndIndex < suballoc2ndCount)
        -
        9546  {
        -
        9547  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9548 
        -
        9549  // 1. Process free space before this allocation.
        -
        9550  if(lastOffset < suballoc.offset)
        -
        9551  {
        -
        9552  // There is free space from lastOffset to suballoc.offset.
        -
        9553  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9554  inoutStats.unusedSize += unusedRangeSize;
        -
        9555  ++inoutStats.unusedRangeCount;
        -
        9556  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        -
        9557  }
        -
        9558 
        -
        9559  // 2. Process this allocation.
        -
        9560  // There is allocation with suballoc.offset, suballoc.size.
        -
        9561  ++inoutStats.allocationCount;
        -
        9562 
        -
        9563  // 3. Prepare for next iteration.
        -
        9564  lastOffset = suballoc.offset + suballoc.size;
        -
        9565  ++nextAlloc2ndIndex;
        -
        9566  }
        -
        9567  // We are at the end.
        -
        9568  else
        -
        9569  {
        -
        9570  if(lastOffset < freeSpace2ndTo1stEnd)
        -
        9571  {
        -
        9572  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        -
        9573  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        -
        9574  inoutStats.unusedSize += unusedRangeSize;
        -
        9575  ++inoutStats.unusedRangeCount;
        -
        9576  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        -
        9577  }
        -
        9578 
        -
        9579  // End of loop.
        -
        9580  lastOffset = freeSpace2ndTo1stEnd;
        -
        9581  }
        -
        9582  }
        -
        9583  }
        -
        9584 
        -
        9585  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        -
        9586  const VkDeviceSize freeSpace1stTo2ndEnd =
        -
        9587  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        -
        9588  while(lastOffset < freeSpace1stTo2ndEnd)
        -
        9589  {
        -
        9590  // Find next non-null allocation or move nextAllocIndex to the end.
        -
        9591  while(nextAlloc1stIndex < suballoc1stCount &&
        -
        9592  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        -
        9593  {
        -
        9594  ++nextAlloc1stIndex;
        -
        9595  }
        -
        9596 
        -
        9597  // Found non-null allocation.
        -
        9598  if(nextAlloc1stIndex < suballoc1stCount)
        -
        9599  {
        -
        9600  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        -
        9601 
        -
        9602  // 1. Process free space before this allocation.
        -
        9603  if(lastOffset < suballoc.offset)
        -
        9604  {
        -
        9605  // There is free space from lastOffset to suballoc.offset.
        -
        9606  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9607  inoutStats.unusedSize += unusedRangeSize;
        -
        9608  ++inoutStats.unusedRangeCount;
        -
        9609  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        -
        9610  }
        -
        9611 
        -
        9612  // 2. Process this allocation.
        -
        9613  // There is allocation with suballoc.offset, suballoc.size.
        -
        9614  ++inoutStats.allocationCount;
        -
        9615 
        -
        9616  // 3. Prepare for next iteration.
        -
        9617  lastOffset = suballoc.offset + suballoc.size;
        -
        9618  ++nextAlloc1stIndex;
        -
        9619  }
        -
        9620  // We are at the end.
        -
        9621  else
        -
        9622  {
        -
        9623  if(lastOffset < freeSpace1stTo2ndEnd)
        -
        9624  {
        -
        9625  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        -
        9626  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        -
        9627  inoutStats.unusedSize += unusedRangeSize;
        -
        9628  ++inoutStats.unusedRangeCount;
        -
        9629  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        -
        9630  }
        -
        9631 
        -
        9632  // End of loop.
        -
        9633  lastOffset = freeSpace1stTo2ndEnd;
        -
        9634  }
        -
        9635  }
        -
        9636 
        -
        9637  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        9638  {
        -
        9639  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        -
        9640  while(lastOffset < size)
        -
        9641  {
        -
        9642  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        -
        9643  while(nextAlloc2ndIndex != SIZE_MAX &&
        -
        9644  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9645  {
        -
        9646  --nextAlloc2ndIndex;
        -
        9647  }
        -
        9648 
        -
        9649  // Found non-null allocation.
        -
        9650  if(nextAlloc2ndIndex != SIZE_MAX)
        -
        9651  {
        -
        9652  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9653 
        -
        9654  // 1. Process free space before this allocation.
        -
        9655  if(lastOffset < suballoc.offset)
        -
        9656  {
        -
        9657  // There is free space from lastOffset to suballoc.offset.
        -
        9658  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9659  inoutStats.unusedSize += unusedRangeSize;
        -
        9660  ++inoutStats.unusedRangeCount;
        -
        9661  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        -
        9662  }
        -
        9663 
        -
        9664  // 2. Process this allocation.
        -
        9665  // There is allocation with suballoc.offset, suballoc.size.
        -
        9666  ++inoutStats.allocationCount;
        -
        9667 
        -
        9668  // 3. Prepare for next iteration.
        -
        9669  lastOffset = suballoc.offset + suballoc.size;
        -
        9670  --nextAlloc2ndIndex;
        -
        9671  }
        -
        9672  // We are at the end.
        -
        9673  else
        -
        9674  {
        -
        9675  if(lastOffset < size)
        -
        9676  {
        -
        9677  // There is free space from lastOffset to size.
        -
        9678  const VkDeviceSize unusedRangeSize = size - lastOffset;
        -
        9679  inoutStats.unusedSize += unusedRangeSize;
        -
        9680  ++inoutStats.unusedRangeCount;
        -
        9681  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        -
        9682  }
        -
        9683 
        -
        9684  // End of loop.
        -
        9685  lastOffset = size;
        -
        9686  }
        -
        9687  }
        -
        9688  }
        -
        9689 }
        -
        9690 
        -
        9691 #if VMA_STATS_STRING_ENABLED
        -
        9692 void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
        -
        9693 {
        -
        9694  const VkDeviceSize size = GetSize();
        -
        9695  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        9696  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        9697  const size_t suballoc1stCount = suballocations1st.size();
        -
        9698  const size_t suballoc2ndCount = suballocations2nd.size();
        -
        9699 
        -
        9700  // FIRST PASS
        -
        9701 
        -
        9702  size_t unusedRangeCount = 0;
        -
        9703  VkDeviceSize usedBytes = 0;
        -
        9704 
        -
        9705  VkDeviceSize lastOffset = 0;
        -
        9706 
        -
        9707  size_t alloc2ndCount = 0;
        -
        9708  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        9709  {
        -
        9710  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        -
        9711  size_t nextAlloc2ndIndex = 0;
        -
        9712  while(lastOffset < freeSpace2ndTo1stEnd)
        -
        9713  {
        -
        9714  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        -
        9715  while(nextAlloc2ndIndex < suballoc2ndCount &&
        -
        9716  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9717  {
        -
        9718  ++nextAlloc2ndIndex;
        -
        9719  }
        -
        9720 
        -
        9721  // Found non-null allocation.
        -
        9722  if(nextAlloc2ndIndex < suballoc2ndCount)
        -
        9723  {
        -
        9724  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9725 
        -
        9726  // 1. Process free space before this allocation.
        -
        9727  if(lastOffset < suballoc.offset)
        -
        9728  {
        -
        9729  // There is free space from lastOffset to suballoc.offset.
        -
        9730  ++unusedRangeCount;
        -
        9731  }
        -
        9732 
        -
        9733  // 2. Process this allocation.
        -
        9734  // There is allocation with suballoc.offset, suballoc.size.
        -
        9735  ++alloc2ndCount;
        -
        9736  usedBytes += suballoc.size;
        -
        9737 
        -
        9738  // 3. Prepare for next iteration.
        -
        9739  lastOffset = suballoc.offset + suballoc.size;
        -
        9740  ++nextAlloc2ndIndex;
        -
        9741  }
        -
        9742  // We are at the end.
        -
        9743  else
        -
        9744  {
        -
        9745  if(lastOffset < freeSpace2ndTo1stEnd)
        -
        9746  {
        -
        9747  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        -
        9748  ++unusedRangeCount;
        -
        9749  }
        -
        9750 
        -
        9751  // End of loop.
        -
        9752  lastOffset = freeSpace2ndTo1stEnd;
        -
        9753  }
        -
        9754  }
        -
        9755  }
        -
        9756 
        -
        9757  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        -
        9758  size_t alloc1stCount = 0;
        -
        9759  const VkDeviceSize freeSpace1stTo2ndEnd =
        -
        9760  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        -
        9761  while(lastOffset < freeSpace1stTo2ndEnd)
        -
        9762  {
        -
        9763  // Find next non-null allocation or move nextAllocIndex to the end.
        -
        9764  while(nextAlloc1stIndex < suballoc1stCount &&
        -
        9765  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        -
        9766  {
        -
        9767  ++nextAlloc1stIndex;
        -
        9768  }
        -
        9769 
        -
        9770  // Found non-null allocation.
        -
        9771  if(nextAlloc1stIndex < suballoc1stCount)
        -
        9772  {
        -
        9773  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        -
        9774 
        -
        9775  // 1. Process free space before this allocation.
        -
        9776  if(lastOffset < suballoc.offset)
        -
        9777  {
        -
        9778  // There is free space from lastOffset to suballoc.offset.
        -
        9779  ++unusedRangeCount;
        -
        9780  }
        -
        9781 
        -
        9782  // 2. Process this allocation.
        -
        9783  // There is allocation with suballoc.offset, suballoc.size.
        -
        9784  ++alloc1stCount;
        -
        9785  usedBytes += suballoc.size;
        -
        9786 
        -
        9787  // 3. Prepare for next iteration.
        -
        9788  lastOffset = suballoc.offset + suballoc.size;
        -
        9789  ++nextAlloc1stIndex;
        -
        9790  }
        -
        9791  // We are at the end.
        -
        9792  else
        -
        9793  {
        -
        9794  if(lastOffset < size)
        -
        9795  {
        -
        9796  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        -
        9797  ++unusedRangeCount;
        -
        9798  }
        -
        9799 
        -
        9800  // End of loop.
        -
        9801  lastOffset = freeSpace1stTo2ndEnd;
        -
        9802  }
        -
        9803  }
        -
        9804 
        -
        9805  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        9806  {
        -
        9807  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        -
        9808  while(lastOffset < size)
        -
        9809  {
        -
        9810  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        -
        9811  while(nextAlloc2ndIndex != SIZE_MAX &&
        -
        9812  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9813  {
        -
        9814  --nextAlloc2ndIndex;
        -
        9815  }
        -
        9816 
        -
        9817  // Found non-null allocation.
        -
        9818  if(nextAlloc2ndIndex != SIZE_MAX)
        -
        9819  {
        -
        9820  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9821 
        -
        9822  // 1. Process free space before this allocation.
        -
        9823  if(lastOffset < suballoc.offset)
        -
        9824  {
        -
        9825  // There is free space from lastOffset to suballoc.offset.
        -
        9826  ++unusedRangeCount;
        -
        9827  }
        -
        9828 
        -
        9829  // 2. Process this allocation.
        -
        9830  // There is allocation with suballoc.offset, suballoc.size.
        -
        9831  ++alloc2ndCount;
        -
        9832  usedBytes += suballoc.size;
        -
        9833 
        -
        9834  // 3. Prepare for next iteration.
        -
        9835  lastOffset = suballoc.offset + suballoc.size;
        -
        9836  --nextAlloc2ndIndex;
        -
        9837  }
        -
        9838  // We are at the end.
        -
        9839  else
        -
        9840  {
        -
        9841  if(lastOffset < size)
        -
        9842  {
        -
        9843  // There is free space from lastOffset to size.
        -
        9844  ++unusedRangeCount;
        -
        9845  }
        -
        9846 
        -
        9847  // End of loop.
        -
        9848  lastOffset = size;
        -
        9849  }
        -
        9850  }
        -
        9851  }
        -
        9852 
        -
        9853  const VkDeviceSize unusedBytes = size - usedBytes;
        -
        9854  PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
        -
        9855 
        -
        9856  // SECOND PASS
        -
        9857  lastOffset = 0;
        -
        9858 
        -
        9859  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        9860  {
        -
        9861  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        -
        9862  size_t nextAlloc2ndIndex = 0;
        -
        9863  while(lastOffset < freeSpace2ndTo1stEnd)
        -
        9864  {
        -
        9865  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        -
        9866  while(nextAlloc2ndIndex < suballoc2ndCount &&
        -
        9867  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9868  {
        -
        9869  ++nextAlloc2ndIndex;
        -
        9870  }
        -
        9871 
        -
        9872  // Found non-null allocation.
        -
        9873  if(nextAlloc2ndIndex < suballoc2ndCount)
        -
        9874  {
        -
        9875  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9876 
        -
        9877  // 1. Process free space before this allocation.
        -
        9878  if(lastOffset < suballoc.offset)
        -
        9879  {
        -
        9880  // There is free space from lastOffset to suballoc.offset.
        -
        9881  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9882  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        -
        9883  }
        -
        9884 
        -
        9885  // 2. Process this allocation.
        -
        9886  // There is allocation with suballoc.offset, suballoc.size.
        -
        9887  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        -
        9888 
        -
        9889  // 3. Prepare for next iteration.
        -
        9890  lastOffset = suballoc.offset + suballoc.size;
        -
        9891  ++nextAlloc2ndIndex;
        -
        9892  }
        -
        9893  // We are at the end.
        -
        9894  else
        -
        9895  {
        -
        9896  if(lastOffset < freeSpace2ndTo1stEnd)
        -
        9897  {
        -
        9898  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        -
        9899  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        -
        9900  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        -
        9901  }
        +
        9278  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
        +
        9279  }
        +
        9280 
        +
        9281  VMA_VALIDATE(offset <= GetSize());
        +
        9282  VMA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);
        +
        9283 
        +
        9284  return true;
        +
        9285 }
        +
        9286 
        +
        9287 size_t VmaBlockMetadata_Linear::GetAllocationCount() const
        +
        9288 {
        +
        9289  return AccessSuballocations1st().size() - (m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount) +
        +
        9290  AccessSuballocations2nd().size() - m_2ndNullItemsCount;
        +
        9291 }
        +
        9292 
        +
        9293 VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const
        +
        9294 {
        +
        9295  const VkDeviceSize size = GetSize();
        +
        9296 
        +
        9297  /*
        +
        9298  We don't consider gaps inside allocation vectors with freed allocations because
        +
        9299  they are not suitable for reuse in linear allocator. We consider only space that
        +
        9300  is available for new allocations.
        +
        9301  */
        +
        9302  if(IsEmpty())
        +
        9303  {
        +
        9304  return size;
        +
        9305  }
        +
        9306 
        +
        9307  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        9308 
        +
        9309  switch(m_2ndVectorMode)
        +
        9310  {
        +
        9311  case SECOND_VECTOR_EMPTY:
        +
        9312  /*
        +
        9313  Available space is after end of 1st, as well as before beginning of 1st (which
        +
        9314  whould make it a ring buffer).
        +
        9315  */
        +
        9316  {
        +
        9317  const size_t suballocations1stCount = suballocations1st.size();
        +
        9318  VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);
        +
        9319  const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        +
        9320  const VmaSuballocation& lastSuballoc = suballocations1st[suballocations1stCount - 1];
        +
        9321  return VMA_MAX(
        +
        9322  firstSuballoc.offset,
        +
        9323  size - (lastSuballoc.offset + lastSuballoc.size));
        +
        9324  }
        +
        9325  break;
        +
        9326 
        +
        9327  case SECOND_VECTOR_RING_BUFFER:
        +
        9328  /*
        +
        9329  Available space is only between end of 2nd and beginning of 1st.
        +
        9330  */
        +
        9331  {
        +
        9332  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        9333  const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();
        +
        9334  const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];
        +
        9335  return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);
        +
        9336  }
        +
        9337  break;
        +
        9338 
        +
        9339  case SECOND_VECTOR_DOUBLE_STACK:
        +
        9340  /*
        +
        9341  Available space is only between end of 1st and top of 2nd.
        +
        9342  */
        +
        9343  {
        +
        9344  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        9345  const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();
        +
        9346  const VmaSuballocation& lastSuballoc1st = suballocations1st.back();
        +
        9347  return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);
        +
        9348  }
        +
        9349  break;
        +
        9350 
        +
        9351  default:
        +
        9352  VMA_ASSERT(0);
        +
        9353  return 0;
        +
        9354  }
        +
        9355 }
        +
        9356 
        +
        9357 void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        +
        9358 {
        +
        9359  const VkDeviceSize size = GetSize();
        +
        9360  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        9361  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        9362  const size_t suballoc1stCount = suballocations1st.size();
        +
        9363  const size_t suballoc2ndCount = suballocations2nd.size();
        +
        9364 
        +
        9365  outInfo.blockCount = 1;
        +
        9366  outInfo.allocationCount = (uint32_t)GetAllocationCount();
        +
        9367  outInfo.unusedRangeCount = 0;
        +
        9368  outInfo.usedBytes = 0;
        +
        9369  outInfo.allocationSizeMin = UINT64_MAX;
        +
        9370  outInfo.allocationSizeMax = 0;
        +
        9371  outInfo.unusedRangeSizeMin = UINT64_MAX;
        +
        9372  outInfo.unusedRangeSizeMax = 0;
        +
        9373 
        +
        9374  VkDeviceSize lastOffset = 0;
        +
        9375 
        +
        9376  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        9377  {
        +
        9378  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        +
        9379  size_t nextAlloc2ndIndex = 0;
        +
        9380  while(lastOffset < freeSpace2ndTo1stEnd)
        +
        9381  {
        +
        9382  // Find next non-null allocation or move nextAllocIndex to the end.
        +
        9383  while(nextAlloc2ndIndex < suballoc2ndCount &&
        +
        9384  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9385  {
        +
        9386  ++nextAlloc2ndIndex;
        +
        9387  }
        +
        9388 
        +
        9389  // Found non-null allocation.
        +
        9390  if(nextAlloc2ndIndex < suballoc2ndCount)
        +
        9391  {
        +
        9392  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        9393 
        +
        9394  // 1. Process free space before this allocation.
        +
        9395  if(lastOffset < suballoc.offset)
        +
        9396  {
        +
        9397  // There is free space from lastOffset to suballoc.offset.
        +
        9398  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9399  ++outInfo.unusedRangeCount;
        +
        9400  outInfo.unusedBytes += unusedRangeSize;
        +
        9401  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        +
        9402  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        +
        9403  }
        +
        9404 
        +
        9405  // 2. Process this allocation.
        +
        9406  // There is allocation with suballoc.offset, suballoc.size.
        +
        9407  outInfo.usedBytes += suballoc.size;
        +
        9408  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        +
        9409  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        +
        9410 
        +
        9411  // 3. Prepare for next iteration.
        +
        9412  lastOffset = suballoc.offset + suballoc.size;
        +
        9413  ++nextAlloc2ndIndex;
        +
        9414  }
        +
        9415  // We are at the end.
        +
        9416  else
        +
        9417  {
        +
        9418  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        +
        9419  if(lastOffset < freeSpace2ndTo1stEnd)
        +
        9420  {
        +
        9421  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        +
        9422  ++outInfo.unusedRangeCount;
        +
        9423  outInfo.unusedBytes += unusedRangeSize;
        +
        9424  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        +
        9425  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        +
        9426  }
        +
        9427 
        +
        9428  // End of loop.
        +
        9429  lastOffset = freeSpace2ndTo1stEnd;
        +
        9430  }
        +
        9431  }
        +
        9432  }
        +
        9433 
        +
        9434  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        +
        9435  const VkDeviceSize freeSpace1stTo2ndEnd =
        +
        9436  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        +
        9437  while(lastOffset < freeSpace1stTo2ndEnd)
        +
        9438  {
        +
        9439  // Find next non-null allocation or move nextAllocIndex to the end.
        +
        9440  while(nextAlloc1stIndex < suballoc1stCount &&
        +
        9441  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        +
        9442  {
        +
        9443  ++nextAlloc1stIndex;
        +
        9444  }
        +
        9445 
        +
        9446  // Found non-null allocation.
        +
        9447  if(nextAlloc1stIndex < suballoc1stCount)
        +
        9448  {
        +
        9449  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        +
        9450 
        +
        9451  // 1. Process free space before this allocation.
        +
        9452  if(lastOffset < suballoc.offset)
        +
        9453  {
        +
        9454  // There is free space from lastOffset to suballoc.offset.
        +
        9455  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9456  ++outInfo.unusedRangeCount;
        +
        9457  outInfo.unusedBytes += unusedRangeSize;
        +
        9458  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        +
        9459  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        +
        9460  }
        +
        9461 
        +
        9462  // 2. Process this allocation.
        +
        9463  // There is allocation with suballoc.offset, suballoc.size.
        +
        9464  outInfo.usedBytes += suballoc.size;
        +
        9465  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        +
        9466  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        +
        9467 
        +
        9468  // 3. Prepare for next iteration.
        +
        9469  lastOffset = suballoc.offset + suballoc.size;
        +
        9470  ++nextAlloc1stIndex;
        +
        9471  }
        +
        9472  // We are at the end.
        +
        9473  else
        +
        9474  {
        +
        9475  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        +
        9476  if(lastOffset < freeSpace1stTo2ndEnd)
        +
        9477  {
        +
        9478  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        +
        9479  ++outInfo.unusedRangeCount;
        +
        9480  outInfo.unusedBytes += unusedRangeSize;
        +
        9481  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        +
        9482  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        +
        9483  }
        +
        9484 
        +
        9485  // End of loop.
        +
        9486  lastOffset = freeSpace1stTo2ndEnd;
        +
        9487  }
        +
        9488  }
        +
        9489 
        +
        9490  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        9491  {
        +
        9492  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        +
        9493  while(lastOffset < size)
        +
        9494  {
        +
        9495  // Find next non-null allocation or move nextAllocIndex to the end.
        +
        9496  while(nextAlloc2ndIndex != SIZE_MAX &&
        +
        9497  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9498  {
        +
        9499  --nextAlloc2ndIndex;
        +
        9500  }
        +
        9501 
        +
        9502  // Found non-null allocation.
        +
        9503  if(nextAlloc2ndIndex != SIZE_MAX)
        +
        9504  {
        +
        9505  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        9506 
        +
        9507  // 1. Process free space before this allocation.
        +
        9508  if(lastOffset < suballoc.offset)
        +
        9509  {
        +
        9510  // There is free space from lastOffset to suballoc.offset.
        +
        9511  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9512  ++outInfo.unusedRangeCount;
        +
        9513  outInfo.unusedBytes += unusedRangeSize;
        +
        9514  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        +
        9515  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        +
        9516  }
        +
        9517 
        +
        9518  // 2. Process this allocation.
        +
        9519  // There is allocation with suballoc.offset, suballoc.size.
        +
        9520  outInfo.usedBytes += suballoc.size;
        +
        9521  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        +
        9522  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        +
        9523 
        +
        9524  // 3. Prepare for next iteration.
        +
        9525  lastOffset = suballoc.offset + suballoc.size;
        +
        9526  --nextAlloc2ndIndex;
        +
        9527  }
        +
        9528  // We are at the end.
        +
        9529  else
        +
        9530  {
        +
        9531  // There is free space from lastOffset to size.
        +
        9532  if(lastOffset < size)
        +
        9533  {
        +
        9534  const VkDeviceSize unusedRangeSize = size - lastOffset;
        +
        9535  ++outInfo.unusedRangeCount;
        +
        9536  outInfo.unusedBytes += unusedRangeSize;
        +
        9537  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        +
        9538  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        +
        9539  }
        +
        9540 
        +
        9541  // End of loop.
        +
        9542  lastOffset = size;
        +
        9543  }
        +
        9544  }
        +
        9545  }
        +
        9546 
        +
        9547  outInfo.unusedBytes = size - outInfo.usedBytes;
        +
        9548 }
        +
        9549 
        +
        9550 void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& inoutStats) const
        +
        9551 {
        +
        9552  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        9553  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        9554  const VkDeviceSize size = GetSize();
        +
        9555  const size_t suballoc1stCount = suballocations1st.size();
        +
        9556  const size_t suballoc2ndCount = suballocations2nd.size();
        +
        9557 
        +
        9558  inoutStats.size += size;
        +
        9559 
        +
        9560  VkDeviceSize lastOffset = 0;
        +
        9561 
        +
        9562  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        9563  {
        +
        9564  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        +
        9565  size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
        +
        9566  while(lastOffset < freeSpace2ndTo1stEnd)
        +
        9567  {
        +
        9568  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        +
        9569  while(nextAlloc2ndIndex < suballoc2ndCount &&
        +
        9570  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9571  {
        +
        9572  ++nextAlloc2ndIndex;
        +
        9573  }
        +
        9574 
        +
        9575  // Found non-null allocation.
        +
        9576  if(nextAlloc2ndIndex < suballoc2ndCount)
        +
        9577  {
        +
        9578  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        9579 
        +
        9580  // 1. Process free space before this allocation.
        +
        9581  if(lastOffset < suballoc.offset)
        +
        9582  {
        +
        9583  // There is free space from lastOffset to suballoc.offset.
        +
        9584  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9585  inoutStats.unusedSize += unusedRangeSize;
        +
        9586  ++inoutStats.unusedRangeCount;
        +
        9587  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        +
        9588  }
        +
        9589 
        +
        9590  // 2. Process this allocation.
        +
        9591  // There is allocation with suballoc.offset, suballoc.size.
        +
        9592  ++inoutStats.allocationCount;
        +
        9593 
        +
        9594  // 3. Prepare for next iteration.
        +
        9595  lastOffset = suballoc.offset + suballoc.size;
        +
        9596  ++nextAlloc2ndIndex;
        +
        9597  }
        +
        9598  // We are at the end.
        +
        9599  else
        +
        9600  {
        +
        9601  if(lastOffset < freeSpace2ndTo1stEnd)
        +
        9602  {
        +
        9603  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        +
        9604  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        +
        9605  inoutStats.unusedSize += unusedRangeSize;
        +
        9606  ++inoutStats.unusedRangeCount;
        +
        9607  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        +
        9608  }
        +
        9609 
        +
        9610  // End of loop.
        +
        9611  lastOffset = freeSpace2ndTo1stEnd;
        +
        9612  }
        +
        9613  }
        +
        9614  }
        +
        9615 
        +
        9616  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        +
        9617  const VkDeviceSize freeSpace1stTo2ndEnd =
        +
        9618  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        +
        9619  while(lastOffset < freeSpace1stTo2ndEnd)
        +
        9620  {
        +
        9621  // Find next non-null allocation or move nextAllocIndex to the end.
        +
        9622  while(nextAlloc1stIndex < suballoc1stCount &&
        +
        9623  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        +
        9624  {
        +
        9625  ++nextAlloc1stIndex;
        +
        9626  }
        +
        9627 
        +
        9628  // Found non-null allocation.
        +
        9629  if(nextAlloc1stIndex < suballoc1stCount)
        +
        9630  {
        +
        9631  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        +
        9632 
        +
        9633  // 1. Process free space before this allocation.
        +
        9634  if(lastOffset < suballoc.offset)
        +
        9635  {
        +
        9636  // There is free space from lastOffset to suballoc.offset.
        +
        9637  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9638  inoutStats.unusedSize += unusedRangeSize;
        +
        9639  ++inoutStats.unusedRangeCount;
        +
        9640  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        +
        9641  }
        +
        9642 
        +
        9643  // 2. Process this allocation.
        +
        9644  // There is allocation with suballoc.offset, suballoc.size.
        +
        9645  ++inoutStats.allocationCount;
        +
        9646 
        +
        9647  // 3. Prepare for next iteration.
        +
        9648  lastOffset = suballoc.offset + suballoc.size;
        +
        9649  ++nextAlloc1stIndex;
        +
        9650  }
        +
        9651  // We are at the end.
        +
        9652  else
        +
        9653  {
        +
        9654  if(lastOffset < freeSpace1stTo2ndEnd)
        +
        9655  {
        +
        9656  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        +
        9657  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        +
        9658  inoutStats.unusedSize += unusedRangeSize;
        +
        9659  ++inoutStats.unusedRangeCount;
        +
        9660  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        +
        9661  }
        +
        9662 
        +
        9663  // End of loop.
        +
        9664  lastOffset = freeSpace1stTo2ndEnd;
        +
        9665  }
        +
        9666  }
        +
        9667 
        +
        9668  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        9669  {
        +
        9670  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        +
        9671  while(lastOffset < size)
        +
        9672  {
        +
        9673  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        +
        9674  while(nextAlloc2ndIndex != SIZE_MAX &&
        +
        9675  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9676  {
        +
        9677  --nextAlloc2ndIndex;
        +
        9678  }
        +
        9679 
        +
        9680  // Found non-null allocation.
        +
        9681  if(nextAlloc2ndIndex != SIZE_MAX)
        +
        9682  {
        +
        9683  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        9684 
        +
        9685  // 1. Process free space before this allocation.
        +
        9686  if(lastOffset < suballoc.offset)
        +
        9687  {
        +
        9688  // There is free space from lastOffset to suballoc.offset.
        +
        9689  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9690  inoutStats.unusedSize += unusedRangeSize;
        +
        9691  ++inoutStats.unusedRangeCount;
        +
        9692  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        +
        9693  }
        +
        9694 
        +
        9695  // 2. Process this allocation.
        +
        9696  // There is allocation with suballoc.offset, suballoc.size.
        +
        9697  ++inoutStats.allocationCount;
        +
        9698 
        +
        9699  // 3. Prepare for next iteration.
        +
        9700  lastOffset = suballoc.offset + suballoc.size;
        +
        9701  --nextAlloc2ndIndex;
        +
        9702  }
        +
        9703  // We are at the end.
        +
        9704  else
        +
        9705  {
        +
        9706  if(lastOffset < size)
        +
        9707  {
        +
        9708  // There is free space from lastOffset to size.
        +
        9709  const VkDeviceSize unusedRangeSize = size - lastOffset;
        +
        9710  inoutStats.unusedSize += unusedRangeSize;
        +
        9711  ++inoutStats.unusedRangeCount;
        +
        9712  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        +
        9713  }
        +
        9714 
        +
        9715  // End of loop.
        +
        9716  lastOffset = size;
        +
        9717  }
        +
        9718  }
        +
        9719  }
        +
        9720 }
        +
        9721 
        +
        9722 #if VMA_STATS_STRING_ENABLED
        +
        9723 void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
        +
        9724 {
        +
        9725  const VkDeviceSize size = GetSize();
        +
        9726  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        9727  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        9728  const size_t suballoc1stCount = suballocations1st.size();
        +
        9729  const size_t suballoc2ndCount = suballocations2nd.size();
        +
        9730 
        +
        9731  // FIRST PASS
        +
        9732 
        +
        9733  size_t unusedRangeCount = 0;
        +
        9734  VkDeviceSize usedBytes = 0;
        +
        9735 
        +
        9736  VkDeviceSize lastOffset = 0;
        +
        9737 
        +
        9738  size_t alloc2ndCount = 0;
        +
        9739  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        9740  {
        +
        9741  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        +
        9742  size_t nextAlloc2ndIndex = 0;
        +
        9743  while(lastOffset < freeSpace2ndTo1stEnd)
        +
        9744  {
        +
        9745  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        +
        9746  while(nextAlloc2ndIndex < suballoc2ndCount &&
        +
        9747  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9748  {
        +
        9749  ++nextAlloc2ndIndex;
        +
        9750  }
        +
        9751 
        +
        9752  // Found non-null allocation.
        +
        9753  if(nextAlloc2ndIndex < suballoc2ndCount)
        +
        9754  {
        +
        9755  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        9756 
        +
        9757  // 1. Process free space before this allocation.
        +
        9758  if(lastOffset < suballoc.offset)
        +
        9759  {
        +
        9760  // There is free space from lastOffset to suballoc.offset.
        +
        9761  ++unusedRangeCount;
        +
        9762  }
        +
        9763 
        +
        9764  // 2. Process this allocation.
        +
        9765  // There is allocation with suballoc.offset, suballoc.size.
        +
        9766  ++alloc2ndCount;
        +
        9767  usedBytes += suballoc.size;
        +
        9768 
        +
        9769  // 3. Prepare for next iteration.
        +
        9770  lastOffset = suballoc.offset + suballoc.size;
        +
        9771  ++nextAlloc2ndIndex;
        +
        9772  }
        +
        9773  // We are at the end.
        +
        9774  else
        +
        9775  {
        +
        9776  if(lastOffset < freeSpace2ndTo1stEnd)
        +
        9777  {
        +
        9778  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        +
        9779  ++unusedRangeCount;
        +
        9780  }
        +
        9781 
        +
        9782  // End of loop.
        +
        9783  lastOffset = freeSpace2ndTo1stEnd;
        +
        9784  }
        +
        9785  }
        +
        9786  }
        +
        9787 
        +
        9788  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        +
        9789  size_t alloc1stCount = 0;
        +
        9790  const VkDeviceSize freeSpace1stTo2ndEnd =
        +
        9791  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        +
        9792  while(lastOffset < freeSpace1stTo2ndEnd)
        +
        9793  {
        +
        9794  // Find next non-null allocation or move nextAllocIndex to the end.
        +
        9795  while(nextAlloc1stIndex < suballoc1stCount &&
        +
        9796  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        +
        9797  {
        +
        9798  ++nextAlloc1stIndex;
        +
        9799  }
        +
        9800 
        +
        9801  // Found non-null allocation.
        +
        9802  if(nextAlloc1stIndex < suballoc1stCount)
        +
        9803  {
        +
        9804  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        +
        9805 
        +
        9806  // 1. Process free space before this allocation.
        +
        9807  if(lastOffset < suballoc.offset)
        +
        9808  {
        +
        9809  // There is free space from lastOffset to suballoc.offset.
        +
        9810  ++unusedRangeCount;
        +
        9811  }
        +
        9812 
        +
        9813  // 2. Process this allocation.
        +
        9814  // There is allocation with suballoc.offset, suballoc.size.
        +
        9815  ++alloc1stCount;
        +
        9816  usedBytes += suballoc.size;
        +
        9817 
        +
        9818  // 3. Prepare for next iteration.
        +
        9819  lastOffset = suballoc.offset + suballoc.size;
        +
        9820  ++nextAlloc1stIndex;
        +
        9821  }
        +
        9822  // We are at the end.
        +
        9823  else
        +
        9824  {
        +
        9825  if(lastOffset < size)
        +
        9826  {
        +
        9827  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        +
        9828  ++unusedRangeCount;
        +
        9829  }
        +
        9830 
        +
        9831  // End of loop.
        +
        9832  lastOffset = freeSpace1stTo2ndEnd;
        +
        9833  }
        +
        9834  }
        +
        9835 
        +
        9836  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        9837  {
        +
        9838  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        +
        9839  while(lastOffset < size)
        +
        9840  {
        +
        9841  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        +
        9842  while(nextAlloc2ndIndex != SIZE_MAX &&
        +
        9843  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9844  {
        +
        9845  --nextAlloc2ndIndex;
        +
        9846  }
        +
        9847 
        +
        9848  // Found non-null allocation.
        +
        9849  if(nextAlloc2ndIndex != SIZE_MAX)
        +
        9850  {
        +
        9851  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        9852 
        +
        9853  // 1. Process free space before this allocation.
        +
        9854  if(lastOffset < suballoc.offset)
        +
        9855  {
        +
        9856  // There is free space from lastOffset to suballoc.offset.
        +
        9857  ++unusedRangeCount;
        +
        9858  }
        +
        9859 
        +
        9860  // 2. Process this allocation.
        +
        9861  // There is allocation with suballoc.offset, suballoc.size.
        +
        9862  ++alloc2ndCount;
        +
        9863  usedBytes += suballoc.size;
        +
        9864 
        +
        9865  // 3. Prepare for next iteration.
        +
        9866  lastOffset = suballoc.offset + suballoc.size;
        +
        9867  --nextAlloc2ndIndex;
        +
        9868  }
        +
        9869  // We are at the end.
        +
        9870  else
        +
        9871  {
        +
        9872  if(lastOffset < size)
        +
        9873  {
        +
        9874  // There is free space from lastOffset to size.
        +
        9875  ++unusedRangeCount;
        +
        9876  }
        +
        9877 
        +
        9878  // End of loop.
        +
        9879  lastOffset = size;
        +
        9880  }
        +
        9881  }
        +
        9882  }
        +
        9883 
        +
        9884  const VkDeviceSize unusedBytes = size - usedBytes;
        +
        9885  PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
        +
        9886 
        +
        9887  // SECOND PASS
        +
        9888  lastOffset = 0;
        +
        9889 
        +
        9890  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        9891  {
        +
        9892  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        +
        9893  size_t nextAlloc2ndIndex = 0;
        +
        9894  while(lastOffset < freeSpace2ndTo1stEnd)
        +
        9895  {
        +
        9896  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        +
        9897  while(nextAlloc2ndIndex < suballoc2ndCount &&
        +
        9898  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9899  {
        +
        9900  ++nextAlloc2ndIndex;
        +
        9901  }
        9902 
        -
        9903  // End of loop.
        -
        9904  lastOffset = freeSpace2ndTo1stEnd;
        -
        9905  }
        -
        9906  }
        -
        9907  }
        -
        9908 
        -
        9909  nextAlloc1stIndex = m_1stNullItemsBeginCount;
        -
        9910  while(lastOffset < freeSpace1stTo2ndEnd)
        -
        9911  {
        -
        9912  // Find next non-null allocation or move nextAllocIndex to the end.
        -
        9913  while(nextAlloc1stIndex < suballoc1stCount &&
        -
        9914  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        -
        9915  {
        -
        9916  ++nextAlloc1stIndex;
        -
        9917  }
        -
        9918 
        -
        9919  // Found non-null allocation.
        -
        9920  if(nextAlloc1stIndex < suballoc1stCount)
        -
        9921  {
        -
        9922  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        -
        9923 
        -
        9924  // 1. Process free space before this allocation.
        -
        9925  if(lastOffset < suballoc.offset)
        +
        9903  // Found non-null allocation.
        +
        9904  if(nextAlloc2ndIndex < suballoc2ndCount)
        +
        9905  {
        +
        9906  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        9907 
        +
        9908  // 1. Process free space before this allocation.
        +
        9909  if(lastOffset < suballoc.offset)
        +
        9910  {
        +
        9911  // There is free space from lastOffset to suballoc.offset.
        +
        9912  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9913  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        +
        9914  }
        +
        9915 
        +
        9916  // 2. Process this allocation.
        +
        9917  // There is allocation with suballoc.offset, suballoc.size.
        +
        9918  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        +
        9919 
        +
        9920  // 3. Prepare for next iteration.
        +
        9921  lastOffset = suballoc.offset + suballoc.size;
        +
        9922  ++nextAlloc2ndIndex;
        +
        9923  }
        +
        9924  // We are at the end.
        +
        9925  else
        9926  {
        -
        9927  // There is free space from lastOffset to suballoc.offset.
        -
        9928  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9929  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        -
        9930  }
        -
        9931 
        -
        9932  // 2. Process this allocation.
        -
        9933  // There is allocation with suballoc.offset, suballoc.size.
        -
        9934  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        -
        9935 
        -
        9936  // 3. Prepare for next iteration.
        -
        9937  lastOffset = suballoc.offset + suballoc.size;
        -
        9938  ++nextAlloc1stIndex;
        -
        9939  }
        -
        9940  // We are at the end.
        -
        9941  else
        -
        9942  {
        -
        9943  if(lastOffset < freeSpace1stTo2ndEnd)
        -
        9944  {
        -
        9945  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        -
        9946  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        -
        9947  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        -
        9948  }
        +
        9927  if(lastOffset < freeSpace2ndTo1stEnd)
        +
        9928  {
        +
        9929  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        +
        9930  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        +
        9931  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        +
        9932  }
        +
        9933 
        +
        9934  // End of loop.
        +
        9935  lastOffset = freeSpace2ndTo1stEnd;
        +
        9936  }
        +
        9937  }
        +
        9938  }
        +
        9939 
        +
        9940  nextAlloc1stIndex = m_1stNullItemsBeginCount;
        +
        9941  while(lastOffset < freeSpace1stTo2ndEnd)
        +
        9942  {
        +
        9943  // Find next non-null allocation or move nextAllocIndex to the end.
        +
        9944  while(nextAlloc1stIndex < suballoc1stCount &&
        +
        9945  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        +
        9946  {
        +
        9947  ++nextAlloc1stIndex;
        +
        9948  }
        9949 
        -
        9950  // End of loop.
        -
        9951  lastOffset = freeSpace1stTo2ndEnd;
        -
        9952  }
        -
        9953  }
        -
        9954 
        -
        9955  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        9956  {
        -
        9957  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        -
        9958  while(lastOffset < size)
        -
        9959  {
        -
        9960  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        -
        9961  while(nextAlloc2ndIndex != SIZE_MAX &&
        -
        9962  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        -
        9963  {
        -
        9964  --nextAlloc2ndIndex;
        -
        9965  }
        -
        9966 
        -
        9967  // Found non-null allocation.
        -
        9968  if(nextAlloc2ndIndex != SIZE_MAX)
        -
        9969  {
        -
        9970  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        -
        9971 
        -
        9972  // 1. Process free space before this allocation.
        -
        9973  if(lastOffset < suballoc.offset)
        -
        9974  {
        -
        9975  // There is free space from lastOffset to suballoc.offset.
        -
        9976  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        -
        9977  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        -
        9978  }
        -
        9979 
        -
        9980  // 2. Process this allocation.
        -
        9981  // There is allocation with suballoc.offset, suballoc.size.
        -
        9982  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        -
        9983 
        -
        9984  // 3. Prepare for next iteration.
        -
        9985  lastOffset = suballoc.offset + suballoc.size;
        -
        9986  --nextAlloc2ndIndex;
        -
        9987  }
        -
        9988  // We are at the end.
        -
        9989  else
        -
        9990  {
        -
        9991  if(lastOffset < size)
        -
        9992  {
        -
        9993  // There is free space from lastOffset to size.
        -
        9994  const VkDeviceSize unusedRangeSize = size - lastOffset;
        -
        9995  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        -
        9996  }
        +
        9950  // Found non-null allocation.
        +
        9951  if(nextAlloc1stIndex < suballoc1stCount)
        +
        9952  {
        +
        9953  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        +
        9954 
        +
        9955  // 1. Process free space before this allocation.
        +
        9956  if(lastOffset < suballoc.offset)
        +
        9957  {
        +
        9958  // There is free space from lastOffset to suballoc.offset.
        +
        9959  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        9960  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        +
        9961  }
        +
        9962 
        +
        9963  // 2. Process this allocation.
        +
        9964  // There is allocation with suballoc.offset, suballoc.size.
        +
        9965  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        +
        9966 
        +
        9967  // 3. Prepare for next iteration.
        +
        9968  lastOffset = suballoc.offset + suballoc.size;
        +
        9969  ++nextAlloc1stIndex;
        +
        9970  }
        +
        9971  // We are at the end.
        +
        9972  else
        +
        9973  {
        +
        9974  if(lastOffset < freeSpace1stTo2ndEnd)
        +
        9975  {
        +
        9976  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        +
        9977  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        +
        9978  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        +
        9979  }
        +
        9980 
        +
        9981  // End of loop.
        +
        9982  lastOffset = freeSpace1stTo2ndEnd;
        +
        9983  }
        +
        9984  }
        +
        9985 
        +
        9986  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        9987  {
        +
        9988  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        +
        9989  while(lastOffset < size)
        +
        9990  {
        +
        9991  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        +
        9992  while(nextAlloc2ndIndex != SIZE_MAX &&
        +
        9993  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        +
        9994  {
        +
        9995  --nextAlloc2ndIndex;
        +
        9996  }
        9997 
        -
        9998  // End of loop.
        -
        9999  lastOffset = size;
        -
        10000  }
        -
        10001  }
        -
        10002  }
        -
        10003 
        -
        10004  PrintDetailedMap_End(json);
        -
        10005 }
        -
        10006 #endif // #if VMA_STATS_STRING_ENABLED
        -
        10007 
        -
        10008 bool VmaBlockMetadata_Linear::CreateAllocationRequest(
        -
        10009  uint32_t currentFrameIndex,
        -
        10010  uint32_t frameInUseCount,
        -
        10011  VkDeviceSize bufferImageGranularity,
        -
        10012  VkDeviceSize allocSize,
        -
        10013  VkDeviceSize allocAlignment,
        -
        10014  bool upperAddress,
        -
        10015  VmaSuballocationType allocType,
        -
        10016  bool canMakeOtherLost,
        -
        10017  uint32_t strategy,
        -
        10018  VmaAllocationRequest* pAllocationRequest)
        -
        10019 {
        -
        10020  VMA_ASSERT(allocSize > 0);
        -
        10021  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        -
        10022  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        -
        10023  VMA_HEAVY_ASSERT(Validate());
        -
        10024  return upperAddress ?
        -
        10025  CreateAllocationRequest_UpperAddress(
        -
        10026  currentFrameIndex, frameInUseCount, bufferImageGranularity,
        -
        10027  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest) :
        -
        10028  CreateAllocationRequest_LowerAddress(
        -
        10029  currentFrameIndex, frameInUseCount, bufferImageGranularity,
        -
        10030  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest);
        -
        10031 }
        -
        10032 
        -
        10033 bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
        -
        10034  uint32_t currentFrameIndex,
        -
        10035  uint32_t frameInUseCount,
        -
        10036  VkDeviceSize bufferImageGranularity,
        -
        10037  VkDeviceSize allocSize,
        -
        10038  VkDeviceSize allocAlignment,
        -
        10039  VmaSuballocationType allocType,
        -
        10040  bool canMakeOtherLost,
        -
        10041  uint32_t strategy,
        -
        10042  VmaAllocationRequest* pAllocationRequest)
        -
        10043 {
        -
        10044  const VkDeviceSize size = GetSize();
        -
        10045  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10046  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        10047 
        -
        10048  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        10049  {
        -
        10050  VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
        -
        10051  return false;
        -
        10052  }
        -
        10053 
        -
        10054  // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
        -
        10055  if(allocSize > size)
        -
        10056  {
        -
        10057  return false;
        -
        10058  }
        -
        10059  VkDeviceSize resultBaseOffset = size - allocSize;
        -
        10060  if(!suballocations2nd.empty())
        -
        10061  {
        -
        10062  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        -
        10063  resultBaseOffset = lastSuballoc.offset - allocSize;
        -
        10064  if(allocSize > lastSuballoc.offset)
        -
        10065  {
        -
        10066  return false;
        -
        10067  }
        -
        10068  }
        -
        10069 
        -
        10070  // Start from offset equal to end of free space.
        -
        10071  VkDeviceSize resultOffset = resultBaseOffset;
        -
        10072 
        -
        10073  // Apply VMA_DEBUG_MARGIN at the end.
        -
        10074  if(VMA_DEBUG_MARGIN > 0)
        -
        10075  {
        -
        10076  if(resultOffset < VMA_DEBUG_MARGIN)
        -
        10077  {
        -
        10078  return false;
        -
        10079  }
        -
        10080  resultOffset -= VMA_DEBUG_MARGIN;
        -
        10081  }
        -
        10082 
        -
        10083  // Apply alignment.
        -
        10084  resultOffset = VmaAlignDown(resultOffset, allocAlignment);
        -
        10085 
        -
        10086  // Check next suballocations from 2nd for BufferImageGranularity conflicts.
        -
        10087  // Make bigger alignment if necessary.
        -
        10088  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        -
        10089  {
        -
        10090  bool bufferImageGranularityConflict = false;
        -
        10091  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        -
        10092  {
        -
        10093  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        -
        10094  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        -
        10095  {
        -
        10096  if(VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
        -
        10097  {
        -
        10098  bufferImageGranularityConflict = true;
        -
        10099  break;
        -
        10100  }
        -
        10101  }
        -
        10102  else
        -
        10103  // Already on previous page.
        -
        10104  break;
        -
        10105  }
        -
        10106  if(bufferImageGranularityConflict)
        -
        10107  {
        -
        10108  resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
        -
        10109  }
        -
        10110  }
        -
        10111 
        -
        10112  // There is enough free space.
        -
        10113  const VkDeviceSize endOf1st = !suballocations1st.empty() ?
        -
        10114  suballocations1st.back().offset + suballocations1st.back().size :
        -
        10115  0;
        -
        10116  if(endOf1st + VMA_DEBUG_MARGIN <= resultOffset)
        -
        10117  {
        -
        10118  // Check previous suballocations for BufferImageGranularity conflicts.
        -
        10119  // If conflict exists, allocation cannot be made here.
        -
        10120  if(bufferImageGranularity > 1)
        -
        10121  {
        -
        10122  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        -
        10123  {
        -
        10124  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        -
        10125  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        -
        10126  {
        -
        10127  if(VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
        -
        10128  {
        -
        10129  return false;
        -
        10130  }
        +
        9998  // Found non-null allocation.
        +
        9999  if(nextAlloc2ndIndex != SIZE_MAX)
        +
        10000  {
        +
        10001  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        +
        10002 
        +
        10003  // 1. Process free space before this allocation.
        +
        10004  if(lastOffset < suballoc.offset)
        +
        10005  {
        +
        10006  // There is free space from lastOffset to suballoc.offset.
        +
        10007  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        +
        10008  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        +
        10009  }
        +
        10010 
        +
        10011  // 2. Process this allocation.
        +
        10012  // There is allocation with suballoc.offset, suballoc.size.
        +
        10013  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        +
        10014 
        +
        10015  // 3. Prepare for next iteration.
        +
        10016  lastOffset = suballoc.offset + suballoc.size;
        +
        10017  --nextAlloc2ndIndex;
        +
        10018  }
        +
        10019  // We are at the end.
        +
        10020  else
        +
        10021  {
        +
        10022  if(lastOffset < size)
        +
        10023  {
        +
        10024  // There is free space from lastOffset to size.
        +
        10025  const VkDeviceSize unusedRangeSize = size - lastOffset;
        +
        10026  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        +
        10027  }
        +
        10028 
        +
        10029  // End of loop.
        +
        10030  lastOffset = size;
        +
        10031  }
        +
        10032  }
        +
        10033  }
        +
        10034 
        +
        10035  PrintDetailedMap_End(json);
        +
        10036 }
        +
        10037 #endif // #if VMA_STATS_STRING_ENABLED
        +
        10038 
        +
        10039 bool VmaBlockMetadata_Linear::CreateAllocationRequest(
        +
        10040  uint32_t currentFrameIndex,
        +
        10041  uint32_t frameInUseCount,
        +
        10042  VkDeviceSize bufferImageGranularity,
        +
        10043  VkDeviceSize allocSize,
        +
        10044  VkDeviceSize allocAlignment,
        +
        10045  bool upperAddress,
        +
        10046  VmaSuballocationType allocType,
        +
        10047  bool canMakeOtherLost,
        +
        10048  uint32_t strategy,
        +
        10049  VmaAllocationRequest* pAllocationRequest)
        +
        10050 {
        +
        10051  VMA_ASSERT(allocSize > 0);
        +
        10052  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        +
        10053  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        +
        10054  VMA_HEAVY_ASSERT(Validate());
        +
        10055  return upperAddress ?
        +
        10056  CreateAllocationRequest_UpperAddress(
        +
        10057  currentFrameIndex, frameInUseCount, bufferImageGranularity,
        +
        10058  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest) :
        +
        10059  CreateAllocationRequest_LowerAddress(
        +
        10060  currentFrameIndex, frameInUseCount, bufferImageGranularity,
        +
        10061  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest);
        +
        10062 }
        +
        10063 
        +
        10064 bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
        +
        10065  uint32_t currentFrameIndex,
        +
        10066  uint32_t frameInUseCount,
        +
        10067  VkDeviceSize bufferImageGranularity,
        +
        10068  VkDeviceSize allocSize,
        +
        10069  VkDeviceSize allocAlignment,
        +
        10070  VmaSuballocationType allocType,
        +
        10071  bool canMakeOtherLost,
        +
        10072  uint32_t strategy,
        +
        10073  VmaAllocationRequest* pAllocationRequest)
        +
        10074 {
        +
        10075  const VkDeviceSize size = GetSize();
        +
        10076  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10077  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10078 
        +
        10079  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        10080  {
        +
        10081  VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
        +
        10082  return false;
        +
        10083  }
        +
        10084 
        +
        10085  // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
        +
        10086  if(allocSize > size)
        +
        10087  {
        +
        10088  return false;
        +
        10089  }
        +
        10090  VkDeviceSize resultBaseOffset = size - allocSize;
        +
        10091  if(!suballocations2nd.empty())
        +
        10092  {
        +
        10093  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        +
        10094  resultBaseOffset = lastSuballoc.offset - allocSize;
        +
        10095  if(allocSize > lastSuballoc.offset)
        +
        10096  {
        +
        10097  return false;
        +
        10098  }
        +
        10099  }
        +
        10100 
        +
        10101  // Start from offset equal to end of free space.
        +
        10102  VkDeviceSize resultOffset = resultBaseOffset;
        +
        10103 
        +
        10104  // Apply VMA_DEBUG_MARGIN at the end.
        +
        10105  if(VMA_DEBUG_MARGIN > 0)
        +
        10106  {
        +
        10107  if(resultOffset < VMA_DEBUG_MARGIN)
        +
        10108  {
        +
        10109  return false;
        +
        10110  }
        +
        10111  resultOffset -= VMA_DEBUG_MARGIN;
        +
        10112  }
        +
        10113 
        +
        10114  // Apply alignment.
        +
        10115  resultOffset = VmaAlignDown(resultOffset, allocAlignment);
        +
        10116 
        +
        10117  // Check next suballocations from 2nd for BufferImageGranularity conflicts.
        +
        10118  // Make bigger alignment if necessary.
        +
        10119  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        +
        10120  {
        +
        10121  bool bufferImageGranularityConflict = false;
        +
        10122  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        +
        10123  {
        +
        10124  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        +
        10125  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        +
        10126  {
        +
        10127  if(VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
        +
        10128  {
        +
        10129  bufferImageGranularityConflict = true;
        +
        10130  break;
        10131  }
        -
        10132  else
        -
        10133  {
        -
        10134  // Already on next page.
        -
        10135  break;
        -
        10136  }
        -
        10137  }
        -
        10138  }
        -
        10139 
        -
        10140  // All tests passed: Success.
        -
        10141  pAllocationRequest->offset = resultOffset;
        -
        10142  pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;
        -
        10143  pAllocationRequest->sumItemSize = 0;
        -
        10144  // pAllocationRequest->item unused.
        -
        10145  pAllocationRequest->itemsToMakeLostCount = 0;
        -
        10146  pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;
        -
        10147  return true;
        -
        10148  }
        -
        10149 
        -
        10150  return false;
        -
        10151 }
        -
        10152 
        -
        10153 bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
        -
        10154  uint32_t currentFrameIndex,
        -
        10155  uint32_t frameInUseCount,
        -
        10156  VkDeviceSize bufferImageGranularity,
        -
        10157  VkDeviceSize allocSize,
        -
        10158  VkDeviceSize allocAlignment,
        -
        10159  VmaSuballocationType allocType,
        -
        10160  bool canMakeOtherLost,
        -
        10161  uint32_t strategy,
        -
        10162  VmaAllocationRequest* pAllocationRequest)
        -
        10163 {
        -
        10164  const VkDeviceSize size = GetSize();
        -
        10165  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10166  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        10167 
        -
        10168  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        10169  {
        -
        10170  // Try to allocate at the end of 1st vector.
        -
        10171 
        -
        10172  VkDeviceSize resultBaseOffset = 0;
        -
        10173  if(!suballocations1st.empty())
        -
        10174  {
        -
        10175  const VmaSuballocation& lastSuballoc = suballocations1st.back();
        -
        10176  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        -
        10177  }
        -
        10178 
        -
        10179  // Start from offset equal to beginning of free space.
        -
        10180  VkDeviceSize resultOffset = resultBaseOffset;
        -
        10181 
        -
        10182  // Apply VMA_DEBUG_MARGIN at the beginning.
        -
        10183  if(VMA_DEBUG_MARGIN > 0)
        -
        10184  {
        -
        10185  resultOffset += VMA_DEBUG_MARGIN;
        -
        10186  }
        -
        10187 
        -
        10188  // Apply alignment.
        -
        10189  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        -
        10190 
        -
        10191  // Check previous suballocations for BufferImageGranularity conflicts.
        -
        10192  // Make bigger alignment if necessary.
        -
        10193  if(bufferImageGranularity > 1 && !suballocations1st.empty())
        -
        10194  {
        -
        10195  bool bufferImageGranularityConflict = false;
        -
        10196  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        -
        10197  {
        -
        10198  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        -
        10199  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        -
        10200  {
        -
        10201  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        -
        10202  {
        -
        10203  bufferImageGranularityConflict = true;
        -
        10204  break;
        -
        10205  }
        -
        10206  }
        -
        10207  else
        -
        10208  // Already on previous page.
        -
        10209  break;
        -
        10210  }
        -
        10211  if(bufferImageGranularityConflict)
        -
        10212  {
        -
        10213  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        -
        10214  }
        -
        10215  }
        -
        10216 
        -
        10217  const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
        -
        10218  suballocations2nd.back().offset : size;
        -
        10219 
        -
        10220  // There is enough free space at the end after alignment.
        -
        10221  if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)
        -
        10222  {
        -
        10223  // Check next suballocations for BufferImageGranularity conflicts.
        -
        10224  // If conflict exists, allocation cannot be made here.
        -
        10225  if(bufferImageGranularity > 1 && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        10226  {
        -
        10227  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        -
        10228  {
        -
        10229  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        -
        10230  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        -
        10231  {
        -
        10232  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        -
        10233  {
        -
        10234  return false;
        -
        10235  }
        +
        10132  }
        +
        10133  else
        +
        10134  // Already on previous page.
        +
        10135  break;
        +
        10136  }
        +
        10137  if(bufferImageGranularityConflict)
        +
        10138  {
        +
        10139  resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
        +
        10140  }
        +
        10141  }
        +
        10142 
        +
        10143  // There is enough free space.
        +
        10144  const VkDeviceSize endOf1st = !suballocations1st.empty() ?
        +
        10145  suballocations1st.back().offset + suballocations1st.back().size :
        +
        10146  0;
        +
        10147  if(endOf1st + VMA_DEBUG_MARGIN <= resultOffset)
        +
        10148  {
        +
        10149  // Check previous suballocations for BufferImageGranularity conflicts.
        +
        10150  // If conflict exists, allocation cannot be made here.
        +
        10151  if(bufferImageGranularity > 1)
        +
        10152  {
        +
        10153  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        +
        10154  {
        +
        10155  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        +
        10156  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        +
        10157  {
        +
        10158  if(VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
        +
        10159  {
        +
        10160  return false;
        +
        10161  }
        +
        10162  }
        +
        10163  else
        +
        10164  {
        +
        10165  // Already on next page.
        +
        10166  break;
        +
        10167  }
        +
        10168  }
        +
        10169  }
        +
        10170 
        +
        10171  // All tests passed: Success.
        +
        10172  pAllocationRequest->offset = resultOffset;
        +
        10173  pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;
        +
        10174  pAllocationRequest->sumItemSize = 0;
        +
        10175  // pAllocationRequest->item unused.
        +
        10176  pAllocationRequest->itemsToMakeLostCount = 0;
        +
        10177  pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;
        +
        10178  return true;
        +
        10179  }
        +
        10180 
        +
        10181  return false;
        +
        10182 }
        +
        10183 
        +
        10184 bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
        +
        10185  uint32_t currentFrameIndex,
        +
        10186  uint32_t frameInUseCount,
        +
        10187  VkDeviceSize bufferImageGranularity,
        +
        10188  VkDeviceSize allocSize,
        +
        10189  VkDeviceSize allocAlignment,
        +
        10190  VmaSuballocationType allocType,
        +
        10191  bool canMakeOtherLost,
        +
        10192  uint32_t strategy,
        +
        10193  VmaAllocationRequest* pAllocationRequest)
        +
        10194 {
        +
        10195  const VkDeviceSize size = GetSize();
        +
        10196  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10197  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10198 
        +
        10199  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        10200  {
        +
        10201  // Try to allocate at the end of 1st vector.
        +
        10202 
        +
        10203  VkDeviceSize resultBaseOffset = 0;
        +
        10204  if(!suballocations1st.empty())
        +
        10205  {
        +
        10206  const VmaSuballocation& lastSuballoc = suballocations1st.back();
        +
        10207  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        +
        10208  }
        +
        10209 
        +
        10210  // Start from offset equal to beginning of free space.
        +
        10211  VkDeviceSize resultOffset = resultBaseOffset;
        +
        10212 
        +
        10213  // Apply VMA_DEBUG_MARGIN at the beginning.
        +
        10214  if(VMA_DEBUG_MARGIN > 0)
        +
        10215  {
        +
        10216  resultOffset += VMA_DEBUG_MARGIN;
        +
        10217  }
        +
        10218 
        +
        10219  // Apply alignment.
        +
        10220  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        +
        10221 
        +
        10222  // Check previous suballocations for BufferImageGranularity conflicts.
        +
        10223  // Make bigger alignment if necessary.
        +
        10224  if(bufferImageGranularity > 1 && !suballocations1st.empty())
        +
        10225  {
        +
        10226  bool bufferImageGranularityConflict = false;
        +
        10227  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        +
        10228  {
        +
        10229  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        +
        10230  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        +
        10231  {
        +
        10232  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        +
        10233  {
        +
        10234  bufferImageGranularityConflict = true;
        +
        10235  break;
        10236  }
        -
        10237  else
        -
        10238  {
        -
        10239  // Already on previous page.
        -
        10240  break;
        -
        10241  }
        -
        10242  }
        -
        10243  }
        -
        10244 
        -
        10245  // All tests passed: Success.
        -
        10246  pAllocationRequest->offset = resultOffset;
        -
        10247  pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;
        -
        10248  pAllocationRequest->sumItemSize = 0;
        -
        10249  // pAllocationRequest->item, customData unused.
        -
        10250  pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;
        -
        10251  pAllocationRequest->itemsToMakeLostCount = 0;
        -
        10252  return true;
        -
        10253  }
        -
        10254  }
        -
        10255 
        -
        10256  // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
        -
        10257  // beginning of 1st vector as the end of free space.
        -
        10258  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        10259  {
        -
        10260  VMA_ASSERT(!suballocations1st.empty());
        -
        10261 
        -
        10262  VkDeviceSize resultBaseOffset = 0;
        -
        10263  if(!suballocations2nd.empty())
        -
        10264  {
        -
        10265  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        -
        10266  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        -
        10267  }
        -
        10268 
        -
        10269  // Start from offset equal to beginning of free space.
        -
        10270  VkDeviceSize resultOffset = resultBaseOffset;
        -
        10271 
        -
        10272  // Apply VMA_DEBUG_MARGIN at the beginning.
        -
        10273  if(VMA_DEBUG_MARGIN > 0)
        -
        10274  {
        -
        10275  resultOffset += VMA_DEBUG_MARGIN;
        -
        10276  }
        -
        10277 
        -
        10278  // Apply alignment.
        -
        10279  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        -
        10280 
        -
        10281  // Check previous suballocations for BufferImageGranularity conflicts.
        -
        10282  // Make bigger alignment if necessary.
        -
        10283  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        -
        10284  {
        -
        10285  bool bufferImageGranularityConflict = false;
        -
        10286  for(size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
        -
        10287  {
        -
        10288  const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
        -
        10289  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        -
        10290  {
        -
        10291  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        -
        10292  {
        -
        10293  bufferImageGranularityConflict = true;
        -
        10294  break;
        -
        10295  }
        -
        10296  }
        -
        10297  else
        -
        10298  // Already on previous page.
        -
        10299  break;
        -
        10300  }
        -
        10301  if(bufferImageGranularityConflict)
        -
        10302  {
        -
        10303  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        -
        10304  }
        -
        10305  }
        -
        10306 
        -
        10307  pAllocationRequest->itemsToMakeLostCount = 0;
        -
        10308  pAllocationRequest->sumItemSize = 0;
        -
        10309  size_t index1st = m_1stNullItemsBeginCount;
        -
        10310 
        -
        10311  if(canMakeOtherLost)
        -
        10312  {
        -
        10313  while(index1st < suballocations1st.size() &&
        -
        10314  resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)
        -
        10315  {
        -
        10316  // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.
        -
        10317  const VmaSuballocation& suballoc = suballocations1st[index1st];
        -
        10318  if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
        -
        10319  {
        -
        10320  // No problem.
        -
        10321  }
        -
        10322  else
        -
        10323  {
        -
        10324  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        -
        10325  if(suballoc.hAllocation->CanBecomeLost() &&
        -
        10326  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        -
        10327  {
        -
        10328  ++pAllocationRequest->itemsToMakeLostCount;
        -
        10329  pAllocationRequest->sumItemSize += suballoc.size;
        -
        10330  }
        -
        10331  else
        -
        10332  {
        -
        10333  return false;
        -
        10334  }
        -
        10335  }
        -
        10336  ++index1st;
        -
        10337  }
        -
        10338 
        -
        10339  // Check next suballocations for BufferImageGranularity conflicts.
        -
        10340  // If conflict exists, we must mark more allocations lost or fail.
        -
        10341  if(bufferImageGranularity > 1)
        -
        10342  {
        -
        10343  while(index1st < suballocations1st.size())
        -
        10344  {
        -
        10345  const VmaSuballocation& suballoc = suballocations1st[index1st];
        -
        10346  if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))
        -
        10347  {
        -
        10348  if(suballoc.hAllocation != VK_NULL_HANDLE)
        -
        10349  {
        -
        10350  // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).
        -
        10351  if(suballoc.hAllocation->CanBecomeLost() &&
        -
        10352  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        -
        10353  {
        -
        10354  ++pAllocationRequest->itemsToMakeLostCount;
        -
        10355  pAllocationRequest->sumItemSize += suballoc.size;
        -
        10356  }
        -
        10357  else
        -
        10358  {
        -
        10359  return false;
        -
        10360  }
        -
        10361  }
        -
        10362  }
        -
        10363  else
        -
        10364  {
        -
        10365  // Already on next page.
        -
        10366  break;
        -
        10367  }
        -
        10368  ++index1st;
        -
        10369  }
        -
        10370  }
        -
        10371 
        -
        10372  // Special case: There is not enough room at the end for this allocation, even after making all from the 1st lost.
        -
        10373  if(index1st == suballocations1st.size() &&
        -
        10374  resultOffset + allocSize + VMA_DEBUG_MARGIN > size)
        -
        10375  {
        -
        10376  // TODO: This is a known bug that it's not yet implemented and the allocation is failing.
        -
        10377  VMA_DEBUG_LOG("Unsupported special case in custom pool with linear allocation algorithm used as ring buffer with allocations that can be lost.");
        -
        10378  }
        -
        10379  }
        -
        10380 
        -
        10381  // There is enough free space at the end after alignment.
        -
        10382  if((index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= size) ||
        -
        10383  (index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset))
        -
        10384  {
        -
        10385  // Check next suballocations for BufferImageGranularity conflicts.
        -
        10386  // If conflict exists, allocation cannot be made here.
        -
        10387  if(bufferImageGranularity > 1)
        -
        10388  {
        -
        10389  for(size_t nextSuballocIndex = index1st;
        -
        10390  nextSuballocIndex < suballocations1st.size();
        -
        10391  nextSuballocIndex++)
        -
        10392  {
        -
        10393  const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
        -
        10394  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        +
        10237  }
        +
        10238  else
        +
        10239  // Already on previous page.
        +
        10240  break;
        +
        10241  }
        +
        10242  if(bufferImageGranularityConflict)
        +
        10243  {
        +
        10244  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        +
        10245  }
        +
        10246  }
        +
        10247 
        +
        10248  const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
        +
        10249  suballocations2nd.back().offset : size;
        +
        10250 
        +
        10251  // There is enough free space at the end after alignment.
        +
        10252  if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)
        +
        10253  {
        +
        10254  // Check next suballocations for BufferImageGranularity conflicts.
        +
        10255  // If conflict exists, allocation cannot be made here.
        +
        10256  if(bufferImageGranularity > 1 && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        10257  {
        +
        10258  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        +
        10259  {
        +
        10260  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        +
        10261  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        +
        10262  {
        +
        10263  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        +
        10264  {
        +
        10265  return false;
        +
        10266  }
        +
        10267  }
        +
        10268  else
        +
        10269  {
        +
        10270  // Already on previous page.
        +
        10271  break;
        +
        10272  }
        +
        10273  }
        +
        10274  }
        +
        10275 
        +
        10276  // All tests passed: Success.
        +
        10277  pAllocationRequest->offset = resultOffset;
        +
        10278  pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;
        +
        10279  pAllocationRequest->sumItemSize = 0;
        +
        10280  // pAllocationRequest->item, customData unused.
        +
        10281  pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;
        +
        10282  pAllocationRequest->itemsToMakeLostCount = 0;
        +
        10283  return true;
        +
        10284  }
        +
        10285  }
        +
        10286 
        +
        10287  // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
        +
        10288  // beginning of 1st vector as the end of free space.
        +
        10289  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        10290  {
        +
        10291  VMA_ASSERT(!suballocations1st.empty());
        +
        10292 
        +
        10293  VkDeviceSize resultBaseOffset = 0;
        +
        10294  if(!suballocations2nd.empty())
        +
        10295  {
        +
        10296  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        +
        10297  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        +
        10298  }
        +
        10299 
        +
        10300  // Start from offset equal to beginning of free space.
        +
        10301  VkDeviceSize resultOffset = resultBaseOffset;
        +
        10302 
        +
        10303  // Apply VMA_DEBUG_MARGIN at the beginning.
        +
        10304  if(VMA_DEBUG_MARGIN > 0)
        +
        10305  {
        +
        10306  resultOffset += VMA_DEBUG_MARGIN;
        +
        10307  }
        +
        10308 
        +
        10309  // Apply alignment.
        +
        10310  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        +
        10311 
        +
        10312  // Check previous suballocations for BufferImageGranularity conflicts.
        +
        10313  // Make bigger alignment if necessary.
        +
        10314  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        +
        10315  {
        +
        10316  bool bufferImageGranularityConflict = false;
        +
        10317  for(size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
        +
        10318  {
        +
        10319  const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
        +
        10320  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        +
        10321  {
        +
        10322  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        +
        10323  {
        +
        10324  bufferImageGranularityConflict = true;
        +
        10325  break;
        +
        10326  }
        +
        10327  }
        +
        10328  else
        +
        10329  // Already on previous page.
        +
        10330  break;
        +
        10331  }
        +
        10332  if(bufferImageGranularityConflict)
        +
        10333  {
        +
        10334  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        +
        10335  }
        +
        10336  }
        +
        10337 
        +
        10338  pAllocationRequest->itemsToMakeLostCount = 0;
        +
        10339  pAllocationRequest->sumItemSize = 0;
        +
        10340  size_t index1st = m_1stNullItemsBeginCount;
        +
        10341 
        +
        10342  if(canMakeOtherLost)
        +
        10343  {
        +
        10344  while(index1st < suballocations1st.size() &&
        +
        10345  resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)
        +
        10346  {
        +
        10347  // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.
        +
        10348  const VmaSuballocation& suballoc = suballocations1st[index1st];
        +
        10349  if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
        +
        10350  {
        +
        10351  // No problem.
        +
        10352  }
        +
        10353  else
        +
        10354  {
        +
        10355  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        +
        10356  if(suballoc.hAllocation->CanBecomeLost() &&
        +
        10357  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        +
        10358  {
        +
        10359  ++pAllocationRequest->itemsToMakeLostCount;
        +
        10360  pAllocationRequest->sumItemSize += suballoc.size;
        +
        10361  }
        +
        10362  else
        +
        10363  {
        +
        10364  return false;
        +
        10365  }
        +
        10366  }
        +
        10367  ++index1st;
        +
        10368  }
        +
        10369 
        +
        10370  // Check next suballocations for BufferImageGranularity conflicts.
        +
        10371  // If conflict exists, we must mark more allocations lost or fail.
        +
        10372  if(bufferImageGranularity > 1)
        +
        10373  {
        +
        10374  while(index1st < suballocations1st.size())
        +
        10375  {
        +
        10376  const VmaSuballocation& suballoc = suballocations1st[index1st];
        +
        10377  if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))
        +
        10378  {
        +
        10379  if(suballoc.hAllocation != VK_NULL_HANDLE)
        +
        10380  {
        +
        10381  // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).
        +
        10382  if(suballoc.hAllocation->CanBecomeLost() &&
        +
        10383  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        +
        10384  {
        +
        10385  ++pAllocationRequest->itemsToMakeLostCount;
        +
        10386  pAllocationRequest->sumItemSize += suballoc.size;
        +
        10387  }
        +
        10388  else
        +
        10389  {
        +
        10390  return false;
        +
        10391  }
        +
        10392  }
        +
        10393  }
        +
        10394  else
        10395  {
        -
        10396  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        -
        10397  {
        -
        10398  return false;
        -
        10399  }
        -
        10400  }
        -
        10401  else
        -
        10402  {
        -
        10403  // Already on next page.
        -
        10404  break;
        -
        10405  }
        -
        10406  }
        -
        10407  }
        -
        10408 
        -
        10409  // All tests passed: Success.
        -
        10410  pAllocationRequest->offset = resultOffset;
        -
        10411  pAllocationRequest->sumFreeSize =
        -
        10412  (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)
        -
        10413  - resultBaseOffset
        -
        10414  - pAllocationRequest->sumItemSize;
        -
        10415  pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;
        -
        10416  // pAllocationRequest->item, customData unused.
        -
        10417  return true;
        -
        10418  }
        -
        10419  }
        -
        10420 
        -
        10421  return false;
        -
        10422 }
        -
        10423 
        -
        10424 bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(
        -
        10425  uint32_t currentFrameIndex,
        -
        10426  uint32_t frameInUseCount,
        -
        10427  VmaAllocationRequest* pAllocationRequest)
        -
        10428 {
        -
        10429  if(pAllocationRequest->itemsToMakeLostCount == 0)
        -
        10430  {
        -
        10431  return true;
        -
        10432  }
        -
        10433 
        -
        10434  VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);
        -
        10435 
        -
        10436  // We always start from 1st.
        -
        10437  SuballocationVectorType* suballocations = &AccessSuballocations1st();
        -
        10438  size_t index = m_1stNullItemsBeginCount;
        -
        10439  size_t madeLostCount = 0;
        -
        10440  while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)
        -
        10441  {
        -
        10442  if(index == suballocations->size())
        -
        10443  {
        -
        10444  index = 0;
        -
        10445  // If we get to the end of 1st, we wrap around to beginning of 2nd of 1st.
        -
        10446  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        10447  {
        -
        10448  suballocations = &AccessSuballocations2nd();
        -
        10449  }
        -
        10450  // else: m_2ndVectorMode == SECOND_VECTOR_EMPTY:
        -
        10451  // suballocations continues pointing at AccessSuballocations1st().
        -
        10452  VMA_ASSERT(!suballocations->empty());
        -
        10453  }
        -
        10454  VmaSuballocation& suballoc = (*suballocations)[index];
        -
        10455  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        -
        10456  {
        -
        10457  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        -
        10458  VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());
        -
        10459  if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        -
        10460  {
        -
        10461  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        10462  suballoc.hAllocation = VK_NULL_HANDLE;
        -
        10463  m_SumFreeSize += suballoc.size;
        -
        10464  if(suballocations == &AccessSuballocations1st())
        -
        10465  {
        -
        10466  ++m_1stNullItemsMiddleCount;
        -
        10467  }
        -
        10468  else
        -
        10469  {
        -
        10470  ++m_2ndNullItemsCount;
        -
        10471  }
        -
        10472  ++madeLostCount;
        -
        10473  }
        -
        10474  else
        -
        10475  {
        -
        10476  return false;
        -
        10477  }
        -
        10478  }
        -
        10479  ++index;
        -
        10480  }
        -
        10481 
        -
        10482  CleanupAfterFree();
        -
        10483  //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().
        -
        10484 
        -
        10485  return true;
        -
        10486 }
        -
        10487 
        -
        10488 uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        -
        10489 {
        -
        10490  uint32_t lostAllocationCount = 0;
        -
        10491 
        -
        10492  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10493  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        -
        10494  {
        -
        10495  VmaSuballocation& suballoc = suballocations1st[i];
        -
        10496  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        -
        10497  suballoc.hAllocation->CanBecomeLost() &&
        -
        10498  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        -
        10499  {
        -
        10500  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        10501  suballoc.hAllocation = VK_NULL_HANDLE;
        -
        10502  ++m_1stNullItemsMiddleCount;
        -
        10503  m_SumFreeSize += suballoc.size;
        -
        10504  ++lostAllocationCount;
        -
        10505  }
        -
        10506  }
        -
        10507 
        -
        10508  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        10509  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        -
        10510  {
        -
        10511  VmaSuballocation& suballoc = suballocations2nd[i];
        -
        10512  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        -
        10513  suballoc.hAllocation->CanBecomeLost() &&
        -
        10514  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        -
        10515  {
        -
        10516  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        10517  suballoc.hAllocation = VK_NULL_HANDLE;
        -
        10518  ++m_2ndNullItemsCount;
        -
        10519  m_SumFreeSize += suballoc.size;
        -
        10520  ++lostAllocationCount;
        -
        10521  }
        -
        10522  }
        -
        10523 
        -
        10524  if(lostAllocationCount)
        +
        10396  // Already on next page.
        +
        10397  break;
        +
        10398  }
        +
        10399  ++index1st;
        +
        10400  }
        +
        10401  }
        +
        10402 
        +
        10403  // Special case: There is not enough room at the end for this allocation, even after making all from the 1st lost.
        +
        10404  if(index1st == suballocations1st.size() &&
        +
        10405  resultOffset + allocSize + VMA_DEBUG_MARGIN > size)
        +
        10406  {
        +
        10407  // TODO: This is a known bug that it's not yet implemented and the allocation is failing.
        +
        10408  VMA_DEBUG_LOG("Unsupported special case in custom pool with linear allocation algorithm used as ring buffer with allocations that can be lost.");
        +
        10409  }
        +
        10410  }
        +
        10411 
        +
        10412  // There is enough free space at the end after alignment.
        +
        10413  if((index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= size) ||
        +
        10414  (index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset))
        +
        10415  {
        +
        10416  // Check next suballocations for BufferImageGranularity conflicts.
        +
        10417  // If conflict exists, allocation cannot be made here.
        +
        10418  if(bufferImageGranularity > 1)
        +
        10419  {
        +
        10420  for(size_t nextSuballocIndex = index1st;
        +
        10421  nextSuballocIndex < suballocations1st.size();
        +
        10422  nextSuballocIndex++)
        +
        10423  {
        +
        10424  const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
        +
        10425  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        +
        10426  {
        +
        10427  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        +
        10428  {
        +
        10429  return false;
        +
        10430  }
        +
        10431  }
        +
        10432  else
        +
        10433  {
        +
        10434  // Already on next page.
        +
        10435  break;
        +
        10436  }
        +
        10437  }
        +
        10438  }
        +
        10439 
        +
        10440  // All tests passed: Success.
        +
        10441  pAllocationRequest->offset = resultOffset;
        +
        10442  pAllocationRequest->sumFreeSize =
        +
        10443  (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)
        +
        10444  - resultBaseOffset
        +
        10445  - pAllocationRequest->sumItemSize;
        +
        10446  pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;
        +
        10447  // pAllocationRequest->item, customData unused.
        +
        10448  return true;
        +
        10449  }
        +
        10450  }
        +
        10451 
        +
        10452  return false;
        +
        10453 }
        +
        10454 
        +
        10455 bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(
        +
        10456  uint32_t currentFrameIndex,
        +
        10457  uint32_t frameInUseCount,
        +
        10458  VmaAllocationRequest* pAllocationRequest)
        +
        10459 {
        +
        10460  if(pAllocationRequest->itemsToMakeLostCount == 0)
        +
        10461  {
        +
        10462  return true;
        +
        10463  }
        +
        10464 
        +
        10465  VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);
        +
        10466 
        +
        10467  // We always start from 1st.
        +
        10468  SuballocationVectorType* suballocations = &AccessSuballocations1st();
        +
        10469  size_t index = m_1stNullItemsBeginCount;
        +
        10470  size_t madeLostCount = 0;
        +
        10471  while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)
        +
        10472  {
        +
        10473  if(index == suballocations->size())
        +
        10474  {
        +
        10475  index = 0;
        +
        10476  // If we get to the end of 1st, we wrap around to beginning of 2nd of 1st.
        +
        10477  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        10478  {
        +
        10479  suballocations = &AccessSuballocations2nd();
        +
        10480  }
        +
        10481  // else: m_2ndVectorMode == SECOND_VECTOR_EMPTY:
        +
        10482  // suballocations continues pointing at AccessSuballocations1st().
        +
        10483  VMA_ASSERT(!suballocations->empty());
        +
        10484  }
        +
        10485  VmaSuballocation& suballoc = (*suballocations)[index];
        +
        10486  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        +
        10487  {
        +
        10488  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        +
        10489  VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());
        +
        10490  if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        +
        10491  {
        +
        10492  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        10493  suballoc.hAllocation = VK_NULL_HANDLE;
        +
        10494  m_SumFreeSize += suballoc.size;
        +
        10495  if(suballocations == &AccessSuballocations1st())
        +
        10496  {
        +
        10497  ++m_1stNullItemsMiddleCount;
        +
        10498  }
        +
        10499  else
        +
        10500  {
        +
        10501  ++m_2ndNullItemsCount;
        +
        10502  }
        +
        10503  ++madeLostCount;
        +
        10504  }
        +
        10505  else
        +
        10506  {
        +
        10507  return false;
        +
        10508  }
        +
        10509  }
        +
        10510  ++index;
        +
        10511  }
        +
        10512 
        +
        10513  CleanupAfterFree();
        +
        10514  //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().
        +
        10515 
        +
        10516  return true;
        +
        10517 }
        +
        10518 
        +
        10519 uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        +
        10520 {
        +
        10521  uint32_t lostAllocationCount = 0;
        +
        10522 
        +
        10523  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10524  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        10525  {
        -
        10526  CleanupAfterFree();
        -
        10527  }
        -
        10528 
        -
        10529  return lostAllocationCount;
        -
        10530 }
        -
        10531 
        -
        10532 VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
        -
        10533 {
        -
        10534  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10535  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        -
        10536  {
        -
        10537  const VmaSuballocation& suballoc = suballocations1st[i];
        -
        10538  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        -
        10539  {
        -
        10540  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        -
        10541  {
        -
        10542  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        -
        10543  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        10544  }
        -
        10545  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        -
        10546  {
        -
        10547  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        -
        10548  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        10549  }
        -
        10550  }
        -
        10551  }
        -
        10552 
        -
        10553  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        10554  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        -
        10555  {
        -
        10556  const VmaSuballocation& suballoc = suballocations2nd[i];
        -
        10557  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        -
        10558  {
        -
        10559  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        -
        10560  {
        -
        10561  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        -
        10562  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        10563  }
        -
        10564  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        -
        10565  {
        -
        10566  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        -
        10567  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        10568  }
        -
        10569  }
        -
        10570  }
        -
        10571 
        -
        10572  return VK_SUCCESS;
        -
        10573 }
        -
        10574 
        -
        10575 void VmaBlockMetadata_Linear::Alloc(
        -
        10576  const VmaAllocationRequest& request,
        -
        10577  VmaSuballocationType type,
        -
        10578  VkDeviceSize allocSize,
        -
        10579  VmaAllocation hAllocation)
        -
        10580 {
        -
        10581  const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, type };
        -
        10582 
        -
        10583  switch(request.type)
        -
        10584  {
        -
        10585  case VmaAllocationRequestType::UpperAddress:
        -
        10586  {
        -
        10587  VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
        -
        10588  "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
        -
        10589  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        10590  suballocations2nd.push_back(newSuballoc);
        -
        10591  m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
        -
        10592  }
        -
        10593  break;
        -
        10594  case VmaAllocationRequestType::EndOf1st:
        -
        10595  {
        -
        10596  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10597 
        -
        10598  VMA_ASSERT(suballocations1st.empty() ||
        -
        10599  request.offset >= suballocations1st.back().offset + suballocations1st.back().size);
        -
        10600  // Check if it fits before the end of the block.
        -
        10601  VMA_ASSERT(request.offset + allocSize <= GetSize());
        +
        10526  VmaSuballocation& suballoc = suballocations1st[i];
        +
        10527  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        +
        10528  suballoc.hAllocation->CanBecomeLost() &&
        +
        10529  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        +
        10530  {
        +
        10531  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        10532  suballoc.hAllocation = VK_NULL_HANDLE;
        +
        10533  ++m_1stNullItemsMiddleCount;
        +
        10534  m_SumFreeSize += suballoc.size;
        +
        10535  ++lostAllocationCount;
        +
        10536  }
        +
        10537  }
        +
        10538 
        +
        10539  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10540  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        +
        10541  {
        +
        10542  VmaSuballocation& suballoc = suballocations2nd[i];
        +
        10543  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        +
        10544  suballoc.hAllocation->CanBecomeLost() &&
        +
        10545  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        +
        10546  {
        +
        10547  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        10548  suballoc.hAllocation = VK_NULL_HANDLE;
        +
        10549  ++m_2ndNullItemsCount;
        +
        10550  m_SumFreeSize += suballoc.size;
        +
        10551  ++lostAllocationCount;
        +
        10552  }
        +
        10553  }
        +
        10554 
        +
        10555  if(lostAllocationCount)
        +
        10556  {
        +
        10557  CleanupAfterFree();
        +
        10558  }
        +
        10559 
        +
        10560  return lostAllocationCount;
        +
        10561 }
        +
        10562 
        +
        10563 VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
        +
        10564 {
        +
        10565  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10566  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        +
        10567  {
        +
        10568  const VmaSuballocation& suballoc = suballocations1st[i];
        +
        10569  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        +
        10570  {
        +
        10571  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        +
        10572  {
        +
        10573  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        +
        10574  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        10575  }
        +
        10576  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        +
        10577  {
        +
        10578  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        +
        10579  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        10580  }
        +
        10581  }
        +
        10582  }
        +
        10583 
        +
        10584  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10585  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        +
        10586  {
        +
        10587  const VmaSuballocation& suballoc = suballocations2nd[i];
        +
        10588  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        +
        10589  {
        +
        10590  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        +
        10591  {
        +
        10592  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        +
        10593  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        10594  }
        +
        10595  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        +
        10596  {
        +
        10597  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        +
        10598  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        10599  }
        +
        10600  }
        +
        10601  }
        10602 
        -
        10603  suballocations1st.push_back(newSuballoc);
        -
        10604  }
        -
        10605  break;
        -
        10606  case VmaAllocationRequestType::EndOf2nd:
        -
        10607  {
        -
        10608  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10609  // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
        -
        10610  VMA_ASSERT(!suballocations1st.empty() &&
        -
        10611  request.offset + allocSize <= suballocations1st[m_1stNullItemsBeginCount].offset);
        -
        10612  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10603  return VK_SUCCESS;
        +
        10604 }
        +
        10605 
        +
        10606 void VmaBlockMetadata_Linear::Alloc(
        +
        10607  const VmaAllocationRequest& request,
        +
        10608  VmaSuballocationType type,
        +
        10609  VkDeviceSize allocSize,
        +
        10610  VmaAllocation hAllocation)
        +
        10611 {
        +
        10612  const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, type };
        10613 
        -
        10614  switch(m_2ndVectorMode)
        -
        10615  {
        -
        10616  case SECOND_VECTOR_EMPTY:
        -
        10617  // First allocation from second part ring buffer.
        -
        10618  VMA_ASSERT(suballocations2nd.empty());
        -
        10619  m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
        -
        10620  break;
        -
        10621  case SECOND_VECTOR_RING_BUFFER:
        -
        10622  // 2-part ring buffer is already started.
        -
        10623  VMA_ASSERT(!suballocations2nd.empty());
        -
        10624  break;
        -
        10625  case SECOND_VECTOR_DOUBLE_STACK:
        -
        10626  VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
        -
        10627  break;
        -
        10628  default:
        -
        10629  VMA_ASSERT(0);
        -
        10630  }
        -
        10631 
        -
        10632  suballocations2nd.push_back(newSuballoc);
        -
        10633  }
        -
        10634  break;
        -
        10635  default:
        -
        10636  VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
        -
        10637  }
        -
        10638 
        -
        10639  m_SumFreeSize -= newSuballoc.size;
        -
        10640 }
        -
        10641 
        -
        10642 void VmaBlockMetadata_Linear::Free(const VmaAllocation allocation)
        -
        10643 {
        -
        10644  FreeAtOffset(allocation->GetOffset());
        -
        10645 }
        -
        10646 
        -
        10647 void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)
        -
        10648 {
        -
        10649  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10650  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        10651 
        -
        10652  if(!suballocations1st.empty())
        -
        10653  {
        -
        10654  // First allocation: Mark it as next empty at the beginning.
        -
        10655  VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        -
        10656  if(firstSuballoc.offset == offset)
        -
        10657  {
        -
        10658  firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        10659  firstSuballoc.hAllocation = VK_NULL_HANDLE;
        -
        10660  m_SumFreeSize += firstSuballoc.size;
        -
        10661  ++m_1stNullItemsBeginCount;
        -
        10662  CleanupAfterFree();
        -
        10663  return;
        +
        10614  switch(request.type)
        +
        10615  {
        +
        10616  case VmaAllocationRequestType::UpperAddress:
        +
        10617  {
        +
        10618  VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
        +
        10619  "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
        +
        10620  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10621  suballocations2nd.push_back(newSuballoc);
        +
        10622  m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
        +
        10623  }
        +
        10624  break;
        +
        10625  case VmaAllocationRequestType::EndOf1st:
        +
        10626  {
        +
        10627  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10628 
        +
        10629  VMA_ASSERT(suballocations1st.empty() ||
        +
        10630  request.offset >= suballocations1st.back().offset + suballocations1st.back().size);
        +
        10631  // Check if it fits before the end of the block.
        +
        10632  VMA_ASSERT(request.offset + allocSize <= GetSize());
        +
        10633 
        +
        10634  suballocations1st.push_back(newSuballoc);
        +
        10635  }
        +
        10636  break;
        +
        10637  case VmaAllocationRequestType::EndOf2nd:
        +
        10638  {
        +
        10639  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10640  // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
        +
        10641  VMA_ASSERT(!suballocations1st.empty() &&
        +
        10642  request.offset + allocSize <= suballocations1st[m_1stNullItemsBeginCount].offset);
        +
        10643  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10644 
        +
        10645  switch(m_2ndVectorMode)
        +
        10646  {
        +
        10647  case SECOND_VECTOR_EMPTY:
        +
        10648  // First allocation from second part ring buffer.
        +
        10649  VMA_ASSERT(suballocations2nd.empty());
        +
        10650  m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
        +
        10651  break;
        +
        10652  case SECOND_VECTOR_RING_BUFFER:
        +
        10653  // 2-part ring buffer is already started.
        +
        10654  VMA_ASSERT(!suballocations2nd.empty());
        +
        10655  break;
        +
        10656  case SECOND_VECTOR_DOUBLE_STACK:
        +
        10657  VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
        +
        10658  break;
        +
        10659  default:
        +
        10660  VMA_ASSERT(0);
        +
        10661  }
        +
        10662 
        +
        10663  suballocations2nd.push_back(newSuballoc);
        10664  }
        -
        10665  }
        -
        10666 
        -
        10667  // Last allocation in 2-part ring buffer or top of upper stack (same logic).
        -
        10668  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
        -
        10669  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        -
        10670  {
        -
        10671  VmaSuballocation& lastSuballoc = suballocations2nd.back();
        -
        10672  if(lastSuballoc.offset == offset)
        -
        10673  {
        -
        10674  m_SumFreeSize += lastSuballoc.size;
        -
        10675  suballocations2nd.pop_back();
        -
        10676  CleanupAfterFree();
        -
        10677  return;
        -
        10678  }
        -
        10679  }
        -
        10680  // Last allocation in 1st vector.
        -
        10681  else if(m_2ndVectorMode == SECOND_VECTOR_EMPTY)
        -
        10682  {
        -
        10683  VmaSuballocation& lastSuballoc = suballocations1st.back();
        -
        10684  if(lastSuballoc.offset == offset)
        -
        10685  {
        -
        10686  m_SumFreeSize += lastSuballoc.size;
        -
        10687  suballocations1st.pop_back();
        -
        10688  CleanupAfterFree();
        -
        10689  return;
        -
        10690  }
        -
        10691  }
        -
        10692 
        -
        10693  // Item from the middle of 1st vector.
        -
        10694  {
        -
        10695  VmaSuballocation refSuballoc;
        -
        10696  refSuballoc.offset = offset;
        -
        10697  // Rest of members stays uninitialized intentionally for better performance.
        -
        10698  SuballocationVectorType::iterator it = VmaBinaryFindSorted(
        -
        10699  suballocations1st.begin() + m_1stNullItemsBeginCount,
        -
        10700  suballocations1st.end(),
        -
        10701  refSuballoc,
        -
        10702  VmaSuballocationOffsetLess());
        -
        10703  if(it != suballocations1st.end())
        +
        10665  break;
        +
        10666  default:
        +
        10667  VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
        +
        10668  }
        +
        10669 
        +
        10670  m_SumFreeSize -= newSuballoc.size;
        +
        10671 }
        +
        10672 
        +
        10673 void VmaBlockMetadata_Linear::Free(const VmaAllocation allocation)
        +
        10674 {
        +
        10675  FreeAtOffset(allocation->GetOffset());
        +
        10676 }
        +
        10677 
        +
        10678 void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)
        +
        10679 {
        +
        10680  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10681  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        +
        10682 
        +
        10683  if(!suballocations1st.empty())
        +
        10684  {
        +
        10685  // First allocation: Mark it as next empty at the beginning.
        +
        10686  VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        +
        10687  if(firstSuballoc.offset == offset)
        +
        10688  {
        +
        10689  firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        10690  firstSuballoc.hAllocation = VK_NULL_HANDLE;
        +
        10691  m_SumFreeSize += firstSuballoc.size;
        +
        10692  ++m_1stNullItemsBeginCount;
        +
        10693  CleanupAfterFree();
        +
        10694  return;
        +
        10695  }
        +
        10696  }
        +
        10697 
        +
        10698  // Last allocation in 2-part ring buffer or top of upper stack (same logic).
        +
        10699  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
        +
        10700  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        +
        10701  {
        +
        10702  VmaSuballocation& lastSuballoc = suballocations2nd.back();
        +
        10703  if(lastSuballoc.offset == offset)
        10704  {
        -
        10705  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        10706  it->hAllocation = VK_NULL_HANDLE;
        -
        10707  ++m_1stNullItemsMiddleCount;
        -
        10708  m_SumFreeSize += it->size;
        -
        10709  CleanupAfterFree();
        -
        10710  return;
        -
        10711  }
        -
        10712  }
        -
        10713 
        -
        10714  if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)
        -
        10715  {
        -
        10716  // Item from the middle of 2nd vector.
        -
        10717  VmaSuballocation refSuballoc;
        -
        10718  refSuballoc.offset = offset;
        -
        10719  // Rest of members stays uninitialized intentionally for better performance.
        -
        10720  SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
        -
        10721  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
        -
        10722  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
        -
        10723  if(it != suballocations2nd.end())
        -
        10724  {
        -
        10725  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        -
        10726  it->hAllocation = VK_NULL_HANDLE;
        -
        10727  ++m_2ndNullItemsCount;
        -
        10728  m_SumFreeSize += it->size;
        -
        10729  CleanupAfterFree();
        -
        10730  return;
        -
        10731  }
        -
        10732  }
        -
        10733 
        -
        10734  VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
        -
        10735 }
        -
        10736 
        -
        10737 bool VmaBlockMetadata_Linear::ShouldCompact1st() const
        -
        10738 {
        -
        10739  const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        -
        10740  const size_t suballocCount = AccessSuballocations1st().size();
        -
        10741  return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
        -
        10742 }
        -
        10743 
        -
        10744 void VmaBlockMetadata_Linear::CleanupAfterFree()
        -
        10745 {
        -
        10746  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        -
        10747  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        -
        10748 
        -
        10749  if(IsEmpty())
        -
        10750  {
        -
        10751  suballocations1st.clear();
        -
        10752  suballocations2nd.clear();
        -
        10753  m_1stNullItemsBeginCount = 0;
        -
        10754  m_1stNullItemsMiddleCount = 0;
        -
        10755  m_2ndNullItemsCount = 0;
        -
        10756  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        -
        10757  }
        -
        10758  else
        -
        10759  {
        -
        10760  const size_t suballoc1stCount = suballocations1st.size();
        -
        10761  const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        -
        10762  VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
        -
        10763 
        -
        10764  // Find more null items at the beginning of 1st vector.
        -
        10765  while(m_1stNullItemsBeginCount < suballoc1stCount &&
        -
        10766  suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        -
        10767  {
        -
        10768  ++m_1stNullItemsBeginCount;
        -
        10769  --m_1stNullItemsMiddleCount;
        -
        10770  }
        -
        10771 
        -
        10772  // Find more null items at the end of 1st vector.
        -
        10773  while(m_1stNullItemsMiddleCount > 0 &&
        -
        10774  suballocations1st.back().hAllocation == VK_NULL_HANDLE)
        -
        10775  {
        -
        10776  --m_1stNullItemsMiddleCount;
        -
        10777  suballocations1st.pop_back();
        -
        10778  }
        +
        10705  m_SumFreeSize += lastSuballoc.size;
        +
        10706  suballocations2nd.pop_back();
        +
        10707  CleanupAfterFree();
        +
        10708  return;
        +
        10709  }
        +
        10710  }
        +
        10711  // Last allocation in 1st vector.
        +
        10712  else if(m_2ndVectorMode == SECOND_VECTOR_EMPTY)
        +
        10713  {
        +
        10714  VmaSuballocation& lastSuballoc = suballocations1st.back();
        +
        10715  if(lastSuballoc.offset == offset)
        +
        10716  {
        +
        10717  m_SumFreeSize += lastSuballoc.size;
        +
        10718  suballocations1st.pop_back();
        +
        10719  CleanupAfterFree();
        +
        10720  return;
        +
        10721  }
        +
        10722  }
        +
        10723 
        +
        10724  // Item from the middle of 1st vector.
        +
        10725  {
        +
        10726  VmaSuballocation refSuballoc;
        +
        10727  refSuballoc.offset = offset;
        +
        10728  // Rest of members stays uninitialized intentionally for better performance.
        +
        10729  SuballocationVectorType::iterator it = VmaBinaryFindSorted(
        +
        10730  suballocations1st.begin() + m_1stNullItemsBeginCount,
        +
        10731  suballocations1st.end(),
        +
        10732  refSuballoc,
        +
        10733  VmaSuballocationOffsetLess());
        +
        10734  if(it != suballocations1st.end())
        +
        10735  {
        +
        10736  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        10737  it->hAllocation = VK_NULL_HANDLE;
        +
        10738  ++m_1stNullItemsMiddleCount;
        +
        10739  m_SumFreeSize += it->size;
        +
        10740  CleanupAfterFree();
        +
        10741  return;
        +
        10742  }
        +
        10743  }
        +
        10744 
        +
        10745  if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)
        +
        10746  {
        +
        10747  // Item from the middle of 2nd vector.
        +
        10748  VmaSuballocation refSuballoc;
        +
        10749  refSuballoc.offset = offset;
        +
        10750  // Rest of members stays uninitialized intentionally for better performance.
        +
        10751  SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
        +
        10752  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
        +
        10753  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
        +
        10754  if(it != suballocations2nd.end())
        +
        10755  {
        +
        10756  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        +
        10757  it->hAllocation = VK_NULL_HANDLE;
        +
        10758  ++m_2ndNullItemsCount;
        +
        10759  m_SumFreeSize += it->size;
        +
        10760  CleanupAfterFree();
        +
        10761  return;
        +
        10762  }
        +
        10763  }
        +
        10764 
        +
        10765  VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
        +
        10766 }
        +
        10767 
        +
        10768 bool VmaBlockMetadata_Linear::ShouldCompact1st() const
        +
        10769 {
        +
        10770  const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        +
        10771  const size_t suballocCount = AccessSuballocations1st().size();
        +
        10772  return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
        +
        10773 }
        +
        10774 
        +
        10775 void VmaBlockMetadata_Linear::CleanupAfterFree()
        +
        10776 {
        +
        10777  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        +
        10778  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        10779 
        -
        10780  // Find more null items at the end of 2nd vector.
        -
        10781  while(m_2ndNullItemsCount > 0 &&
        -
        10782  suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
        -
        10783  {
        -
        10784  --m_2ndNullItemsCount;
        -
        10785  suballocations2nd.pop_back();
        -
        10786  }
        -
        10787 
        -
        10788  // Find more null items at the beginning of 2nd vector.
        -
        10789  while(m_2ndNullItemsCount > 0 &&
        -
        10790  suballocations2nd[0].hAllocation == VK_NULL_HANDLE)
        -
        10791  {
        -
        10792  --m_2ndNullItemsCount;
        -
        10793  VmaVectorRemove(suballocations2nd, 0);
        -
        10794  }
        -
        10795 
        -
        10796  if(ShouldCompact1st())
        -
        10797  {
        -
        10798  const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
        -
        10799  size_t srcIndex = m_1stNullItemsBeginCount;
        -
        10800  for(size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
        -
        10801  {
        -
        10802  while(suballocations1st[srcIndex].hAllocation == VK_NULL_HANDLE)
        -
        10803  {
        -
        10804  ++srcIndex;
        -
        10805  }
        -
        10806  if(dstIndex != srcIndex)
        -
        10807  {
        -
        10808  suballocations1st[dstIndex] = suballocations1st[srcIndex];
        -
        10809  }
        -
        10810  ++srcIndex;
        -
        10811  }
        -
        10812  suballocations1st.resize(nonNullItemCount);
        -
        10813  m_1stNullItemsBeginCount = 0;
        -
        10814  m_1stNullItemsMiddleCount = 0;
        -
        10815  }
        -
        10816 
        -
        10817  // 2nd vector became empty.
        -
        10818  if(suballocations2nd.empty())
        -
        10819  {
        -
        10820  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        -
        10821  }
        -
        10822 
        -
        10823  // 1st vector became empty.
        -
        10824  if(suballocations1st.size() - m_1stNullItemsBeginCount == 0)
        -
        10825  {
        -
        10826  suballocations1st.clear();
        -
        10827  m_1stNullItemsBeginCount = 0;
        -
        10828 
        -
        10829  if(!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        -
        10830  {
        -
        10831  // Swap 1st with 2nd. Now 2nd is empty.
        -
        10832  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        -
        10833  m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
        -
        10834  while(m_1stNullItemsBeginCount < suballocations2nd.size() &&
        -
        10835  suballocations2nd[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        -
        10836  {
        -
        10837  ++m_1stNullItemsBeginCount;
        -
        10838  --m_1stNullItemsMiddleCount;
        -
        10839  }
        -
        10840  m_2ndNullItemsCount = 0;
        -
        10841  m_1stVectorIndex ^= 1;
        +
        10780  if(IsEmpty())
        +
        10781  {
        +
        10782  suballocations1st.clear();
        +
        10783  suballocations2nd.clear();
        +
        10784  m_1stNullItemsBeginCount = 0;
        +
        10785  m_1stNullItemsMiddleCount = 0;
        +
        10786  m_2ndNullItemsCount = 0;
        +
        10787  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        +
        10788  }
        +
        10789  else
        +
        10790  {
        +
        10791  const size_t suballoc1stCount = suballocations1st.size();
        +
        10792  const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        +
        10793  VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
        +
        10794 
        +
        10795  // Find more null items at the beginning of 1st vector.
        +
        10796  while(m_1stNullItemsBeginCount < suballoc1stCount &&
        +
        10797  suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        +
        10798  {
        +
        10799  ++m_1stNullItemsBeginCount;
        +
        10800  --m_1stNullItemsMiddleCount;
        +
        10801  }
        +
        10802 
        +
        10803  // Find more null items at the end of 1st vector.
        +
        10804  while(m_1stNullItemsMiddleCount > 0 &&
        +
        10805  suballocations1st.back().hAllocation == VK_NULL_HANDLE)
        +
        10806  {
        +
        10807  --m_1stNullItemsMiddleCount;
        +
        10808  suballocations1st.pop_back();
        +
        10809  }
        +
        10810 
        +
        10811  // Find more null items at the end of 2nd vector.
        +
        10812  while(m_2ndNullItemsCount > 0 &&
        +
        10813  suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
        +
        10814  {
        +
        10815  --m_2ndNullItemsCount;
        +
        10816  suballocations2nd.pop_back();
        +
        10817  }
        +
        10818 
        +
        10819  // Find more null items at the beginning of 2nd vector.
        +
        10820  while(m_2ndNullItemsCount > 0 &&
        +
        10821  suballocations2nd[0].hAllocation == VK_NULL_HANDLE)
        +
        10822  {
        +
        10823  --m_2ndNullItemsCount;
        +
        10824  VmaVectorRemove(suballocations2nd, 0);
        +
        10825  }
        +
        10826 
        +
        10827  if(ShouldCompact1st())
        +
        10828  {
        +
        10829  const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
        +
        10830  size_t srcIndex = m_1stNullItemsBeginCount;
        +
        10831  for(size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
        +
        10832  {
        +
        10833  while(suballocations1st[srcIndex].hAllocation == VK_NULL_HANDLE)
        +
        10834  {
        +
        10835  ++srcIndex;
        +
        10836  }
        +
        10837  if(dstIndex != srcIndex)
        +
        10838  {
        +
        10839  suballocations1st[dstIndex] = suballocations1st[srcIndex];
        +
        10840  }
        +
        10841  ++srcIndex;
        10842  }
        -
        10843  }
        -
        10844  }
        -
        10845 
        -
        10846  VMA_HEAVY_ASSERT(Validate());
        -
        10847 }
        -
        10848 
        -
        10849 
        -
        10851 // class VmaBlockMetadata_Buddy
        -
        10852 
        -
        10853 VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(VmaAllocator hAllocator) :
        -
        10854  VmaBlockMetadata(hAllocator),
        -
        10855  m_Root(VMA_NULL),
        -
        10856  m_AllocationCount(0),
        -
        10857  m_FreeCount(1),
        -
        10858  m_SumFreeSize(0)
        -
        10859 {
        -
        10860  memset(m_FreeList, 0, sizeof(m_FreeList));
        -
        10861 }
        -
        10862 
        -
        10863 VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
        -
        10864 {
        -
        10865  DeleteNode(m_Root);
        -
        10866 }
        -
        10867 
        -
        10868 void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
        -
        10869 {
        -
        10870  VmaBlockMetadata::Init(size);
        -
        10871 
        -
        10872  m_UsableSize = VmaPrevPow2(size);
        -
        10873  m_SumFreeSize = m_UsableSize;
        -
        10874 
        -
        10875  // Calculate m_LevelCount.
        -
        10876  m_LevelCount = 1;
        -
        10877  while(m_LevelCount < MAX_LEVELS &&
        -
        10878  LevelToNodeSize(m_LevelCount) >= MIN_NODE_SIZE)
        -
        10879  {
        -
        10880  ++m_LevelCount;
        -
        10881  }
        -
        10882 
        -
        10883  Node* rootNode = vma_new(GetAllocationCallbacks(), Node)();
        -
        10884  rootNode->offset = 0;
        -
        10885  rootNode->type = Node::TYPE_FREE;
        -
        10886  rootNode->parent = VMA_NULL;
        -
        10887  rootNode->buddy = VMA_NULL;
        -
        10888 
        -
        10889  m_Root = rootNode;
        -
        10890  AddToFreeListFront(0, rootNode);
        -
        10891 }
        -
        10892 
        -
        10893 bool VmaBlockMetadata_Buddy::Validate() const
        -
        10894 {
        -
        10895  // Validate tree.
        -
        10896  ValidationContext ctx;
        -
        10897  if(!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
        -
        10898  {
        -
        10899  VMA_VALIDATE(false && "ValidateNode failed.");
        -
        10900  }
        -
        10901  VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
        -
        10902  VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);
        -
        10903 
        -
        10904  // Validate free node lists.
        -
        10905  for(uint32_t level = 0; level < m_LevelCount; ++level)
        -
        10906  {
        -
        10907  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
        -
        10908  m_FreeList[level].front->free.prev == VMA_NULL);
        -
        10909 
        -
        10910  for(Node* node = m_FreeList[level].front;
        -
        10911  node != VMA_NULL;
        -
        10912  node = node->free.next)
        -
        10913  {
        -
        10914  VMA_VALIDATE(node->type == Node::TYPE_FREE);
        -
        10915 
        -
        10916  if(node->free.next == VMA_NULL)
        -
        10917  {
        -
        10918  VMA_VALIDATE(m_FreeList[level].back == node);
        -
        10919  }
        -
        10920  else
        -
        10921  {
        -
        10922  VMA_VALIDATE(node->free.next->free.prev == node);
        -
        10923  }
        -
        10924  }
        -
        10925  }
        -
        10926 
        -
        10927  // Validate that free lists ar higher levels are empty.
        -
        10928  for(uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
        +
        10843  suballocations1st.resize(nonNullItemCount);
        +
        10844  m_1stNullItemsBeginCount = 0;
        +
        10845  m_1stNullItemsMiddleCount = 0;
        +
        10846  }
        +
        10847 
        +
        10848  // 2nd vector became empty.
        +
        10849  if(suballocations2nd.empty())
        +
        10850  {
        +
        10851  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        +
        10852  }
        +
        10853 
        +
        10854  // 1st vector became empty.
        +
        10855  if(suballocations1st.size() - m_1stNullItemsBeginCount == 0)
        +
        10856  {
        +
        10857  suballocations1st.clear();
        +
        10858  m_1stNullItemsBeginCount = 0;
        +
        10859 
        +
        10860  if(!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        +
        10861  {
        +
        10862  // Swap 1st with 2nd. Now 2nd is empty.
        +
        10863  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        +
        10864  m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
        +
        10865  while(m_1stNullItemsBeginCount < suballocations2nd.size() &&
        +
        10866  suballocations2nd[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        +
        10867  {
        +
        10868  ++m_1stNullItemsBeginCount;
        +
        10869  --m_1stNullItemsMiddleCount;
        +
        10870  }
        +
        10871  m_2ndNullItemsCount = 0;
        +
        10872  m_1stVectorIndex ^= 1;
        +
        10873  }
        +
        10874  }
        +
        10875  }
        +
        10876 
        +
        10877  VMA_HEAVY_ASSERT(Validate());
        +
        10878 }
        +
        10879 
        +
        10880 
        +
        10882 // class VmaBlockMetadata_Buddy
        +
        10883 
        +
        10884 VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(VmaAllocator hAllocator) :
        +
        10885  VmaBlockMetadata(hAllocator),
        +
        10886  m_Root(VMA_NULL),
        +
        10887  m_AllocationCount(0),
        +
        10888  m_FreeCount(1),
        +
        10889  m_SumFreeSize(0)
        +
        10890 {
        +
        10891  memset(m_FreeList, 0, sizeof(m_FreeList));
        +
        10892 }
        +
        10893 
        +
        10894 VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
        +
        10895 {
        +
        10896  DeleteNode(m_Root);
        +
        10897 }
        +
        10898 
        +
        10899 void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
        +
        10900 {
        +
        10901  VmaBlockMetadata::Init(size);
        +
        10902 
        +
        10903  m_UsableSize = VmaPrevPow2(size);
        +
        10904  m_SumFreeSize = m_UsableSize;
        +
        10905 
        +
        10906  // Calculate m_LevelCount.
        +
        10907  m_LevelCount = 1;
        +
        10908  while(m_LevelCount < MAX_LEVELS &&
        +
        10909  LevelToNodeSize(m_LevelCount) >= MIN_NODE_SIZE)
        +
        10910  {
        +
        10911  ++m_LevelCount;
        +
        10912  }
        +
        10913 
        +
        10914  Node* rootNode = vma_new(GetAllocationCallbacks(), Node)();
        +
        10915  rootNode->offset = 0;
        +
        10916  rootNode->type = Node::TYPE_FREE;
        +
        10917  rootNode->parent = VMA_NULL;
        +
        10918  rootNode->buddy = VMA_NULL;
        +
        10919 
        +
        10920  m_Root = rootNode;
        +
        10921  AddToFreeListFront(0, rootNode);
        +
        10922 }
        +
        10923 
        +
        10924 bool VmaBlockMetadata_Buddy::Validate() const
        +
        10925 {
        +
        10926  // Validate tree.
        +
        10927  ValidationContext ctx;
        +
        10928  if(!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
        10929  {
        -
        10930  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
        +
        10930  VMA_VALIDATE(false && "ValidateNode failed.");
        10931  }
        -
        10932 
        -
        10933  return true;
        -
        10934 }
        -
        10935 
        -
        10936 VkDeviceSize VmaBlockMetadata_Buddy::GetUnusedRangeSizeMax() const
        -
        10937 {
        -
        10938  for(uint32_t level = 0; level < m_LevelCount; ++level)
        -
        10939  {
        -
        10940  if(m_FreeList[level].front != VMA_NULL)
        -
        10941  {
        -
        10942  return LevelToNodeSize(level);
        -
        10943  }
        -
        10944  }
        -
        10945  return 0;
        -
        10946 }
        -
        10947 
        -
        10948 void VmaBlockMetadata_Buddy::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        -
        10949 {
        -
        10950  const VkDeviceSize unusableSize = GetUnusableSize();
        -
        10951 
        -
        10952  outInfo.blockCount = 1;
        -
        10953 
        -
        10954  outInfo.allocationCount = outInfo.unusedRangeCount = 0;
        -
        10955  outInfo.usedBytes = outInfo.unusedBytes = 0;
        -
        10956 
        -
        10957  outInfo.allocationSizeMax = outInfo.unusedRangeSizeMax = 0;
        -
        10958  outInfo.allocationSizeMin = outInfo.unusedRangeSizeMin = UINT64_MAX;
        -
        10959  outInfo.allocationSizeAvg = outInfo.unusedRangeSizeAvg = 0; // Unused.
        -
        10960 
        -
        10961  CalcAllocationStatInfoNode(outInfo, m_Root, LevelToNodeSize(0));
        -
        10962 
        -
        10963  if(unusableSize > 0)
        -
        10964  {
        -
        10965  ++outInfo.unusedRangeCount;
        -
        10966  outInfo.unusedBytes += unusableSize;
        -
        10967  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusableSize);
        -
        10968  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusableSize);
        -
        10969  }
        -
        10970 }
        -
        10971 
        -
        10972 void VmaBlockMetadata_Buddy::AddPoolStats(VmaPoolStats& inoutStats) const
        -
        10973 {
        -
        10974  const VkDeviceSize unusableSize = GetUnusableSize();
        -
        10975 
        -
        10976  inoutStats.size += GetSize();
        -
        10977  inoutStats.unusedSize += m_SumFreeSize + unusableSize;
        -
        10978  inoutStats.allocationCount += m_AllocationCount;
        -
        10979  inoutStats.unusedRangeCount += m_FreeCount;
        -
        10980  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
        -
        10981 
        -
        10982  if(unusableSize > 0)
        -
        10983  {
        -
        10984  ++inoutStats.unusedRangeCount;
        -
        10985  // Not updating inoutStats.unusedRangeSizeMax with unusableSize because this space is not available for allocations.
        -
        10986  }
        -
        10987 }
        -
        10988 
        -
        10989 #if VMA_STATS_STRING_ENABLED
        -
        10990 
        -
        10991 void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json) const
        -
        10992 {
        -
        10993  // TODO optimize
        -
        10994  VmaStatInfo stat;
        -
        10995  CalcAllocationStatInfo(stat);
        -
        10996 
        -
        10997  PrintDetailedMap_Begin(
        -
        10998  json,
        -
        10999  stat.unusedBytes,
        -
        11000  stat.allocationCount,
        -
        11001  stat.unusedRangeCount);
        +
        10932  VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
        +
        10933  VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);
        +
        10934 
        +
        10935  // Validate free node lists.
        +
        10936  for(uint32_t level = 0; level < m_LevelCount; ++level)
        +
        10937  {
        +
        10938  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
        +
        10939  m_FreeList[level].front->free.prev == VMA_NULL);
        +
        10940 
        +
        10941  for(Node* node = m_FreeList[level].front;
        +
        10942  node != VMA_NULL;
        +
        10943  node = node->free.next)
        +
        10944  {
        +
        10945  VMA_VALIDATE(node->type == Node::TYPE_FREE);
        +
        10946 
        +
        10947  if(node->free.next == VMA_NULL)
        +
        10948  {
        +
        10949  VMA_VALIDATE(m_FreeList[level].back == node);
        +
        10950  }
        +
        10951  else
        +
        10952  {
        +
        10953  VMA_VALIDATE(node->free.next->free.prev == node);
        +
        10954  }
        +
        10955  }
        +
        10956  }
        +
        10957 
        +
        10958  // Validate that free lists ar higher levels are empty.
        +
        10959  for(uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
        +
        10960  {
        +
        10961  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
        +
        10962  }
        +
        10963 
        +
        10964  return true;
        +
        10965 }
        +
        10966 
        +
        10967 VkDeviceSize VmaBlockMetadata_Buddy::GetUnusedRangeSizeMax() const
        +
        10968 {
        +
        10969  for(uint32_t level = 0; level < m_LevelCount; ++level)
        +
        10970  {
        +
        10971  if(m_FreeList[level].front != VMA_NULL)
        +
        10972  {
        +
        10973  return LevelToNodeSize(level);
        +
        10974  }
        +
        10975  }
        +
        10976  return 0;
        +
        10977 }
        +
        10978 
        +
        10979 void VmaBlockMetadata_Buddy::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        +
        10980 {
        +
        10981  const VkDeviceSize unusableSize = GetUnusableSize();
        +
        10982 
        +
        10983  outInfo.blockCount = 1;
        +
        10984 
        +
        10985  outInfo.allocationCount = outInfo.unusedRangeCount = 0;
        +
        10986  outInfo.usedBytes = outInfo.unusedBytes = 0;
        +
        10987 
        +
        10988  outInfo.allocationSizeMax = outInfo.unusedRangeSizeMax = 0;
        +
        10989  outInfo.allocationSizeMin = outInfo.unusedRangeSizeMin = UINT64_MAX;
        +
        10990  outInfo.allocationSizeAvg = outInfo.unusedRangeSizeAvg = 0; // Unused.
        +
        10991 
        +
        10992  CalcAllocationStatInfoNode(outInfo, m_Root, LevelToNodeSize(0));
        +
        10993 
        +
        10994  if(unusableSize > 0)
        +
        10995  {
        +
        10996  ++outInfo.unusedRangeCount;
        +
        10997  outInfo.unusedBytes += unusableSize;
        +
        10998  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusableSize);
        +
        10999  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusableSize);
        +
        11000  }
        +
        11001 }
        11002 
        -
        11003  PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));
        -
        11004 
        +
        11003 void VmaBlockMetadata_Buddy::AddPoolStats(VmaPoolStats& inoutStats) const
        +
        11004 {
        11005  const VkDeviceSize unusableSize = GetUnusableSize();
        -
        11006  if(unusableSize > 0)
        -
        11007  {
        -
        11008  PrintDetailedMap_UnusedRange(json,
        -
        11009  m_UsableSize, // offset
        -
        11010  unusableSize); // size
        -
        11011  }
        +
        11006 
        +
        11007  inoutStats.size += GetSize();
        +
        11008  inoutStats.unusedSize += m_SumFreeSize + unusableSize;
        +
        11009  inoutStats.allocationCount += m_AllocationCount;
        +
        11010  inoutStats.unusedRangeCount += m_FreeCount;
        +
        11011  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
        11012 
        -
        11013  PrintDetailedMap_End(json);
        -
        11014 }
        -
        11015 
        -
        11016 #endif // #if VMA_STATS_STRING_ENABLED
        -
        11017 
        -
        11018 bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
        -
        11019  uint32_t currentFrameIndex,
        -
        11020  uint32_t frameInUseCount,
        -
        11021  VkDeviceSize bufferImageGranularity,
        -
        11022  VkDeviceSize allocSize,
        -
        11023  VkDeviceSize allocAlignment,
        -
        11024  bool upperAddress,
        -
        11025  VmaSuballocationType allocType,
        -
        11026  bool canMakeOtherLost,
        -
        11027  uint32_t strategy,
        -
        11028  VmaAllocationRequest* pAllocationRequest)
        -
        11029 {
        -
        11030  VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
        -
        11031 
        -
        11032  // Simple way to respect bufferImageGranularity. May be optimized some day.
        -
        11033  // Whenever it might be an OPTIMAL image...
        -
        11034  if(allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
        -
        11035  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        -
        11036  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
        -
        11037  {
        -
        11038  allocAlignment = VMA_MAX(allocAlignment, bufferImageGranularity);
        -
        11039  allocSize = VMA_MAX(allocSize, bufferImageGranularity);
        -
        11040  }
        -
        11041 
        -
        11042  if(allocSize > m_UsableSize)
        -
        11043  {
        -
        11044  return false;
        -
        11045  }
        +
        11013  if(unusableSize > 0)
        +
        11014  {
        +
        11015  ++inoutStats.unusedRangeCount;
        +
        11016  // Not updating inoutStats.unusedRangeSizeMax with unusableSize because this space is not available for allocations.
        +
        11017  }
        +
        11018 }
        +
        11019 
        +
        11020 #if VMA_STATS_STRING_ENABLED
        +
        11021 
        +
        11022 void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json) const
        +
        11023 {
        +
        11024  // TODO optimize
        +
        11025  VmaStatInfo stat;
        +
        11026  CalcAllocationStatInfo(stat);
        +
        11027 
        +
        11028  PrintDetailedMap_Begin(
        +
        11029  json,
        +
        11030  stat.unusedBytes,
        +
        11031  stat.allocationCount,
        +
        11032  stat.unusedRangeCount);
        +
        11033 
        +
        11034  PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));
        +
        11035 
        +
        11036  const VkDeviceSize unusableSize = GetUnusableSize();
        +
        11037  if(unusableSize > 0)
        +
        11038  {
        +
        11039  PrintDetailedMap_UnusedRange(json,
        +
        11040  m_UsableSize, // offset
        +
        11041  unusableSize); // size
        +
        11042  }
        +
        11043 
        +
        11044  PrintDetailedMap_End(json);
        +
        11045 }
        11046 
        -
        11047  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
        -
        11048  for(uint32_t level = targetLevel + 1; level--; )
        -
        11049  {
        -
        11050  for(Node* freeNode = m_FreeList[level].front;
        -
        11051  freeNode != VMA_NULL;
        -
        11052  freeNode = freeNode->free.next)
        -
        11053  {
        -
        11054  if(freeNode->offset % allocAlignment == 0)
        -
        11055  {
        -
        11056  pAllocationRequest->type = VmaAllocationRequestType::Normal;
        -
        11057  pAllocationRequest->offset = freeNode->offset;
        -
        11058  pAllocationRequest->sumFreeSize = LevelToNodeSize(level);
        -
        11059  pAllocationRequest->sumItemSize = 0;
        -
        11060  pAllocationRequest->itemsToMakeLostCount = 0;
        -
        11061  pAllocationRequest->customData = (void*)(uintptr_t)level;
        -
        11062  return true;
        -
        11063  }
        -
        11064  }
        -
        11065  }
        -
        11066 
        -
        11067  return false;
        -
        11068 }
        -
        11069 
        -
        11070 bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost(
        -
        11071  uint32_t currentFrameIndex,
        -
        11072  uint32_t frameInUseCount,
        -
        11073  VmaAllocationRequest* pAllocationRequest)
        -
        11074 {
        -
        11075  /*
        -
        11076  Lost allocations are not supported in buddy allocator at the moment.
        -
        11077  Support might be added in the future.
        -
        11078  */
        -
        11079  return pAllocationRequest->itemsToMakeLostCount == 0;
        -
        11080 }
        -
        11081 
        -
        11082 uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        -
        11083 {
        -
        11084  /*
        -
        11085  Lost allocations are not supported in buddy allocator at the moment.
        -
        11086  Support might be added in the future.
        -
        11087  */
        -
        11088  return 0;
        -
        11089 }
        -
        11090 
        -
        11091 void VmaBlockMetadata_Buddy::Alloc(
        -
        11092  const VmaAllocationRequest& request,
        -
        11093  VmaSuballocationType type,
        -
        11094  VkDeviceSize allocSize,
        -
        11095  VmaAllocation hAllocation)
        -
        11096 {
        -
        11097  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
        -
        11098 
        -
        11099  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
        -
        11100  uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;
        -
        11101 
        -
        11102  Node* currNode = m_FreeList[currLevel].front;
        -
        11103  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
        -
        11104  while(currNode->offset != request.offset)
        -
        11105  {
        -
        11106  currNode = currNode->free.next;
        -
        11107  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
        -
        11108  }
        -
        11109 
        -
        11110  // Go down, splitting free nodes.
        -
        11111  while(currLevel < targetLevel)
        -
        11112  {
        -
        11113  // currNode is already first free node at currLevel.
        -
        11114  // Remove it from list of free nodes at this currLevel.
        -
        11115  RemoveFromFreeList(currLevel, currNode);
        -
        11116 
        -
        11117  const uint32_t childrenLevel = currLevel + 1;
        -
        11118 
        -
        11119  // Create two free sub-nodes.
        -
        11120  Node* leftChild = vma_new(GetAllocationCallbacks(), Node)();
        -
        11121  Node* rightChild = vma_new(GetAllocationCallbacks(), Node)();
        -
        11122 
        -
        11123  leftChild->offset = currNode->offset;
        -
        11124  leftChild->type = Node::TYPE_FREE;
        -
        11125  leftChild->parent = currNode;
        -
        11126  leftChild->buddy = rightChild;
        -
        11127 
        -
        11128  rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
        -
        11129  rightChild->type = Node::TYPE_FREE;
        -
        11130  rightChild->parent = currNode;
        -
        11131  rightChild->buddy = leftChild;
        -
        11132 
        -
        11133  // Convert current currNode to split type.
        -
        11134  currNode->type = Node::TYPE_SPLIT;
        -
        11135  currNode->split.leftChild = leftChild;
        -
        11136 
        -
        11137  // Add child nodes to free list. Order is important!
        -
        11138  AddToFreeListFront(childrenLevel, rightChild);
        -
        11139  AddToFreeListFront(childrenLevel, leftChild);
        -
        11140 
        -
        11141  ++m_FreeCount;
        -
        11142  //m_SumFreeSize -= LevelToNodeSize(currLevel) % 2; // Useful only when level node sizes can be non power of 2.
        -
        11143  ++currLevel;
        -
        11144  currNode = m_FreeList[currLevel].front;
        -
        11145 
        -
        11146  /*
        -
        11147  We can be sure that currNode, as left child of node previously split,
        -
        11148  also fullfills the alignment requirement.
        -
        11149  */
        -
        11150  }
        -
        11151 
        -
        11152  // Remove from free list.
        -
        11153  VMA_ASSERT(currLevel == targetLevel &&
        -
        11154  currNode != VMA_NULL &&
        -
        11155  currNode->type == Node::TYPE_FREE);
        -
        11156  RemoveFromFreeList(currLevel, currNode);
        -
        11157 
        -
        11158  // Convert to allocation node.
        -
        11159  currNode->type = Node::TYPE_ALLOCATION;
        -
        11160  currNode->allocation.alloc = hAllocation;
        -
        11161 
        -
        11162  ++m_AllocationCount;
        -
        11163  --m_FreeCount;
        -
        11164  m_SumFreeSize -= allocSize;
        -
        11165 }
        -
        11166 
        -
        11167 void VmaBlockMetadata_Buddy::DeleteNode(Node* node)
        -
        11168 {
        -
        11169  if(node->type == Node::TYPE_SPLIT)
        -
        11170  {
        -
        11171  DeleteNode(node->split.leftChild->buddy);
        -
        11172  DeleteNode(node->split.leftChild);
        -
        11173  }
        -
        11174 
        -
        11175  vma_delete(GetAllocationCallbacks(), node);
        -
        11176 }
        -
        11177 
        -
        11178 bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
        -
        11179 {
        -
        11180  VMA_VALIDATE(level < m_LevelCount);
        -
        11181  VMA_VALIDATE(curr->parent == parent);
        -
        11182  VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
        -
        11183  VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
        -
        11184  switch(curr->type)
        -
        11185  {
        -
        11186  case Node::TYPE_FREE:
        -
        11187  // curr->free.prev, next are validated separately.
        -
        11188  ctx.calculatedSumFreeSize += levelNodeSize;
        -
        11189  ++ctx.calculatedFreeCount;
        -
        11190  break;
        -
        11191  case Node::TYPE_ALLOCATION:
        -
        11192  ++ctx.calculatedAllocationCount;
        -
        11193  ctx.calculatedSumFreeSize += levelNodeSize - curr->allocation.alloc->GetSize();
        -
        11194  VMA_VALIDATE(curr->allocation.alloc != VK_NULL_HANDLE);
        -
        11195  break;
        -
        11196  case Node::TYPE_SPLIT:
        -
        11197  {
        -
        11198  const uint32_t childrenLevel = level + 1;
        -
        11199  const VkDeviceSize childrenLevelNodeSize = levelNodeSize / 2;
        -
        11200  const Node* const leftChild = curr->split.leftChild;
        -
        11201  VMA_VALIDATE(leftChild != VMA_NULL);
        -
        11202  VMA_VALIDATE(leftChild->offset == curr->offset);
        -
        11203  if(!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
        -
        11204  {
        -
        11205  VMA_VALIDATE(false && "ValidateNode for left child failed.");
        -
        11206  }
        -
        11207  const Node* const rightChild = leftChild->buddy;
        -
        11208  VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
        -
        11209  if(!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
        -
        11210  {
        -
        11211  VMA_VALIDATE(false && "ValidateNode for right child failed.");
        -
        11212  }
        -
        11213  }
        -
        11214  break;
        -
        11215  default:
        -
        11216  return false;
        -
        11217  }
        -
        11218 
        -
        11219  return true;
        -
        11220 }
        -
        11221 
        -
        11222 uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
        -
        11223 {
        -
        11224  // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
        -
        11225  uint32_t level = 0;
        -
        11226  VkDeviceSize currLevelNodeSize = m_UsableSize;
        -
        11227  VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
        -
        11228  while(allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
        -
        11229  {
        -
        11230  ++level;
        -
        11231  currLevelNodeSize = nextLevelNodeSize;
        -
        11232  nextLevelNodeSize = currLevelNodeSize >> 1;
        -
        11233  }
        -
        11234  return level;
        -
        11235 }
        -
        11236 
        -
        11237 void VmaBlockMetadata_Buddy::FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset)
        -
        11238 {
        -
        11239  // Find node and level.
        -
        11240  Node* node = m_Root;
        -
        11241  VkDeviceSize nodeOffset = 0;
        -
        11242  uint32_t level = 0;
        -
        11243  VkDeviceSize levelNodeSize = LevelToNodeSize(0);
        -
        11244  while(node->type == Node::TYPE_SPLIT)
        -
        11245  {
        -
        11246  const VkDeviceSize nextLevelSize = levelNodeSize >> 1;
        -
        11247  if(offset < nodeOffset + nextLevelSize)
        -
        11248  {
        -
        11249  node = node->split.leftChild;
        -
        11250  }
        -
        11251  else
        -
        11252  {
        -
        11253  node = node->split.leftChild->buddy;
        -
        11254  nodeOffset += nextLevelSize;
        -
        11255  }
        -
        11256  ++level;
        -
        11257  levelNodeSize = nextLevelSize;
        -
        11258  }
        -
        11259 
        -
        11260  VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
        -
        11261  VMA_ASSERT(alloc == VK_NULL_HANDLE || node->allocation.alloc == alloc);
        -
        11262 
        -
        11263  ++m_FreeCount;
        -
        11264  --m_AllocationCount;
        -
        11265  m_SumFreeSize += alloc->GetSize();
        -
        11266 
        -
        11267  node->type = Node::TYPE_FREE;
        -
        11268 
        -
        11269  // Join free nodes if possible.
        -
        11270  while(level > 0 && node->buddy->type == Node::TYPE_FREE)
        -
        11271  {
        -
        11272  RemoveFromFreeList(level, node->buddy);
        -
        11273  Node* const parent = node->parent;
        -
        11274 
        -
        11275  vma_delete(GetAllocationCallbacks(), node->buddy);
        -
        11276  vma_delete(GetAllocationCallbacks(), node);
        -
        11277  parent->type = Node::TYPE_FREE;
        -
        11278 
        -
        11279  node = parent;
        -
        11280  --level;
        -
        11281  //m_SumFreeSize += LevelToNodeSize(level) % 2; // Useful only when level node sizes can be non power of 2.
        -
        11282  --m_FreeCount;
        -
        11283  }
        -
        11284 
        -
        11285  AddToFreeListFront(level, node);
        -
        11286 }
        -
        11287 
        -
        11288 void VmaBlockMetadata_Buddy::CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const
        -
        11289 {
        -
        11290  switch(node->type)
        -
        11291  {
        -
        11292  case Node::TYPE_FREE:
        -
        11293  ++outInfo.unusedRangeCount;
        -
        11294  outInfo.unusedBytes += levelNodeSize;
        -
        11295  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, levelNodeSize);
        -
        11296  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, levelNodeSize);
        -
        11297  break;
        -
        11298  case Node::TYPE_ALLOCATION:
        -
        11299  {
        -
        11300  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
        -
        11301  ++outInfo.allocationCount;
        -
        11302  outInfo.usedBytes += allocSize;
        -
        11303  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, allocSize);
        -
        11304  outInfo.allocationSizeMin = VMA_MAX(outInfo.allocationSizeMin, allocSize);
        +
        11047 #endif // #if VMA_STATS_STRING_ENABLED
        +
        11048 
        +
        11049 bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
        +
        11050  uint32_t currentFrameIndex,
        +
        11051  uint32_t frameInUseCount,
        +
        11052  VkDeviceSize bufferImageGranularity,
        +
        11053  VkDeviceSize allocSize,
        +
        11054  VkDeviceSize allocAlignment,
        +
        11055  bool upperAddress,
        +
        11056  VmaSuballocationType allocType,
        +
        11057  bool canMakeOtherLost,
        +
        11058  uint32_t strategy,
        +
        11059  VmaAllocationRequest* pAllocationRequest)
        +
        11060 {
        +
        11061  VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
        +
        11062 
        +
        11063  // Simple way to respect bufferImageGranularity. May be optimized some day.
        +
        11064  // Whenever it might be an OPTIMAL image...
        +
        11065  if(allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
        +
        11066  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        +
        11067  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
        +
        11068  {
        +
        11069  allocAlignment = VMA_MAX(allocAlignment, bufferImageGranularity);
        +
        11070  allocSize = VMA_MAX(allocSize, bufferImageGranularity);
        +
        11071  }
        +
        11072 
        +
        11073  if(allocSize > m_UsableSize)
        +
        11074  {
        +
        11075  return false;
        +
        11076  }
        +
        11077 
        +
        11078  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
        +
        11079  for(uint32_t level = targetLevel + 1; level--; )
        +
        11080  {
        +
        11081  for(Node* freeNode = m_FreeList[level].front;
        +
        11082  freeNode != VMA_NULL;
        +
        11083  freeNode = freeNode->free.next)
        +
        11084  {
        +
        11085  if(freeNode->offset % allocAlignment == 0)
        +
        11086  {
        +
        11087  pAllocationRequest->type = VmaAllocationRequestType::Normal;
        +
        11088  pAllocationRequest->offset = freeNode->offset;
        +
        11089  pAllocationRequest->sumFreeSize = LevelToNodeSize(level);
        +
        11090  pAllocationRequest->sumItemSize = 0;
        +
        11091  pAllocationRequest->itemsToMakeLostCount = 0;
        +
        11092  pAllocationRequest->customData = (void*)(uintptr_t)level;
        +
        11093  return true;
        +
        11094  }
        +
        11095  }
        +
        11096  }
        +
        11097 
        +
        11098  return false;
        +
        11099 }
        +
        11100 
        +
        11101 bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost(
        +
        11102  uint32_t currentFrameIndex,
        +
        11103  uint32_t frameInUseCount,
        +
        11104  VmaAllocationRequest* pAllocationRequest)
        +
        11105 {
        +
        11106  /*
        +
        11107  Lost allocations are not supported in buddy allocator at the moment.
        +
        11108  Support might be added in the future.
        +
        11109  */
        +
        11110  return pAllocationRequest->itemsToMakeLostCount == 0;
        +
        11111 }
        +
        11112 
        +
        11113 uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        +
        11114 {
        +
        11115  /*
        +
        11116  Lost allocations are not supported in buddy allocator at the moment.
        +
        11117  Support might be added in the future.
        +
        11118  */
        +
        11119  return 0;
        +
        11120 }
        +
        11121 
        +
        11122 void VmaBlockMetadata_Buddy::Alloc(
        +
        11123  const VmaAllocationRequest& request,
        +
        11124  VmaSuballocationType type,
        +
        11125  VkDeviceSize allocSize,
        +
        11126  VmaAllocation hAllocation)
        +
        11127 {
        +
        11128  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
        +
        11129 
        +
        11130  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
        +
        11131  uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;
        +
        11132 
        +
        11133  Node* currNode = m_FreeList[currLevel].front;
        +
        11134  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
        +
        11135  while(currNode->offset != request.offset)
        +
        11136  {
        +
        11137  currNode = currNode->free.next;
        +
        11138  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
        +
        11139  }
        +
        11140 
        +
        11141  // Go down, splitting free nodes.
        +
        11142  while(currLevel < targetLevel)
        +
        11143  {
        +
        11144  // currNode is already first free node at currLevel.
        +
        11145  // Remove it from list of free nodes at this currLevel.
        +
        11146  RemoveFromFreeList(currLevel, currNode);
        +
        11147 
        +
        11148  const uint32_t childrenLevel = currLevel + 1;
        +
        11149 
        +
        11150  // Create two free sub-nodes.
        +
        11151  Node* leftChild = vma_new(GetAllocationCallbacks(), Node)();
        +
        11152  Node* rightChild = vma_new(GetAllocationCallbacks(), Node)();
        +
        11153 
        +
        11154  leftChild->offset = currNode->offset;
        +
        11155  leftChild->type = Node::TYPE_FREE;
        +
        11156  leftChild->parent = currNode;
        +
        11157  leftChild->buddy = rightChild;
        +
        11158 
        +
        11159  rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
        +
        11160  rightChild->type = Node::TYPE_FREE;
        +
        11161  rightChild->parent = currNode;
        +
        11162  rightChild->buddy = leftChild;
        +
        11163 
        +
        11164  // Convert current currNode to split type.
        +
        11165  currNode->type = Node::TYPE_SPLIT;
        +
        11166  currNode->split.leftChild = leftChild;
        +
        11167 
        +
        11168  // Add child nodes to free list. Order is important!
        +
        11169  AddToFreeListFront(childrenLevel, rightChild);
        +
        11170  AddToFreeListFront(childrenLevel, leftChild);
        +
        11171 
        +
        11172  ++m_FreeCount;
        +
        11173  //m_SumFreeSize -= LevelToNodeSize(currLevel) % 2; // Useful only when level node sizes can be non power of 2.
        +
        11174  ++currLevel;
        +
        11175  currNode = m_FreeList[currLevel].front;
        +
        11176 
        +
        11177  /*
        +
        11178  We can be sure that currNode, as left child of node previously split,
        +
        11179  also fullfills the alignment requirement.
        +
        11180  */
        +
        11181  }
        +
        11182 
        +
        11183  // Remove from free list.
        +
        11184  VMA_ASSERT(currLevel == targetLevel &&
        +
        11185  currNode != VMA_NULL &&
        +
        11186  currNode->type == Node::TYPE_FREE);
        +
        11187  RemoveFromFreeList(currLevel, currNode);
        +
        11188 
        +
        11189  // Convert to allocation node.
        +
        11190  currNode->type = Node::TYPE_ALLOCATION;
        +
        11191  currNode->allocation.alloc = hAllocation;
        +
        11192 
        +
        11193  ++m_AllocationCount;
        +
        11194  --m_FreeCount;
        +
        11195  m_SumFreeSize -= allocSize;
        +
        11196 }
        +
        11197 
        +
        11198 void VmaBlockMetadata_Buddy::DeleteNode(Node* node)
        +
        11199 {
        +
        11200  if(node->type == Node::TYPE_SPLIT)
        +
        11201  {
        +
        11202  DeleteNode(node->split.leftChild->buddy);
        +
        11203  DeleteNode(node->split.leftChild);
        +
        11204  }
        +
        11205 
        +
        11206  vma_delete(GetAllocationCallbacks(), node);
        +
        11207 }
        +
        11208 
        +
        11209 bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
        +
        11210 {
        +
        11211  VMA_VALIDATE(level < m_LevelCount);
        +
        11212  VMA_VALIDATE(curr->parent == parent);
        +
        11213  VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
        +
        11214  VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
        +
        11215  switch(curr->type)
        +
        11216  {
        +
        11217  case Node::TYPE_FREE:
        +
        11218  // curr->free.prev, next are validated separately.
        +
        11219  ctx.calculatedSumFreeSize += levelNodeSize;
        +
        11220  ++ctx.calculatedFreeCount;
        +
        11221  break;
        +
        11222  case Node::TYPE_ALLOCATION:
        +
        11223  ++ctx.calculatedAllocationCount;
        +
        11224  ctx.calculatedSumFreeSize += levelNodeSize - curr->allocation.alloc->GetSize();
        +
        11225  VMA_VALIDATE(curr->allocation.alloc != VK_NULL_HANDLE);
        +
        11226  break;
        +
        11227  case Node::TYPE_SPLIT:
        +
        11228  {
        +
        11229  const uint32_t childrenLevel = level + 1;
        +
        11230  const VkDeviceSize childrenLevelNodeSize = levelNodeSize / 2;
        +
        11231  const Node* const leftChild = curr->split.leftChild;
        +
        11232  VMA_VALIDATE(leftChild != VMA_NULL);
        +
        11233  VMA_VALIDATE(leftChild->offset == curr->offset);
        +
        11234  if(!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
        +
        11235  {
        +
        11236  VMA_VALIDATE(false && "ValidateNode for left child failed.");
        +
        11237  }
        +
        11238  const Node* const rightChild = leftChild->buddy;
        +
        11239  VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
        +
        11240  if(!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
        +
        11241  {
        +
        11242  VMA_VALIDATE(false && "ValidateNode for right child failed.");
        +
        11243  }
        +
        11244  }
        +
        11245  break;
        +
        11246  default:
        +
        11247  return false;
        +
        11248  }
        +
        11249 
        +
        11250  return true;
        +
        11251 }
        +
        11252 
        +
        11253 uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
        +
        11254 {
        +
        11255  // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
        +
        11256  uint32_t level = 0;
        +
        11257  VkDeviceSize currLevelNodeSize = m_UsableSize;
        +
        11258  VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
        +
        11259  while(allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
        +
        11260  {
        +
        11261  ++level;
        +
        11262  currLevelNodeSize = nextLevelNodeSize;
        +
        11263  nextLevelNodeSize = currLevelNodeSize >> 1;
        +
        11264  }
        +
        11265  return level;
        +
        11266 }
        +
        11267 
        +
        11268 void VmaBlockMetadata_Buddy::FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset)
        +
        11269 {
        +
        11270  // Find node and level.
        +
        11271  Node* node = m_Root;
        +
        11272  VkDeviceSize nodeOffset = 0;
        +
        11273  uint32_t level = 0;
        +
        11274  VkDeviceSize levelNodeSize = LevelToNodeSize(0);
        +
        11275  while(node->type == Node::TYPE_SPLIT)
        +
        11276  {
        +
        11277  const VkDeviceSize nextLevelSize = levelNodeSize >> 1;
        +
        11278  if(offset < nodeOffset + nextLevelSize)
        +
        11279  {
        +
        11280  node = node->split.leftChild;
        +
        11281  }
        +
        11282  else
        +
        11283  {
        +
        11284  node = node->split.leftChild->buddy;
        +
        11285  nodeOffset += nextLevelSize;
        +
        11286  }
        +
        11287  ++level;
        +
        11288  levelNodeSize = nextLevelSize;
        +
        11289  }
        +
        11290 
        +
        11291  VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
        +
        11292  VMA_ASSERT(alloc == VK_NULL_HANDLE || node->allocation.alloc == alloc);
        +
        11293 
        +
        11294  ++m_FreeCount;
        +
        11295  --m_AllocationCount;
        +
        11296  m_SumFreeSize += alloc->GetSize();
        +
        11297 
        +
        11298  node->type = Node::TYPE_FREE;
        +
        11299 
        +
        11300  // Join free nodes if possible.
        +
        11301  while(level > 0 && node->buddy->type == Node::TYPE_FREE)
        +
        11302  {
        +
        11303  RemoveFromFreeList(level, node->buddy);
        +
        11304  Node* const parent = node->parent;
        11305 
        -
        11306  const VkDeviceSize unusedRangeSize = levelNodeSize - allocSize;
        -
        11307  if(unusedRangeSize > 0)
        -
        11308  {
        -
        11309  ++outInfo.unusedRangeCount;
        -
        11310  outInfo.unusedBytes += unusedRangeSize;
        -
        11311  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusedRangeSize);
        -
        11312  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, unusedRangeSize);
        -
        11313  }
        -
        11314  }
        -
        11315  break;
        -
        11316  case Node::TYPE_SPLIT:
        -
        11317  {
        -
        11318  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
        -
        11319  const Node* const leftChild = node->split.leftChild;
        -
        11320  CalcAllocationStatInfoNode(outInfo, leftChild, childrenNodeSize);
        -
        11321  const Node* const rightChild = leftChild->buddy;
        -
        11322  CalcAllocationStatInfoNode(outInfo, rightChild, childrenNodeSize);
        -
        11323  }
        -
        11324  break;
        -
        11325  default:
        -
        11326  VMA_ASSERT(0);
        -
        11327  }
        -
        11328 }
        -
        11329 
        -
        11330 void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
        -
        11331 {
        -
        11332  VMA_ASSERT(node->type == Node::TYPE_FREE);
        -
        11333 
        -
        11334  // List is empty.
        -
        11335  Node* const frontNode = m_FreeList[level].front;
        -
        11336  if(frontNode == VMA_NULL)
        -
        11337  {
        -
        11338  VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
        -
        11339  node->free.prev = node->free.next = VMA_NULL;
        -
        11340  m_FreeList[level].front = m_FreeList[level].back = node;
        -
        11341  }
        -
        11342  else
        -
        11343  {
        -
        11344  VMA_ASSERT(frontNode->free.prev == VMA_NULL);
        -
        11345  node->free.prev = VMA_NULL;
        -
        11346  node->free.next = frontNode;
        -
        11347  frontNode->free.prev = node;
        -
        11348  m_FreeList[level].front = node;
        -
        11349  }
        -
        11350 }
        -
        11351 
        -
        11352 void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
        -
        11353 {
        -
        11354  VMA_ASSERT(m_FreeList[level].front != VMA_NULL);
        -
        11355 
        -
        11356  // It is at the front.
        -
        11357  if(node->free.prev == VMA_NULL)
        -
        11358  {
        -
        11359  VMA_ASSERT(m_FreeList[level].front == node);
        -
        11360  m_FreeList[level].front = node->free.next;
        -
        11361  }
        -
        11362  else
        -
        11363  {
        -
        11364  Node* const prevFreeNode = node->free.prev;
        -
        11365  VMA_ASSERT(prevFreeNode->free.next == node);
        -
        11366  prevFreeNode->free.next = node->free.next;
        -
        11367  }
        -
        11368 
        -
        11369  // It is at the back.
        -
        11370  if(node->free.next == VMA_NULL)
        -
        11371  {
        -
        11372  VMA_ASSERT(m_FreeList[level].back == node);
        -
        11373  m_FreeList[level].back = node->free.prev;
        -
        11374  }
        -
        11375  else
        -
        11376  {
        -
        11377  Node* const nextFreeNode = node->free.next;
        -
        11378  VMA_ASSERT(nextFreeNode->free.prev == node);
        -
        11379  nextFreeNode->free.prev = node->free.prev;
        +
        11306  vma_delete(GetAllocationCallbacks(), node->buddy);
        +
        11307  vma_delete(GetAllocationCallbacks(), node);
        +
        11308  parent->type = Node::TYPE_FREE;
        +
        11309 
        +
        11310  node = parent;
        +
        11311  --level;
        +
        11312  //m_SumFreeSize += LevelToNodeSize(level) % 2; // Useful only when level node sizes can be non power of 2.
        +
        11313  --m_FreeCount;
        +
        11314  }
        +
        11315 
        +
        11316  AddToFreeListFront(level, node);
        +
        11317 }
        +
        11318 
        +
        11319 void VmaBlockMetadata_Buddy::CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const
        +
        11320 {
        +
        11321  switch(node->type)
        +
        11322  {
        +
        11323  case Node::TYPE_FREE:
        +
        11324  ++outInfo.unusedRangeCount;
        +
        11325  outInfo.unusedBytes += levelNodeSize;
        +
        11326  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, levelNodeSize);
        +
        11327  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, levelNodeSize);
        +
        11328  break;
        +
        11329  case Node::TYPE_ALLOCATION:
        +
        11330  {
        +
        11331  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
        +
        11332  ++outInfo.allocationCount;
        +
        11333  outInfo.usedBytes += allocSize;
        +
        11334  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, allocSize);
        +
        11335  outInfo.allocationSizeMin = VMA_MAX(outInfo.allocationSizeMin, allocSize);
        +
        11336 
        +
        11337  const VkDeviceSize unusedRangeSize = levelNodeSize - allocSize;
        +
        11338  if(unusedRangeSize > 0)
        +
        11339  {
        +
        11340  ++outInfo.unusedRangeCount;
        +
        11341  outInfo.unusedBytes += unusedRangeSize;
        +
        11342  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusedRangeSize);
        +
        11343  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, unusedRangeSize);
        +
        11344  }
        +
        11345  }
        +
        11346  break;
        +
        11347  case Node::TYPE_SPLIT:
        +
        11348  {
        +
        11349  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
        +
        11350  const Node* const leftChild = node->split.leftChild;
        +
        11351  CalcAllocationStatInfoNode(outInfo, leftChild, childrenNodeSize);
        +
        11352  const Node* const rightChild = leftChild->buddy;
        +
        11353  CalcAllocationStatInfoNode(outInfo, rightChild, childrenNodeSize);
        +
        11354  }
        +
        11355  break;
        +
        11356  default:
        +
        11357  VMA_ASSERT(0);
        +
        11358  }
        +
        11359 }
        +
        11360 
        +
        11361 void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
        +
        11362 {
        +
        11363  VMA_ASSERT(node->type == Node::TYPE_FREE);
        +
        11364 
        +
        11365  // List is empty.
        +
        11366  Node* const frontNode = m_FreeList[level].front;
        +
        11367  if(frontNode == VMA_NULL)
        +
        11368  {
        +
        11369  VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
        +
        11370  node->free.prev = node->free.next = VMA_NULL;
        +
        11371  m_FreeList[level].front = m_FreeList[level].back = node;
        +
        11372  }
        +
        11373  else
        +
        11374  {
        +
        11375  VMA_ASSERT(frontNode->free.prev == VMA_NULL);
        +
        11376  node->free.prev = VMA_NULL;
        +
        11377  node->free.next = frontNode;
        +
        11378  frontNode->free.prev = node;
        +
        11379  m_FreeList[level].front = node;
        11380  }
        11381 }
        11382 
        -
        11383 #if VMA_STATS_STRING_ENABLED
        -
        11384 void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
        -
        11385 {
        -
        11386  switch(node->type)
        -
        11387  {
        -
        11388  case Node::TYPE_FREE:
        -
        11389  PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
        -
        11390  break;
        -
        11391  case Node::TYPE_ALLOCATION:
        -
        11392  {
        -
        11393  PrintDetailedMap_Allocation(json, node->offset, node->allocation.alloc);
        -
        11394  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
        -
        11395  if(allocSize < levelNodeSize)
        -
        11396  {
        -
        11397  PrintDetailedMap_UnusedRange(json, node->offset + allocSize, levelNodeSize - allocSize);
        -
        11398  }
        -
        11399  }
        -
        11400  break;
        -
        11401  case Node::TYPE_SPLIT:
        -
        11402  {
        -
        11403  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
        -
        11404  const Node* const leftChild = node->split.leftChild;
        -
        11405  PrintDetailedMapNode(json, leftChild, childrenNodeSize);
        -
        11406  const Node* const rightChild = leftChild->buddy;
        -
        11407  PrintDetailedMapNode(json, rightChild, childrenNodeSize);
        -
        11408  }
        -
        11409  break;
        -
        11410  default:
        -
        11411  VMA_ASSERT(0);
        -
        11412  }
        -
        11413 }
        -
        11414 #endif // #if VMA_STATS_STRING_ENABLED
        -
        11415 
        -
        11416 
        -
        11418 // class VmaDeviceMemoryBlock
        -
        11419 
        -
        11420 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
        -
        11421  m_pMetadata(VMA_NULL),
        -
        11422  m_MemoryTypeIndex(UINT32_MAX),
        -
        11423  m_Id(0),
        -
        11424  m_hMemory(VK_NULL_HANDLE),
        -
        11425  m_MapCount(0),
        -
        11426  m_pMappedData(VMA_NULL)
        -
        11427 {
        -
        11428 }
        -
        11429 
        -
        11430 void VmaDeviceMemoryBlock::Init(
        -
        11431  VmaAllocator hAllocator,
        -
        11432  VmaPool hParentPool,
        -
        11433  uint32_t newMemoryTypeIndex,
        -
        11434  VkDeviceMemory newMemory,
        -
        11435  VkDeviceSize newSize,
        -
        11436  uint32_t id,
        -
        11437  uint32_t algorithm)
        -
        11438 {
        -
        11439  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        -
        11440 
        -
        11441  m_hParentPool = hParentPool;
        -
        11442  m_MemoryTypeIndex = newMemoryTypeIndex;
        -
        11443  m_Id = id;
        -
        11444  m_hMemory = newMemory;
        -
        11445 
        -
        11446  switch(algorithm)
        -
        11447  {
        -
        11448  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
        -
        11449  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator);
        -
        11450  break;
        -
        11451  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
        -
        11452  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Buddy)(hAllocator);
        -
        11453  break;
        -
        11454  default:
        -
        11455  VMA_ASSERT(0);
        -
        11456  // Fall-through.
        -
        11457  case 0:
        -
        11458  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);
        -
        11459  }
        -
        11460  m_pMetadata->Init(newSize);
        -
        11461 }
        -
        11462 
        -
        11463 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
        -
        11464 {
        -
        11465  // This is the most important assert in the entire library.
        -
        11466  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
        -
        11467  VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
        -
        11468 
        -
        11469  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
        -
        11470  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
        -
        11471  m_hMemory = VK_NULL_HANDLE;
        -
        11472 
        -
        11473  vma_delete(allocator, m_pMetadata);
        -
        11474  m_pMetadata = VMA_NULL;
        -
        11475 }
        +
        11383 void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
        +
        11384 {
        +
        11385  VMA_ASSERT(m_FreeList[level].front != VMA_NULL);
        +
        11386 
        +
        11387  // It is at the front.
        +
        11388  if(node->free.prev == VMA_NULL)
        +
        11389  {
        +
        11390  VMA_ASSERT(m_FreeList[level].front == node);
        +
        11391  m_FreeList[level].front = node->free.next;
        +
        11392  }
        +
        11393  else
        +
        11394  {
        +
        11395  Node* const prevFreeNode = node->free.prev;
        +
        11396  VMA_ASSERT(prevFreeNode->free.next == node);
        +
        11397  prevFreeNode->free.next = node->free.next;
        +
        11398  }
        +
        11399 
        +
        11400  // It is at the back.
        +
        11401  if(node->free.next == VMA_NULL)
        +
        11402  {
        +
        11403  VMA_ASSERT(m_FreeList[level].back == node);
        +
        11404  m_FreeList[level].back = node->free.prev;
        +
        11405  }
        +
        11406  else
        +
        11407  {
        +
        11408  Node* const nextFreeNode = node->free.next;
        +
        11409  VMA_ASSERT(nextFreeNode->free.prev == node);
        +
        11410  nextFreeNode->free.prev = node->free.prev;
        +
        11411  }
        +
        11412 }
        +
        11413 
        +
        11414 #if VMA_STATS_STRING_ENABLED
        +
        11415 void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
        +
        11416 {
        +
        11417  switch(node->type)
        +
        11418  {
        +
        11419  case Node::TYPE_FREE:
        +
        11420  PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
        +
        11421  break;
        +
        11422  case Node::TYPE_ALLOCATION:
        +
        11423  {
        +
        11424  PrintDetailedMap_Allocation(json, node->offset, node->allocation.alloc);
        +
        11425  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
        +
        11426  if(allocSize < levelNodeSize)
        +
        11427  {
        +
        11428  PrintDetailedMap_UnusedRange(json, node->offset + allocSize, levelNodeSize - allocSize);
        +
        11429  }
        +
        11430  }
        +
        11431  break;
        +
        11432  case Node::TYPE_SPLIT:
        +
        11433  {
        +
        11434  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
        +
        11435  const Node* const leftChild = node->split.leftChild;
        +
        11436  PrintDetailedMapNode(json, leftChild, childrenNodeSize);
        +
        11437  const Node* const rightChild = leftChild->buddy;
        +
        11438  PrintDetailedMapNode(json, rightChild, childrenNodeSize);
        +
        11439  }
        +
        11440  break;
        +
        11441  default:
        +
        11442  VMA_ASSERT(0);
        +
        11443  }
        +
        11444 }
        +
        11445 #endif // #if VMA_STATS_STRING_ENABLED
        +
        11446 
        +
        11447 
        +
        11449 // class VmaDeviceMemoryBlock
        +
        11450 
        +
        11451 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
        +
        11452  m_pMetadata(VMA_NULL),
        +
        11453  m_MemoryTypeIndex(UINT32_MAX),
        +
        11454  m_Id(0),
        +
        11455  m_hMemory(VK_NULL_HANDLE),
        +
        11456  m_MapCount(0),
        +
        11457  m_pMappedData(VMA_NULL)
        +
        11458 {
        +
        11459 }
        +
        11460 
        +
        11461 void VmaDeviceMemoryBlock::Init(
        +
        11462  VmaAllocator hAllocator,
        +
        11463  VmaPool hParentPool,
        +
        11464  uint32_t newMemoryTypeIndex,
        +
        11465  VkDeviceMemory newMemory,
        +
        11466  VkDeviceSize newSize,
        +
        11467  uint32_t id,
        +
        11468  uint32_t algorithm)
        +
        11469 {
        +
        11470  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        +
        11471 
        +
        11472  m_hParentPool = hParentPool;
        +
        11473  m_MemoryTypeIndex = newMemoryTypeIndex;
        +
        11474  m_Id = id;
        +
        11475  m_hMemory = newMemory;
        11476 
        -
        11477 bool VmaDeviceMemoryBlock::Validate() const
        -
        11478 {
        -
        11479  VMA_VALIDATE((m_hMemory != VK_NULL_HANDLE) &&
        -
        11480  (m_pMetadata->GetSize() != 0));
        -
        11481 
        -
        11482  return m_pMetadata->Validate();
        -
        11483 }
        -
        11484 
        -
        11485 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
        -
        11486 {
        -
        11487  void* pData = nullptr;
        -
        11488  VkResult res = Map(hAllocator, 1, &pData);
        -
        11489  if(res != VK_SUCCESS)
        -
        11490  {
        -
        11491  return res;
        -
        11492  }
        +
        11477  switch(algorithm)
        +
        11478  {
        +
        11479  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
        +
        11480  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator);
        +
        11481  break;
        +
        11482  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
        +
        11483  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Buddy)(hAllocator);
        +
        11484  break;
        +
        11485  default:
        +
        11486  VMA_ASSERT(0);
        +
        11487  // Fall-through.
        +
        11488  case 0:
        +
        11489  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);
        +
        11490  }
        +
        11491  m_pMetadata->Init(newSize);
        +
        11492 }
        11493 
        -
        11494  res = m_pMetadata->CheckCorruption(pData);
        -
        11495 
        -
        11496  Unmap(hAllocator, 1);
        -
        11497 
        -
        11498  return res;
        -
        11499 }
        -
        11500 
        -
        11501 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
        -
        11502 {
        -
        11503  if(count == 0)
        -
        11504  {
        -
        11505  return VK_SUCCESS;
        -
        11506  }
        +
        11494 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
        +
        11495 {
        +
        11496  // This is the most important assert in the entire library.
        +
        11497  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
        +
        11498  VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
        +
        11499 
        +
        11500  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
        +
        11501  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
        +
        11502  m_hMemory = VK_NULL_HANDLE;
        +
        11503 
        +
        11504  vma_delete(allocator, m_pMetadata);
        +
        11505  m_pMetadata = VMA_NULL;
        +
        11506 }
        11507 
        -
        11508  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        -
        11509  if(m_MapCount != 0)
        -
        11510  {
        -
        11511  m_MapCount += count;
        -
        11512  VMA_ASSERT(m_pMappedData != VMA_NULL);
        -
        11513  if(ppData != VMA_NULL)
        -
        11514  {
        -
        11515  *ppData = m_pMappedData;
        -
        11516  }
        -
        11517  return VK_SUCCESS;
        -
        11518  }
        -
        11519  else
        -
        11520  {
        -
        11521  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        -
        11522  hAllocator->m_hDevice,
        -
        11523  m_hMemory,
        -
        11524  0, // offset
        -
        11525  VK_WHOLE_SIZE,
        -
        11526  0, // flags
        -
        11527  &m_pMappedData);
        -
        11528  if(result == VK_SUCCESS)
        -
        11529  {
        -
        11530  if(ppData != VMA_NULL)
        -
        11531  {
        -
        11532  *ppData = m_pMappedData;
        -
        11533  }
        -
        11534  m_MapCount = count;
        -
        11535  }
        -
        11536  return result;
        +
        11508 bool VmaDeviceMemoryBlock::Validate() const
        +
        11509 {
        +
        11510  VMA_VALIDATE((m_hMemory != VK_NULL_HANDLE) &&
        +
        11511  (m_pMetadata->GetSize() != 0));
        +
        11512 
        +
        11513  return m_pMetadata->Validate();
        +
        11514 }
        +
        11515 
        +
        11516 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
        +
        11517 {
        +
        11518  void* pData = nullptr;
        +
        11519  VkResult res = Map(hAllocator, 1, &pData);
        +
        11520  if(res != VK_SUCCESS)
        +
        11521  {
        +
        11522  return res;
        +
        11523  }
        +
        11524 
        +
        11525  res = m_pMetadata->CheckCorruption(pData);
        +
        11526 
        +
        11527  Unmap(hAllocator, 1);
        +
        11528 
        +
        11529  return res;
        +
        11530 }
        +
        11531 
        +
        11532 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
        +
        11533 {
        +
        11534  if(count == 0)
        +
        11535  {
        +
        11536  return VK_SUCCESS;
        11537  }
        -
        11538 }
        -
        11539 
        -
        11540 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
        -
        11541 {
        -
        11542  if(count == 0)
        -
        11543  {
        -
        11544  return;
        -
        11545  }
        -
        11546 
        -
        11547  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        -
        11548  if(m_MapCount >= count)
        -
        11549  {
        -
        11550  m_MapCount -= count;
        -
        11551  if(m_MapCount == 0)
        -
        11552  {
        -
        11553  m_pMappedData = VMA_NULL;
        -
        11554  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
        -
        11555  }
        -
        11556  }
        -
        11557  else
        -
        11558  {
        -
        11559  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
        -
        11560  }
        -
        11561 }
        -
        11562 
        -
        11563 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        -
        11564 {
        -
        11565  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        -
        11566  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        -
        11567 
        -
        11568  void* pData;
        -
        11569  VkResult res = Map(hAllocator, 1, &pData);
        -
        11570  if(res != VK_SUCCESS)
        -
        11571  {
        -
        11572  return res;
        -
        11573  }
        -
        11574 
        -
        11575  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
        -
        11576  VmaWriteMagicValue(pData, allocOffset + allocSize);
        +
        11538 
        +
        11539  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        +
        11540  if(m_MapCount != 0)
        +
        11541  {
        +
        11542  m_MapCount += count;
        +
        11543  VMA_ASSERT(m_pMappedData != VMA_NULL);
        +
        11544  if(ppData != VMA_NULL)
        +
        11545  {
        +
        11546  *ppData = m_pMappedData;
        +
        11547  }
        +
        11548  return VK_SUCCESS;
        +
        11549  }
        +
        11550  else
        +
        11551  {
        +
        11552  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        +
        11553  hAllocator->m_hDevice,
        +
        11554  m_hMemory,
        +
        11555  0, // offset
        +
        11556  VK_WHOLE_SIZE,
        +
        11557  0, // flags
        +
        11558  &m_pMappedData);
        +
        11559  if(result == VK_SUCCESS)
        +
        11560  {
        +
        11561  if(ppData != VMA_NULL)
        +
        11562  {
        +
        11563  *ppData = m_pMappedData;
        +
        11564  }
        +
        11565  m_MapCount = count;
        +
        11566  }
        +
        11567  return result;
        +
        11568  }
        +
        11569 }
        +
        11570 
        +
        11571 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
        +
        11572 {
        +
        11573  if(count == 0)
        +
        11574  {
        +
        11575  return;
        +
        11576  }
        11577 
        -
        11578  Unmap(hAllocator, 1);
        -
        11579 
        -
        11580  return VK_SUCCESS;
        -
        11581 }
        -
        11582 
        -
        11583 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        -
        11584 {
        -
        11585  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        -
        11586  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        -
        11587 
        -
        11588  void* pData;
        -
        11589  VkResult res = Map(hAllocator, 1, &pData);
        -
        11590  if(res != VK_SUCCESS)
        -
        11591  {
        -
        11592  return res;
        -
        11593  }
        -
        11594 
        -
        11595  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
        -
        11596  {
        -
        11597  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
        -
        11598  }
        -
        11599  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
        -
        11600  {
        -
        11601  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
        -
        11602  }
        -
        11603 
        -
        11604  Unmap(hAllocator, 1);
        +
        11578  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        +
        11579  if(m_MapCount >= count)
        +
        11580  {
        +
        11581  m_MapCount -= count;
        +
        11582  if(m_MapCount == 0)
        +
        11583  {
        +
        11584  m_pMappedData = VMA_NULL;
        +
        11585  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
        +
        11586  }
        +
        11587  }
        +
        11588  else
        +
        11589  {
        +
        11590  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
        +
        11591  }
        +
        11592 }
        +
        11593 
        +
        11594 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        +
        11595 {
        +
        11596  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        +
        11597  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        +
        11598 
        +
        11599  void* pData;
        +
        11600  VkResult res = Map(hAllocator, 1, &pData);
        +
        11601  if(res != VK_SUCCESS)
        +
        11602  {
        +
        11603  return res;
        +
        11604  }
        11605 
        -
        11606  return VK_SUCCESS;
        -
        11607 }
        +
        11606  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
        +
        11607  VmaWriteMagicValue(pData, allocOffset + allocSize);
        11608 
        -
        11609 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
        -
        11610  const VmaAllocator hAllocator,
        -
        11611  const VmaAllocation hAllocation,
        -
        11612  VkDeviceSize allocationLocalOffset,
        -
        11613  VkBuffer hBuffer,
        -
        11614  const void* pNext)
        +
        11609  Unmap(hAllocator, 1);
        +
        11610 
        +
        11611  return VK_SUCCESS;
        +
        11612 }
        +
        11613 
        +
        11614 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        11615 {
        -
        11616  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        -
        11617  hAllocation->GetBlock() == this);
        -
        11618  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
        -
        11619  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
        -
        11620  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
        -
        11621  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        -
        11622  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        -
        11623  return hAllocator->BindVulkanBuffer(m_hMemory, memoryOffset, hBuffer, pNext);
        -
        11624 }
        +
        11616  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        +
        11617  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        +
        11618 
        +
        11619  void* pData;
        +
        11620  VkResult res = Map(hAllocator, 1, &pData);
        +
        11621  if(res != VK_SUCCESS)
        +
        11622  {
        +
        11623  return res;
        +
        11624  }
        11625 
        -
        11626 VkResult VmaDeviceMemoryBlock::BindImageMemory(
        -
        11627  const VmaAllocator hAllocator,
        -
        11628  const VmaAllocation hAllocation,
        -
        11629  VkDeviceSize allocationLocalOffset,
        -
        11630  VkImage hImage,
        -
        11631  const void* pNext)
        -
        11632 {
        -
        11633  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        -
        11634  hAllocation->GetBlock() == this);
        -
        11635  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
        -
        11636  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
        -
        11637  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
        -
        11638  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        -
        11639  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        -
        11640  return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
        -
        11641 }
        -
        11642 
        -
        11643 static void InitStatInfo(VmaStatInfo& outInfo)
        -
        11644 {
        -
        11645  memset(&outInfo, 0, sizeof(outInfo));
        -
        11646  outInfo.allocationSizeMin = UINT64_MAX;
        -
        11647  outInfo.unusedRangeSizeMin = UINT64_MAX;
        -
        11648 }
        -
        11649 
        -
        11650 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
        -
        11651 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
        -
        11652 {
        -
        11653  inoutInfo.blockCount += srcInfo.blockCount;
        -
        11654  inoutInfo.allocationCount += srcInfo.allocationCount;
        -
        11655  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
        -
        11656  inoutInfo.usedBytes += srcInfo.usedBytes;
        -
        11657  inoutInfo.unusedBytes += srcInfo.unusedBytes;
        -
        11658  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
        -
        11659  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
        -
        11660  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
        -
        11661  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
        -
        11662 }
        -
        11663 
        -
        11664 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
        -
        11665 {
        -
        11666  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
        -
        11667  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
        -
        11668  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
        -
        11669  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
        -
        11670 }
        -
        11671 
        -
        11672 VmaPool_T::VmaPool_T(
        -
        11673  VmaAllocator hAllocator,
        -
        11674  const VmaPoolCreateInfo& createInfo,
        -
        11675  VkDeviceSize preferredBlockSize) :
        -
        11676  m_BlockVector(
        -
        11677  hAllocator,
        -
        11678  this, // hParentPool
        -
        11679  createInfo.memoryTypeIndex,
        -
        11680  createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
        -
        11681  createInfo.minBlockCount,
        -
        11682  createInfo.maxBlockCount,
        -
        11683  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
        -
        11684  createInfo.frameInUseCount,
        -
        11685  createInfo.blockSize != 0, // explicitBlockSize
        -
        11686  createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK), // algorithm
        -
        11687  m_Id(0),
        -
        11688  m_Name(VMA_NULL)
        -
        11689 {
        -
        11690 }
        -
        11691 
        -
        11692 VmaPool_T::~VmaPool_T()
        -
        11693 {
        -
        11694 }
        -
        11695 
        -
        11696 void VmaPool_T::SetName(const char* pName)
        -
        11697 {
        -
        11698  const VkAllocationCallbacks* allocs = m_BlockVector.GetAllocator()->GetAllocationCallbacks();
        -
        11699  VmaFreeString(allocs, m_Name);
        -
        11700 
        -
        11701  if(pName != VMA_NULL)
        -
        11702  {
        -
        11703  m_Name = VmaCreateStringCopy(allocs, pName);
        -
        11704  }
        -
        11705  else
        -
        11706  {
        -
        11707  m_Name = VMA_NULL;
        -
        11708  }
        -
        11709 }
        -
        11710 
        -
        11711 #if VMA_STATS_STRING_ENABLED
        -
        11712 
        -
        11713 #endif // #if VMA_STATS_STRING_ENABLED
        -
        11714 
        -
        11715 VmaBlockVector::VmaBlockVector(
        -
        11716  VmaAllocator hAllocator,
        -
        11717  VmaPool hParentPool,
        -
        11718  uint32_t memoryTypeIndex,
        -
        11719  VkDeviceSize preferredBlockSize,
        -
        11720  size_t minBlockCount,
        -
        11721  size_t maxBlockCount,
        -
        11722  VkDeviceSize bufferImageGranularity,
        -
        11723  uint32_t frameInUseCount,
        -
        11724  bool explicitBlockSize,
        -
        11725  uint32_t algorithm) :
        -
        11726  m_hAllocator(hAllocator),
        -
        11727  m_hParentPool(hParentPool),
        -
        11728  m_MemoryTypeIndex(memoryTypeIndex),
        -
        11729  m_PreferredBlockSize(preferredBlockSize),
        -
        11730  m_MinBlockCount(minBlockCount),
        -
        11731  m_MaxBlockCount(maxBlockCount),
        -
        11732  m_BufferImageGranularity(bufferImageGranularity),
        -
        11733  m_FrameInUseCount(frameInUseCount),
        -
        11734  m_ExplicitBlockSize(explicitBlockSize),
        -
        11735  m_Algorithm(algorithm),
        -
        11736  m_HasEmptyBlock(false),
        -
        11737  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
        -
        11738  m_NextBlockId(0)
        -
        11739 {
        +
        11626  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
        +
        11627  {
        +
        11628  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
        +
        11629  }
        +
        11630  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
        +
        11631  {
        +
        11632  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
        +
        11633  }
        +
        11634 
        +
        11635  Unmap(hAllocator, 1);
        +
        11636 
        +
        11637  return VK_SUCCESS;
        +
        11638 }
        +
        11639 
        +
        11640 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
        +
        11641  const VmaAllocator hAllocator,
        +
        11642  const VmaAllocation hAllocation,
        +
        11643  VkDeviceSize allocationLocalOffset,
        +
        11644  VkBuffer hBuffer,
        +
        11645  const void* pNext)
        +
        11646 {
        +
        11647  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        +
        11648  hAllocation->GetBlock() == this);
        +
        11649  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
        +
        11650  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
        +
        11651  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
        +
        11652  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        +
        11653  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        +
        11654  return hAllocator->BindVulkanBuffer(m_hMemory, memoryOffset, hBuffer, pNext);
        +
        11655 }
        +
        11656 
        +
        11657 VkResult VmaDeviceMemoryBlock::BindImageMemory(
        +
        11658  const VmaAllocator hAllocator,
        +
        11659  const VmaAllocation hAllocation,
        +
        11660  VkDeviceSize allocationLocalOffset,
        +
        11661  VkImage hImage,
        +
        11662  const void* pNext)
        +
        11663 {
        +
        11664  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        +
        11665  hAllocation->GetBlock() == this);
        +
        11666  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
        +
        11667  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
        +
        11668  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
        +
        11669  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        +
        11670  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        +
        11671  return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
        +
        11672 }
        +
        11673 
        +
        11674 static void InitStatInfo(VmaStatInfo& outInfo)
        +
        11675 {
        +
        11676  memset(&outInfo, 0, sizeof(outInfo));
        +
        11677  outInfo.allocationSizeMin = UINT64_MAX;
        +
        11678  outInfo.unusedRangeSizeMin = UINT64_MAX;
        +
        11679 }
        +
        11680 
        +
        11681 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
        +
        11682 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
        +
        11683 {
        +
        11684  inoutInfo.blockCount += srcInfo.blockCount;
        +
        11685  inoutInfo.allocationCount += srcInfo.allocationCount;
        +
        11686  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
        +
        11687  inoutInfo.usedBytes += srcInfo.usedBytes;
        +
        11688  inoutInfo.unusedBytes += srcInfo.unusedBytes;
        +
        11689  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
        +
        11690  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
        +
        11691  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
        +
        11692  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
        +
        11693 }
        +
        11694 
        +
        11695 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
        +
        11696 {
        +
        11697  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
        +
        11698  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
        +
        11699  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
        +
        11700  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
        +
        11701 }
        +
        11702 
        +
        11703 VmaPool_T::VmaPool_T(
        +
        11704  VmaAllocator hAllocator,
        +
        11705  const VmaPoolCreateInfo& createInfo,
        +
        11706  VkDeviceSize preferredBlockSize) :
        +
        11707  m_BlockVector(
        +
        11708  hAllocator,
        +
        11709  this, // hParentPool
        +
        11710  createInfo.memoryTypeIndex,
        +
        11711  createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
        +
        11712  createInfo.minBlockCount,
        +
        11713  createInfo.maxBlockCount,
        +
        11714  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
        +
        11715  createInfo.frameInUseCount,
        +
        11716  createInfo.blockSize != 0, // explicitBlockSize
        +
        11717  createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK), // algorithm
        +
        11718  m_Id(0),
        +
        11719  m_Name(VMA_NULL)
        +
        11720 {
        +
        11721 }
        +
        11722 
        +
        11723 VmaPool_T::~VmaPool_T()
        +
        11724 {
        +
        11725 }
        +
        11726 
        +
        11727 void VmaPool_T::SetName(const char* pName)
        +
        11728 {
        +
        11729  const VkAllocationCallbacks* allocs = m_BlockVector.GetAllocator()->GetAllocationCallbacks();
        +
        11730  VmaFreeString(allocs, m_Name);
        +
        11731 
        +
        11732  if(pName != VMA_NULL)
        +
        11733  {
        +
        11734  m_Name = VmaCreateStringCopy(allocs, pName);
        +
        11735  }
        +
        11736  else
        +
        11737  {
        +
        11738  m_Name = VMA_NULL;
        +
        11739  }
        11740 }
        11741 
        -
        11742 VmaBlockVector::~VmaBlockVector()
        -
        11743 {
        -
        11744  for(size_t i = m_Blocks.size(); i--; )
        -
        11745  {
        -
        11746  m_Blocks[i]->Destroy(m_hAllocator);
        -
        11747  vma_delete(m_hAllocator, m_Blocks[i]);
        -
        11748  }
        -
        11749 }
        -
        11750 
        -
        11751 VkResult VmaBlockVector::CreateMinBlocks()
        -
        11752 {
        -
        11753  for(size_t i = 0; i < m_MinBlockCount; ++i)
        -
        11754  {
        -
        11755  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
        -
        11756  if(res != VK_SUCCESS)
        -
        11757  {
        -
        11758  return res;
        -
        11759  }
        -
        11760  }
        -
        11761  return VK_SUCCESS;
        -
        11762 }
        -
        11763 
        -
        11764 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
        -
        11765 {
        -
        11766  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        -
        11767 
        -
        11768  const size_t blockCount = m_Blocks.size();
        -
        11769 
        -
        11770  pStats->size = 0;
        -
        11771  pStats->unusedSize = 0;
        -
        11772  pStats->allocationCount = 0;
        -
        11773  pStats->unusedRangeCount = 0;
        -
        11774  pStats->unusedRangeSizeMax = 0;
        -
        11775  pStats->blockCount = blockCount;
        -
        11776 
        -
        11777  for(uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        -
        11778  {
        -
        11779  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        -
        11780  VMA_ASSERT(pBlock);
        -
        11781  VMA_HEAVY_ASSERT(pBlock->Validate());
        -
        11782  pBlock->m_pMetadata->AddPoolStats(*pStats);
        -
        11783  }
        -
        11784 }
        -
        11785 
        -
        11786 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
        -
        11787 {
        -
        11788  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        -
        11789  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
        -
        11790  (VMA_DEBUG_MARGIN > 0) &&
        -
        11791  (m_Algorithm == 0 || m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) &&
        -
        11792  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
        +
        11742 #if VMA_STATS_STRING_ENABLED
        +
        11743 
        +
        11744 #endif // #if VMA_STATS_STRING_ENABLED
        +
        11745 
        +
        11746 VmaBlockVector::VmaBlockVector(
        +
        11747  VmaAllocator hAllocator,
        +
        11748  VmaPool hParentPool,
        +
        11749  uint32_t memoryTypeIndex,
        +
        11750  VkDeviceSize preferredBlockSize,
        +
        11751  size_t minBlockCount,
        +
        11752  size_t maxBlockCount,
        +
        11753  VkDeviceSize bufferImageGranularity,
        +
        11754  uint32_t frameInUseCount,
        +
        11755  bool explicitBlockSize,
        +
        11756  uint32_t algorithm) :
        +
        11757  m_hAllocator(hAllocator),
        +
        11758  m_hParentPool(hParentPool),
        +
        11759  m_MemoryTypeIndex(memoryTypeIndex),
        +
        11760  m_PreferredBlockSize(preferredBlockSize),
        +
        11761  m_MinBlockCount(minBlockCount),
        +
        11762  m_MaxBlockCount(maxBlockCount),
        +
        11763  m_BufferImageGranularity(bufferImageGranularity),
        +
        11764  m_FrameInUseCount(frameInUseCount),
        +
        11765  m_ExplicitBlockSize(explicitBlockSize),
        +
        11766  m_Algorithm(algorithm),
        +
        11767  m_HasEmptyBlock(false),
        +
        11768  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
        +
        11769  m_NextBlockId(0)
        +
        11770 {
        +
        11771 }
        +
        11772 
        +
        11773 VmaBlockVector::~VmaBlockVector()
        +
        11774 {
        +
        11775  for(size_t i = m_Blocks.size(); i--; )
        +
        11776  {
        +
        11777  m_Blocks[i]->Destroy(m_hAllocator);
        +
        11778  vma_delete(m_hAllocator, m_Blocks[i]);
        +
        11779  }
        +
        11780 }
        +
        11781 
        +
        11782 VkResult VmaBlockVector::CreateMinBlocks()
        +
        11783 {
        +
        11784  for(size_t i = 0; i < m_MinBlockCount; ++i)
        +
        11785  {
        +
        11786  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
        +
        11787  if(res != VK_SUCCESS)
        +
        11788  {
        +
        11789  return res;
        +
        11790  }
        +
        11791  }
        +
        11792  return VK_SUCCESS;
        11793 }
        11794 
        -
        11795 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
        -
        11796 
        -
        11797 VkResult VmaBlockVector::Allocate(
        -
        11798  uint32_t currentFrameIndex,
        -
        11799  VkDeviceSize size,
        -
        11800  VkDeviceSize alignment,
        -
        11801  const VmaAllocationCreateInfo& createInfo,
        -
        11802  VmaSuballocationType suballocType,
        -
        11803  size_t allocationCount,
        -
        11804  VmaAllocation* pAllocations)
        -
        11805 {
        -
        11806  size_t allocIndex;
        -
        11807  VkResult res = VK_SUCCESS;
        -
        11808 
        -
        11809  if(IsCorruptionDetectionEnabled())
        -
        11810  {
        -
        11811  size = VmaAlignUp<VkDeviceSize>(size, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
        -
        11812  alignment = VmaAlignUp<VkDeviceSize>(alignment, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
        -
        11813  }
        -
        11814 
        -
        11815  {
        -
        11816  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
        -
        11817  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        -
        11818  {
        -
        11819  res = AllocatePage(
        -
        11820  currentFrameIndex,
        -
        11821  size,
        -
        11822  alignment,
        -
        11823  createInfo,
        -
        11824  suballocType,
        -
        11825  pAllocations + allocIndex);
        -
        11826  if(res != VK_SUCCESS)
        -
        11827  {
        -
        11828  break;
        -
        11829  }
        -
        11830  }
        -
        11831  }
        -
        11832 
        -
        11833  if(res != VK_SUCCESS)
        -
        11834  {
        -
        11835  // Free all already created allocations.
        -
        11836  while(allocIndex--)
        -
        11837  {
        -
        11838  Free(pAllocations[allocIndex]);
        -
        11839  }
        -
        11840  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
        -
        11841  }
        -
        11842 
        -
        11843  return res;
        -
        11844 }
        +
        11795 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
        +
        11796 {
        +
        11797  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        +
        11798 
        +
        11799  const size_t blockCount = m_Blocks.size();
        +
        11800 
        +
        11801  pStats->size = 0;
        +
        11802  pStats->unusedSize = 0;
        +
        11803  pStats->allocationCount = 0;
        +
        11804  pStats->unusedRangeCount = 0;
        +
        11805  pStats->unusedRangeSizeMax = 0;
        +
        11806  pStats->blockCount = blockCount;
        +
        11807 
        +
        11808  for(uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        +
        11809  {
        +
        11810  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        +
        11811  VMA_ASSERT(pBlock);
        +
        11812  VMA_HEAVY_ASSERT(pBlock->Validate());
        +
        11813  pBlock->m_pMetadata->AddPoolStats(*pStats);
        +
        11814  }
        +
        11815 }
        +
        11816 
        +
        11817 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
        +
        11818 {
        +
        11819  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        +
        11820  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
        +
        11821  (VMA_DEBUG_MARGIN > 0) &&
        +
        11822  (m_Algorithm == 0 || m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) &&
        +
        11823  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
        +
        11824 }
        +
        11825 
        +
        11826 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
        +
        11827 
        +
        11828 VkResult VmaBlockVector::Allocate(
        +
        11829  uint32_t currentFrameIndex,
        +
        11830  VkDeviceSize size,
        +
        11831  VkDeviceSize alignment,
        +
        11832  const VmaAllocationCreateInfo& createInfo,
        +
        11833  VmaSuballocationType suballocType,
        +
        11834  size_t allocationCount,
        +
        11835  VmaAllocation* pAllocations)
        +
        11836 {
        +
        11837  size_t allocIndex;
        +
        11838  VkResult res = VK_SUCCESS;
        +
        11839 
        +
        11840  if(IsCorruptionDetectionEnabled())
        +
        11841  {
        +
        11842  size = VmaAlignUp<VkDeviceSize>(size, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
        +
        11843  alignment = VmaAlignUp<VkDeviceSize>(alignment, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
        +
        11844  }
        11845 
        -
        11846 VkResult VmaBlockVector::AllocatePage(
        -
        11847  uint32_t currentFrameIndex,
        -
        11848  VkDeviceSize size,
        -
        11849  VkDeviceSize alignment,
        -
        11850  const VmaAllocationCreateInfo& createInfo,
        -
        11851  VmaSuballocationType suballocType,
        -
        11852  VmaAllocation* pAllocation)
        -
        11853 {
        -
        11854  const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
        -
        11855  bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
        -
        11856  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        -
        11857  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
        -
        11858 
        -
        11859  const bool withinBudget = (createInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0;
        -
        11860  VkDeviceSize freeMemory;
        -
        11861  {
        -
        11862  const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
        -
        11863  VmaBudget heapBudget = {};
        -
        11864  m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
        -
        11865  freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;
        -
        11866  }
        -
        11867 
        -
        11868  const bool canFallbackToDedicated = !IsCustomPool();
        -
        11869  const bool canCreateNewBlock =
        -
        11870  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
        -
        11871  (m_Blocks.size() < m_MaxBlockCount) &&
        -
        11872  (freeMemory >= size || !canFallbackToDedicated);
        -
        11873  uint32_t strategy = createInfo.flags & VMA_ALLOCATION_CREATE_STRATEGY_MASK;
        -
        11874 
        -
        11875  // If linearAlgorithm is used, canMakeOtherLost is available only when used as ring buffer.
        -
        11876  // Which in turn is available only when maxBlockCount = 1.
        -
        11877  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT && m_MaxBlockCount > 1)
        -
        11878  {
        -
        11879  canMakeOtherLost = false;
        -
        11880  }
        -
        11881 
        -
        11882  // Upper address can only be used with linear allocator and within single memory block.
        -
        11883  if(isUpperAddress &&
        -
        11884  (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT || m_MaxBlockCount > 1))
        -
        11885  {
        -
        11886  return VK_ERROR_FEATURE_NOT_PRESENT;
        -
        11887  }
        -
        11888 
        -
        11889  // Validate strategy.
        -
        11890  switch(strategy)
        -
        11891  {
        -
        11892  case 0:
        -
        11893  strategy = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT;
        -
        11894  break;
        -
        11895  case VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT:
        -
        11896  case VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT:
        -
        11897  case VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT:
        -
        11898  break;
        -
        11899  default:
        -
        11900  return VK_ERROR_FEATURE_NOT_PRESENT;
        -
        11901  }
        -
        11902 
        -
        11903  // Early reject: requested allocation size is larger that maximum block size for this block vector.
        -
        11904  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
        -
        11905  {
        -
        11906  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        11907  }
        -
        11908 
        -
        11909  /*
        -
        11910  Under certain condition, this whole section can be skipped for optimization, so
        -
        11911  we move on directly to trying to allocate with canMakeOtherLost. That's the case
        -
        11912  e.g. for custom pools with linear algorithm.
        -
        11913  */
        -
        11914  if(!canMakeOtherLost || canCreateNewBlock)
        -
        11915  {
        -
        11916  // 1. Search existing allocations. Try to allocate without making other allocations lost.
        -
        11917  VmaAllocationCreateFlags allocFlagsCopy = createInfo.flags;
        -
        11918  allocFlagsCopy &= ~VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
        +
        11846  {
        +
        11847  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
        +
        11848  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        +
        11849  {
        +
        11850  res = AllocatePage(
        +
        11851  currentFrameIndex,
        +
        11852  size,
        +
        11853  alignment,
        +
        11854  createInfo,
        +
        11855  suballocType,
        +
        11856  pAllocations + allocIndex);
        +
        11857  if(res != VK_SUCCESS)
        +
        11858  {
        +
        11859  break;
        +
        11860  }
        +
        11861  }
        +
        11862  }
        +
        11863 
        +
        11864  if(res != VK_SUCCESS)
        +
        11865  {
        +
        11866  // Free all already created allocations.
        +
        11867  while(allocIndex--)
        +
        11868  {
        +
        11869  Free(pAllocations[allocIndex]);
        +
        11870  }
        +
        11871  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
        +
        11872  }
        +
        11873 
        +
        11874  return res;
        +
        11875 }
        +
        11876 
        +
        11877 VkResult VmaBlockVector::AllocatePage(
        +
        11878  uint32_t currentFrameIndex,
        +
        11879  VkDeviceSize size,
        +
        11880  VkDeviceSize alignment,
        +
        11881  const VmaAllocationCreateInfo& createInfo,
        +
        11882  VmaSuballocationType suballocType,
        +
        11883  VmaAllocation* pAllocation)
        +
        11884 {
        +
        11885  const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
        +
        11886  bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
        +
        11887  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        +
        11888  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
        +
        11889 
        +
        11890  const bool withinBudget = (createInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0;
        +
        11891  VkDeviceSize freeMemory;
        +
        11892  {
        +
        11893  const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
        +
        11894  VmaBudget heapBudget = {};
        +
        11895  m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
        +
        11896  freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;
        +
        11897  }
        +
        11898 
        +
        11899  const bool canFallbackToDedicated = !IsCustomPool();
        +
        11900  const bool canCreateNewBlock =
        +
        11901  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
        +
        11902  (m_Blocks.size() < m_MaxBlockCount) &&
        +
        11903  (freeMemory >= size || !canFallbackToDedicated);
        +
        11904  uint32_t strategy = createInfo.flags & VMA_ALLOCATION_CREATE_STRATEGY_MASK;
        +
        11905 
        +
        11906  // If linearAlgorithm is used, canMakeOtherLost is available only when used as ring buffer.
        +
        11907  // Which in turn is available only when maxBlockCount = 1.
        +
        11908  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT && m_MaxBlockCount > 1)
        +
        11909  {
        +
        11910  canMakeOtherLost = false;
        +
        11911  }
        +
        11912 
        +
        11913  // Upper address can only be used with linear allocator and within single memory block.
        +
        11914  if(isUpperAddress &&
        +
        11915  (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT || m_MaxBlockCount > 1))
        +
        11916  {
        +
        11917  return VK_ERROR_FEATURE_NOT_PRESENT;
        +
        11918  }
        11919 
        -
        11920  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
        -
        11921  {
        -
        11922  // Use only last block.
        -
        11923  if(!m_Blocks.empty())
        -
        11924  {
        -
        11925  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
        -
        11926  VMA_ASSERT(pCurrBlock);
        -
        11927  VkResult res = AllocateFromBlock(
        -
        11928  pCurrBlock,
        -
        11929  currentFrameIndex,
        -
        11930  size,
        -
        11931  alignment,
        -
        11932  allocFlagsCopy,
        -
        11933  createInfo.pUserData,
        -
        11934  suballocType,
        -
        11935  strategy,
        -
        11936  pAllocation);
        -
        11937  if(res == VK_SUCCESS)
        -
        11938  {
        -
        11939  VMA_DEBUG_LOG(" Returned from last block #%u", pCurrBlock->GetId());
        -
        11940  return VK_SUCCESS;
        -
        11941  }
        -
        11942  }
        -
        11943  }
        -
        11944  else
        -
        11945  {
        -
        11946  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
        -
        11947  {
        -
        11948  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        -
        11949  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        -
        11950  {
        -
        11951  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        -
        11952  VMA_ASSERT(pCurrBlock);
        -
        11953  VkResult res = AllocateFromBlock(
        -
        11954  pCurrBlock,
        -
        11955  currentFrameIndex,
        -
        11956  size,
        -
        11957  alignment,
        -
        11958  allocFlagsCopy,
        -
        11959  createInfo.pUserData,
        -
        11960  suballocType,
        -
        11961  strategy,
        -
        11962  pAllocation);
        -
        11963  if(res == VK_SUCCESS)
        -
        11964  {
        -
        11965  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
        -
        11966  return VK_SUCCESS;
        -
        11967  }
        -
        11968  }
        -
        11969  }
        -
        11970  else // WORST_FIT, FIRST_FIT
        -
        11971  {
        -
        11972  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
        -
        11973  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        -
        11974  {
        -
        11975  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        -
        11976  VMA_ASSERT(pCurrBlock);
        -
        11977  VkResult res = AllocateFromBlock(
        -
        11978  pCurrBlock,
        -
        11979  currentFrameIndex,
        -
        11980  size,
        -
        11981  alignment,
        -
        11982  allocFlagsCopy,
        -
        11983  createInfo.pUserData,
        -
        11984  suballocType,
        -
        11985  strategy,
        -
        11986  pAllocation);
        -
        11987  if(res == VK_SUCCESS)
        -
        11988  {
        -
        11989  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
        -
        11990  return VK_SUCCESS;
        -
        11991  }
        -
        11992  }
        -
        11993  }
        -
        11994  }
        -
        11995 
        -
        11996  // 2. Try to create new block.
        -
        11997  if(canCreateNewBlock)
        -
        11998  {
        -
        11999  // Calculate optimal size for new block.
        -
        12000  VkDeviceSize newBlockSize = m_PreferredBlockSize;
        -
        12001  uint32_t newBlockSizeShift = 0;
        -
        12002  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
        -
        12003 
        -
        12004  if(!m_ExplicitBlockSize)
        -
        12005  {
        -
        12006  // Allocate 1/8, 1/4, 1/2 as first blocks.
        -
        12007  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
        -
        12008  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
        -
        12009  {
        -
        12010  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        -
        12011  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
        -
        12012  {
        -
        12013  newBlockSize = smallerNewBlockSize;
        -
        12014  ++newBlockSizeShift;
        -
        12015  }
        -
        12016  else
        -
        12017  {
        -
        12018  break;
        -
        12019  }
        -
        12020  }
        -
        12021  }
        -
        12022 
        -
        12023  size_t newBlockIndex = 0;
        -
        12024  VkResult res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
        -
        12025  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        12026  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
        -
        12027  if(!m_ExplicitBlockSize)
        -
        12028  {
        -
        12029  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
        -
        12030  {
        -
        12031  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        -
        12032  if(smallerNewBlockSize >= size)
        -
        12033  {
        -
        12034  newBlockSize = smallerNewBlockSize;
        -
        12035  ++newBlockSizeShift;
        -
        12036  res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
        -
        12037  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        12038  }
        -
        12039  else
        -
        12040  {
        -
        12041  break;
        -
        12042  }
        -
        12043  }
        -
        12044  }
        -
        12045 
        -
        12046  if(res == VK_SUCCESS)
        -
        12047  {
        -
        12048  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
        -
        12049  VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
        -
        12050 
        -
        12051  res = AllocateFromBlock(
        -
        12052  pBlock,
        -
        12053  currentFrameIndex,
        -
        12054  size,
        -
        12055  alignment,
        -
        12056  allocFlagsCopy,
        -
        12057  createInfo.pUserData,
        -
        12058  suballocType,
        -
        12059  strategy,
        -
        12060  pAllocation);
        -
        12061  if(res == VK_SUCCESS)
        -
        12062  {
        -
        12063  VMA_DEBUG_LOG(" Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
        -
        12064  return VK_SUCCESS;
        -
        12065  }
        -
        12066  else
        -
        12067  {
        -
        12068  // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
        -
        12069  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        12070  }
        -
        12071  }
        -
        12072  }
        -
        12073  }
        -
        12074 
        -
        12075  // 3. Try to allocate from existing blocks with making other allocations lost.
        -
        12076  if(canMakeOtherLost)
        -
        12077  {
        -
        12078  uint32_t tryIndex = 0;
        -
        12079  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
        -
        12080  {
        -
        12081  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
        -
        12082  VmaAllocationRequest bestRequest = {};
        -
        12083  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
        -
        12084 
        -
        12085  // 1. Search existing allocations.
        -
        12086  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
        -
        12087  {
        -
        12088  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        -
        12089  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        -
        12090  {
        -
        12091  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        -
        12092  VMA_ASSERT(pCurrBlock);
        -
        12093  VmaAllocationRequest currRequest = {};
        -
        12094  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
        -
        12095  currentFrameIndex,
        -
        12096  m_FrameInUseCount,
        -
        12097  m_BufferImageGranularity,
        -
        12098  size,
        -
        12099  alignment,
        -
        12100  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
        -
        12101  suballocType,
        -
        12102  canMakeOtherLost,
        -
        12103  strategy,
        -
        12104  &currRequest))
        -
        12105  {
        -
        12106  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        -
        12107  if(pBestRequestBlock == VMA_NULL ||
        -
        12108  currRequestCost < bestRequestCost)
        -
        12109  {
        -
        12110  pBestRequestBlock = pCurrBlock;
        -
        12111  bestRequest = currRequest;
        -
        12112  bestRequestCost = currRequestCost;
        -
        12113 
        -
        12114  if(bestRequestCost == 0)
        -
        12115  {
        -
        12116  break;
        -
        12117  }
        -
        12118  }
        -
        12119  }
        -
        12120  }
        -
        12121  }
        -
        12122  else // WORST_FIT, FIRST_FIT
        -
        12123  {
        -
        12124  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
        -
        12125  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        -
        12126  {
        -
        12127  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        -
        12128  VMA_ASSERT(pCurrBlock);
        -
        12129  VmaAllocationRequest currRequest = {};
        -
        12130  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
        -
        12131  currentFrameIndex,
        -
        12132  m_FrameInUseCount,
        -
        12133  m_BufferImageGranularity,
        -
        12134  size,
        -
        12135  alignment,
        -
        12136  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
        -
        12137  suballocType,
        -
        12138  canMakeOtherLost,
        -
        12139  strategy,
        -
        12140  &currRequest))
        -
        12141  {
        -
        12142  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        -
        12143  if(pBestRequestBlock == VMA_NULL ||
        -
        12144  currRequestCost < bestRequestCost ||
        -
        12145  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
        -
        12146  {
        -
        12147  pBestRequestBlock = pCurrBlock;
        -
        12148  bestRequest = currRequest;
        -
        12149  bestRequestCost = currRequestCost;
        -
        12150 
        -
        12151  if(bestRequestCost == 0 ||
        -
        12152  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
        -
        12153  {
        -
        12154  break;
        -
        12155  }
        -
        12156  }
        -
        12157  }
        -
        12158  }
        -
        12159  }
        -
        12160 
        -
        12161  if(pBestRequestBlock != VMA_NULL)
        -
        12162  {
        -
        12163  if(mapped)
        -
        12164  {
        -
        12165  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
        -
        12166  if(res != VK_SUCCESS)
        -
        12167  {
        -
        12168  return res;
        -
        12169  }
        -
        12170  }
        -
        12171 
        -
        12172  if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(
        -
        12173  currentFrameIndex,
        -
        12174  m_FrameInUseCount,
        -
        12175  &bestRequest))
        -
        12176  {
        -
        12177  // We no longer have an empty Allocation.
        -
        12178  if(pBestRequestBlock->m_pMetadata->IsEmpty())
        -
        12179  {
        -
        12180  m_HasEmptyBlock = false;
        -
        12181  }
        -
        12182  // Allocate from this pBlock.
        -
        12183  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
        -
        12184  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
        -
        12185  pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, *pAllocation);
        -
        12186  (*pAllocation)->InitBlockAllocation(
        -
        12187  pBestRequestBlock,
        -
        12188  bestRequest.offset,
        -
        12189  alignment,
        -
        12190  size,
        -
        12191  m_MemoryTypeIndex,
        -
        12192  suballocType,
        -
        12193  mapped,
        -
        12194  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        -
        12195  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
        -
        12196  VMA_DEBUG_LOG(" Returned from existing block");
        -
        12197  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
        -
        12198  m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
        -
        12199  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        -
        12200  {
        -
        12201  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        -
        12202  }
        -
        12203  if(IsCorruptionDetectionEnabled())
        -
        12204  {
        -
        12205  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
        -
        12206  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        -
        12207  }
        -
        12208  return VK_SUCCESS;
        -
        12209  }
        -
        12210  // else: Some allocations must have been touched while we are here. Next try.
        -
        12211  }
        -
        12212  else
        -
        12213  {
        -
        12214  // Could not find place in any of the blocks - break outer loop.
        -
        12215  break;
        -
        12216  }
        -
        12217  }
        -
        12218  /* Maximum number of tries exceeded - a very unlike event when many other
        -
        12219  threads are simultaneously touching allocations making it impossible to make
        -
        12220  lost at the same time as we try to allocate. */
        -
        12221  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
        -
        12222  {
        -
        12223  return VK_ERROR_TOO_MANY_OBJECTS;
        -
        12224  }
        -
        12225  }
        -
        12226 
        -
        12227  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        12228 }
        -
        12229 
        -
        12230 void VmaBlockVector::Free(
        -
        12231  const VmaAllocation hAllocation)
        -
        12232 {
        -
        12233  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
        -
        12234 
        -
        12235  bool budgetExceeded = false;
        -
        12236  {
        -
        12237  const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
        -
        12238  VmaBudget heapBudget = {};
        -
        12239  m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
        -
        12240  budgetExceeded = heapBudget.usage >= heapBudget.budget;
        -
        12241  }
        -
        12242 
        -
        12243  // Scope for lock.
        -
        12244  {
        -
        12245  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
        -
        12246 
        -
        12247  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        -
        12248 
        -
        12249  if(IsCorruptionDetectionEnabled())
        -
        12250  {
        -
        12251  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
        -
        12252  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
        -
        12253  }
        -
        12254 
        -
        12255  if(hAllocation->IsPersistentMap())
        -
        12256  {
        -
        12257  pBlock->Unmap(m_hAllocator, 1);
        -
        12258  }
        -
        12259 
        -
        12260  pBlock->m_pMetadata->Free(hAllocation);
        -
        12261  VMA_HEAVY_ASSERT(pBlock->Validate());
        -
        12262 
        -
        12263  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
        -
        12264 
        -
        12265  const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
        -
        12266  // pBlock became empty after this deallocation.
        -
        12267  if(pBlock->m_pMetadata->IsEmpty())
        -
        12268  {
        -
        12269  // Already has empty block. We don't want to have two, so delete this one.
        -
        12270  if((m_HasEmptyBlock || budgetExceeded) && canDeleteBlock)
        -
        12271  {
        -
        12272  pBlockToDelete = pBlock;
        -
        12273  Remove(pBlock);
        -
        12274  }
        -
        12275  // We now have first empty block.
        -
        12276  else
        -
        12277  {
        -
        12278  m_HasEmptyBlock = true;
        -
        12279  }
        +
        11920  // Validate strategy.
        +
        11921  switch(strategy)
        +
        11922  {
        +
        11923  case 0:
        +
        11924  strategy = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT;
        +
        11925  break;
        +
        11926  case VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT:
        +
        11927  case VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT:
        +
        11928  case VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT:
        +
        11929  break;
        +
        11930  default:
        +
        11931  return VK_ERROR_FEATURE_NOT_PRESENT;
        +
        11932  }
        +
        11933 
        +
        11934  // Early reject: requested allocation size is larger that maximum block size for this block vector.
        +
        11935  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
        +
        11936  {
        +
        11937  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        11938  }
        +
        11939 
        +
        11940  /*
        +
        11941  Under certain condition, this whole section can be skipped for optimization, so
        +
        11942  we move on directly to trying to allocate with canMakeOtherLost. That's the case
        +
        11943  e.g. for custom pools with linear algorithm.
        +
        11944  */
        +
        11945  if(!canMakeOtherLost || canCreateNewBlock)
        +
        11946  {
        +
        11947  // 1. Search existing allocations. Try to allocate without making other allocations lost.
        +
        11948  VmaAllocationCreateFlags allocFlagsCopy = createInfo.flags;
        +
        11949  allocFlagsCopy &= ~VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
        +
        11950 
        +
        11951  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
        +
        11952  {
        +
        11953  // Use only last block.
        +
        11954  if(!m_Blocks.empty())
        +
        11955  {
        +
        11956  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
        +
        11957  VMA_ASSERT(pCurrBlock);
        +
        11958  VkResult res = AllocateFromBlock(
        +
        11959  pCurrBlock,
        +
        11960  currentFrameIndex,
        +
        11961  size,
        +
        11962  alignment,
        +
        11963  allocFlagsCopy,
        +
        11964  createInfo.pUserData,
        +
        11965  suballocType,
        +
        11966  strategy,
        +
        11967  pAllocation);
        +
        11968  if(res == VK_SUCCESS)
        +
        11969  {
        +
        11970  VMA_DEBUG_LOG(" Returned from last block #%u", pCurrBlock->GetId());
        +
        11971  return VK_SUCCESS;
        +
        11972  }
        +
        11973  }
        +
        11974  }
        +
        11975  else
        +
        11976  {
        +
        11977  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
        +
        11978  {
        +
        11979  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        +
        11980  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        +
        11981  {
        +
        11982  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        +
        11983  VMA_ASSERT(pCurrBlock);
        +
        11984  VkResult res = AllocateFromBlock(
        +
        11985  pCurrBlock,
        +
        11986  currentFrameIndex,
        +
        11987  size,
        +
        11988  alignment,
        +
        11989  allocFlagsCopy,
        +
        11990  createInfo.pUserData,
        +
        11991  suballocType,
        +
        11992  strategy,
        +
        11993  pAllocation);
        +
        11994  if(res == VK_SUCCESS)
        +
        11995  {
        +
        11996  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
        +
        11997  return VK_SUCCESS;
        +
        11998  }
        +
        11999  }
        +
        12000  }
        +
        12001  else // WORST_FIT, FIRST_FIT
        +
        12002  {
        +
        12003  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
        +
        12004  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        +
        12005  {
        +
        12006  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        +
        12007  VMA_ASSERT(pCurrBlock);
        +
        12008  VkResult res = AllocateFromBlock(
        +
        12009  pCurrBlock,
        +
        12010  currentFrameIndex,
        +
        12011  size,
        +
        12012  alignment,
        +
        12013  allocFlagsCopy,
        +
        12014  createInfo.pUserData,
        +
        12015  suballocType,
        +
        12016  strategy,
        +
        12017  pAllocation);
        +
        12018  if(res == VK_SUCCESS)
        +
        12019  {
        +
        12020  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
        +
        12021  return VK_SUCCESS;
        +
        12022  }
        +
        12023  }
        +
        12024  }
        +
        12025  }
        +
        12026 
        +
        12027  // 2. Try to create new block.
        +
        12028  if(canCreateNewBlock)
        +
        12029  {
        +
        12030  // Calculate optimal size for new block.
        +
        12031  VkDeviceSize newBlockSize = m_PreferredBlockSize;
        +
        12032  uint32_t newBlockSizeShift = 0;
        +
        12033  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
        +
        12034 
        +
        12035  if(!m_ExplicitBlockSize)
        +
        12036  {
        +
        12037  // Allocate 1/8, 1/4, 1/2 as first blocks.
        +
        12038  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
        +
        12039  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
        +
        12040  {
        +
        12041  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        +
        12042  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
        +
        12043  {
        +
        12044  newBlockSize = smallerNewBlockSize;
        +
        12045  ++newBlockSizeShift;
        +
        12046  }
        +
        12047  else
        +
        12048  {
        +
        12049  break;
        +
        12050  }
        +
        12051  }
        +
        12052  }
        +
        12053 
        +
        12054  size_t newBlockIndex = 0;
        +
        12055  VkResult res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
        +
        12056  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        12057  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
        +
        12058  if(!m_ExplicitBlockSize)
        +
        12059  {
        +
        12060  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
        +
        12061  {
        +
        12062  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        +
        12063  if(smallerNewBlockSize >= size)
        +
        12064  {
        +
        12065  newBlockSize = smallerNewBlockSize;
        +
        12066  ++newBlockSizeShift;
        +
        12067  res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
        +
        12068  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        12069  }
        +
        12070  else
        +
        12071  {
        +
        12072  break;
        +
        12073  }
        +
        12074  }
        +
        12075  }
        +
        12076 
        +
        12077  if(res == VK_SUCCESS)
        +
        12078  {
        +
        12079  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
        +
        12080  VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
        +
        12081 
        +
        12082  res = AllocateFromBlock(
        +
        12083  pBlock,
        +
        12084  currentFrameIndex,
        +
        12085  size,
        +
        12086  alignment,
        +
        12087  allocFlagsCopy,
        +
        12088  createInfo.pUserData,
        +
        12089  suballocType,
        +
        12090  strategy,
        +
        12091  pAllocation);
        +
        12092  if(res == VK_SUCCESS)
        +
        12093  {
        +
        12094  VMA_DEBUG_LOG(" Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
        +
        12095  return VK_SUCCESS;
        +
        12096  }
        +
        12097  else
        +
        12098  {
        +
        12099  // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
        +
        12100  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        12101  }
        +
        12102  }
        +
        12103  }
        +
        12104  }
        +
        12105 
        +
        12106  // 3. Try to allocate from existing blocks with making other allocations lost.
        +
        12107  if(canMakeOtherLost)
        +
        12108  {
        +
        12109  uint32_t tryIndex = 0;
        +
        12110  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
        +
        12111  {
        +
        12112  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
        +
        12113  VmaAllocationRequest bestRequest = {};
        +
        12114  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
        +
        12115 
        +
        12116  // 1. Search existing allocations.
        +
        12117  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
        +
        12118  {
        +
        12119  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        +
        12120  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        +
        12121  {
        +
        12122  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        +
        12123  VMA_ASSERT(pCurrBlock);
        +
        12124  VmaAllocationRequest currRequest = {};
        +
        12125  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
        +
        12126  currentFrameIndex,
        +
        12127  m_FrameInUseCount,
        +
        12128  m_BufferImageGranularity,
        +
        12129  size,
        +
        12130  alignment,
        +
        12131  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
        +
        12132  suballocType,
        +
        12133  canMakeOtherLost,
        +
        12134  strategy,
        +
        12135  &currRequest))
        +
        12136  {
        +
        12137  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        +
        12138  if(pBestRequestBlock == VMA_NULL ||
        +
        12139  currRequestCost < bestRequestCost)
        +
        12140  {
        +
        12141  pBestRequestBlock = pCurrBlock;
        +
        12142  bestRequest = currRequest;
        +
        12143  bestRequestCost = currRequestCost;
        +
        12144 
        +
        12145  if(bestRequestCost == 0)
        +
        12146  {
        +
        12147  break;
        +
        12148  }
        +
        12149  }
        +
        12150  }
        +
        12151  }
        +
        12152  }
        +
        12153  else // WORST_FIT, FIRST_FIT
        +
        12154  {
        +
        12155  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
        +
        12156  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        +
        12157  {
        +
        12158  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        +
        12159  VMA_ASSERT(pCurrBlock);
        +
        12160  VmaAllocationRequest currRequest = {};
        +
        12161  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
        +
        12162  currentFrameIndex,
        +
        12163  m_FrameInUseCount,
        +
        12164  m_BufferImageGranularity,
        +
        12165  size,
        +
        12166  alignment,
        +
        12167  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
        +
        12168  suballocType,
        +
        12169  canMakeOtherLost,
        +
        12170  strategy,
        +
        12171  &currRequest))
        +
        12172  {
        +
        12173  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        +
        12174  if(pBestRequestBlock == VMA_NULL ||
        +
        12175  currRequestCost < bestRequestCost ||
        +
        12176  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
        +
        12177  {
        +
        12178  pBestRequestBlock = pCurrBlock;
        +
        12179  bestRequest = currRequest;
        +
        12180  bestRequestCost = currRequestCost;
        +
        12181 
        +
        12182  if(bestRequestCost == 0 ||
        +
        12183  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
        +
        12184  {
        +
        12185  break;
        +
        12186  }
        +
        12187  }
        +
        12188  }
        +
        12189  }
        +
        12190  }
        +
        12191 
        +
        12192  if(pBestRequestBlock != VMA_NULL)
        +
        12193  {
        +
        12194  if(mapped)
        +
        12195  {
        +
        12196  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
        +
        12197  if(res != VK_SUCCESS)
        +
        12198  {
        +
        12199  return res;
        +
        12200  }
        +
        12201  }
        +
        12202 
        +
        12203  if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(
        +
        12204  currentFrameIndex,
        +
        12205  m_FrameInUseCount,
        +
        12206  &bestRequest))
        +
        12207  {
        +
        12208  // Allocate from this pBlock.
        +
        12209  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
        +
        12210  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
        +
        12211  pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, *pAllocation);
        +
        12212  UpdateHasEmptyBlock();
        +
        12213  (*pAllocation)->InitBlockAllocation(
        +
        12214  pBestRequestBlock,
        +
        12215  bestRequest.offset,
        +
        12216  alignment,
        +
        12217  size,
        +
        12218  m_MemoryTypeIndex,
        +
        12219  suballocType,
        +
        12220  mapped,
        +
        12221  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        +
        12222  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
        +
        12223  VMA_DEBUG_LOG(" Returned from existing block");
        +
        12224  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
        +
        12225  m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
        +
        12226  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        +
        12227  {
        +
        12228  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        +
        12229  }
        +
        12230  if(IsCorruptionDetectionEnabled())
        +
        12231  {
        +
        12232  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
        +
        12233  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        +
        12234  }
        +
        12235  return VK_SUCCESS;
        +
        12236  }
        +
        12237  // else: Some allocations must have been touched while we are here. Next try.
        +
        12238  }
        +
        12239  else
        +
        12240  {
        +
        12241  // Could not find place in any of the blocks - break outer loop.
        +
        12242  break;
        +
        12243  }
        +
        12244  }
        +
        12245  /* Maximum number of tries exceeded - a very unlike event when many other
        +
        12246  threads are simultaneously touching allocations making it impossible to make
        +
        12247  lost at the same time as we try to allocate. */
        +
        12248  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
        +
        12249  {
        +
        12250  return VK_ERROR_TOO_MANY_OBJECTS;
        +
        12251  }
        +
        12252  }
        +
        12253 
        +
        12254  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        12255 }
        +
        12256 
        +
        12257 void VmaBlockVector::Free(
        +
        12258  const VmaAllocation hAllocation)
        +
        12259 {
        +
        12260  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
        +
        12261 
        +
        12262  bool budgetExceeded = false;
        +
        12263  {
        +
        12264  const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
        +
        12265  VmaBudget heapBudget = {};
        +
        12266  m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
        +
        12267  budgetExceeded = heapBudget.usage >= heapBudget.budget;
        +
        12268  }
        +
        12269 
        +
        12270  // Scope for lock.
        +
        12271  {
        +
        12272  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
        +
        12273 
        +
        12274  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        +
        12275 
        +
        12276  if(IsCorruptionDetectionEnabled())
        +
        12277  {
        +
        12278  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
        +
        12279  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
        12280  }
        -
        12281  // pBlock didn't become empty, but we have another empty block - find and free that one.
        -
        12282  // (This is optional, heuristics.)
        -
        12283  else if(m_HasEmptyBlock && canDeleteBlock)
        -
        12284  {
        -
        12285  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
        -
        12286  if(pLastBlock->m_pMetadata->IsEmpty())
        -
        12287  {
        -
        12288  pBlockToDelete = pLastBlock;
        -
        12289  m_Blocks.pop_back();
        -
        12290  m_HasEmptyBlock = false;
        -
        12291  }
        -
        12292  }
        -
        12293 
        -
        12294  IncrementallySortBlocks();
        -
        12295  }
        -
        12296 
        -
        12297  // Destruction of a free block. Deferred until this point, outside of mutex
        -
        12298  // lock, for performance reason.
        -
        12299  if(pBlockToDelete != VMA_NULL)
        -
        12300  {
        -
        12301  VMA_DEBUG_LOG(" Deleted empty block");
        -
        12302  pBlockToDelete->Destroy(m_hAllocator);
        -
        12303  vma_delete(m_hAllocator, pBlockToDelete);
        -
        12304  }
        -
        12305 }
        -
        12306 
        -
        12307 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
        -
        12308 {
        -
        12309  VkDeviceSize result = 0;
        -
        12310  for(size_t i = m_Blocks.size(); i--; )
        -
        12311  {
        -
        12312  result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
        -
        12313  if(result >= m_PreferredBlockSize)
        -
        12314  {
        -
        12315  break;
        -
        12316  }
        -
        12317  }
        -
        12318  return result;
        -
        12319 }
        -
        12320 
        -
        12321 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
        -
        12322 {
        -
        12323  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        -
        12324  {
        -
        12325  if(m_Blocks[blockIndex] == pBlock)
        -
        12326  {
        -
        12327  VmaVectorRemove(m_Blocks, blockIndex);
        -
        12328  return;
        -
        12329  }
        -
        12330  }
        -
        12331  VMA_ASSERT(0);
        -
        12332 }
        -
        12333 
        -
        12334 void VmaBlockVector::IncrementallySortBlocks()
        -
        12335 {
        -
        12336  if(m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
        -
        12337  {
        -
        12338  // Bubble sort only until first swap.
        -
        12339  for(size_t i = 1; i < m_Blocks.size(); ++i)
        -
        12340  {
        -
        12341  if(m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
        -
        12342  {
        -
        12343  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
        -
        12344  return;
        -
        12345  }
        -
        12346  }
        -
        12347  }
        -
        12348 }
        -
        12349 
        -
        12350 VkResult VmaBlockVector::AllocateFromBlock(
        -
        12351  VmaDeviceMemoryBlock* pBlock,
        -
        12352  uint32_t currentFrameIndex,
        -
        12353  VkDeviceSize size,
        -
        12354  VkDeviceSize alignment,
        -
        12355  VmaAllocationCreateFlags allocFlags,
        -
        12356  void* pUserData,
        -
        12357  VmaSuballocationType suballocType,
        -
        12358  uint32_t strategy,
        -
        12359  VmaAllocation* pAllocation)
        -
        12360 {
        -
        12361  VMA_ASSERT((allocFlags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) == 0);
        -
        12362  const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
        -
        12363  const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        -
        12364  const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
        -
        12365 
        -
        12366  VmaAllocationRequest currRequest = {};
        -
        12367  if(pBlock->m_pMetadata->CreateAllocationRequest(
        -
        12368  currentFrameIndex,
        -
        12369  m_FrameInUseCount,
        -
        12370  m_BufferImageGranularity,
        -
        12371  size,
        -
        12372  alignment,
        -
        12373  isUpperAddress,
        -
        12374  suballocType,
        -
        12375  false, // canMakeOtherLost
        -
        12376  strategy,
        -
        12377  &currRequest))
        -
        12378  {
        -
        12379  // Allocate from pCurrBlock.
        -
        12380  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
        -
        12381 
        -
        12382  if(mapped)
        -
        12383  {
        -
        12384  VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
        -
        12385  if(res != VK_SUCCESS)
        -
        12386  {
        -
        12387  return res;
        -
        12388  }
        -
        12389  }
        -
        12390 
        -
        12391  // We no longer have an empty Allocation.
        -
        12392  if(pBlock->m_pMetadata->IsEmpty())
        -
        12393  {
        -
        12394  m_HasEmptyBlock = false;
        -
        12395  }
        -
        12396 
        -
        12397  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
        -
        12398  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
        -
        12399  pBlock->m_pMetadata->Alloc(currRequest, suballocType, size, *pAllocation);
        -
        12400  (*pAllocation)->InitBlockAllocation(
        -
        12401  pBlock,
        -
        12402  currRequest.offset,
        -
        12403  alignment,
        -
        12404  size,
        -
        12405  m_MemoryTypeIndex,
        -
        12406  suballocType,
        -
        12407  mapped,
        -
        12408  (allocFlags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        -
        12409  VMA_HEAVY_ASSERT(pBlock->Validate());
        -
        12410  (*pAllocation)->SetUserData(m_hAllocator, pUserData);
        -
        12411  m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
        -
        12412  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        -
        12413  {
        -
        12414  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        -
        12415  }
        -
        12416  if(IsCorruptionDetectionEnabled())
        -
        12417  {
        -
        12418  VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
        -
        12419  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        -
        12420  }
        -
        12421  return VK_SUCCESS;
        -
        12422  }
        -
        12423  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        12424 }
        -
        12425 
        -
        12426 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
        -
        12427 {
        -
        12428  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        -
        12429  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
        -
        12430  allocInfo.allocationSize = blockSize;
        -
        12431  VkDeviceMemory mem = VK_NULL_HANDLE;
        -
        12432  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
        -
        12433  if(res < 0)
        -
        12434  {
        -
        12435  return res;
        -
        12436  }
        -
        12437 
        -
        12438  // New VkDeviceMemory successfully created.
        -
        12439 
        -
        12440  // Create new Allocation for it.
        -
        12441  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
        -
        12442  pBlock->Init(
        -
        12443  m_hAllocator,
        -
        12444  m_hParentPool,
        -
        12445  m_MemoryTypeIndex,
        -
        12446  mem,
        -
        12447  allocInfo.allocationSize,
        -
        12448  m_NextBlockId++,
        -
        12449  m_Algorithm);
        -
        12450 
        -
        12451  m_Blocks.push_back(pBlock);
        -
        12452  if(pNewBlockIndex != VMA_NULL)
        -
        12453  {
        -
        12454  *pNewBlockIndex = m_Blocks.size() - 1;
        -
        12455  }
        -
        12456 
        -
        12457  return VK_SUCCESS;
        -
        12458 }
        -
        12459 
        -
        12460 void VmaBlockVector::ApplyDefragmentationMovesCpu(
        -
        12461  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        -
        12462  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves)
        -
        12463 {
        -
        12464  const size_t blockCount = m_Blocks.size();
        -
        12465  const bool isNonCoherent = m_hAllocator->IsMemoryTypeNonCoherent(m_MemoryTypeIndex);
        -
        12466 
        -
        12467  enum BLOCK_FLAG
        -
        12468  {
        -
        12469  BLOCK_FLAG_USED = 0x00000001,
        -
        12470  BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION = 0x00000002,
        -
        12471  };
        -
        12472 
        -
        12473  struct BlockInfo
        -
        12474  {
        -
        12475  uint32_t flags;
        -
        12476  void* pMappedData;
        -
        12477  };
        -
        12478  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> >
        -
        12479  blockInfo(blockCount, BlockInfo(), VmaStlAllocator<BlockInfo>(m_hAllocator->GetAllocationCallbacks()));
        -
        12480  memset(blockInfo.data(), 0, blockCount * sizeof(BlockInfo));
        -
        12481 
        -
        12482  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
        -
        12483  const size_t moveCount = moves.size();
        -
        12484  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        -
        12485  {
        -
        12486  const VmaDefragmentationMove& move = moves[moveIndex];
        -
        12487  blockInfo[move.srcBlockIndex].flags |= BLOCK_FLAG_USED;
        -
        12488  blockInfo[move.dstBlockIndex].flags |= BLOCK_FLAG_USED;
        -
        12489  }
        +
        12281 
        +
        12282  if(hAllocation->IsPersistentMap())
        +
        12283  {
        +
        12284  pBlock->Unmap(m_hAllocator, 1);
        +
        12285  }
        +
        12286 
        +
        12287  pBlock->m_pMetadata->Free(hAllocation);
        +
        12288  VMA_HEAVY_ASSERT(pBlock->Validate());
        +
        12289 
        +
        12290  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
        +
        12291 
        +
        12292  const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
        +
        12293  // pBlock became empty after this deallocation.
        +
        12294  if(pBlock->m_pMetadata->IsEmpty())
        +
        12295  {
        +
        12296  // Already has empty block. We don't want to have two, so delete this one.
        +
        12297  if((m_HasEmptyBlock || budgetExceeded) && canDeleteBlock)
        +
        12298  {
        +
        12299  pBlockToDelete = pBlock;
        +
        12300  Remove(pBlock);
        +
        12301  }
        +
        12302  // else: We now have an empty block - leave it.
        +
        12303  }
        +
        12304  // pBlock didn't become empty, but we have another empty block - find and free that one.
        +
        12305  // (This is optional, heuristics.)
        +
        12306  else if(m_HasEmptyBlock && canDeleteBlock)
        +
        12307  {
        +
        12308  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
        +
        12309  if(pLastBlock->m_pMetadata->IsEmpty())
        +
        12310  {
        +
        12311  pBlockToDelete = pLastBlock;
        +
        12312  m_Blocks.pop_back();
        +
        12313  }
        +
        12314  }
        +
        12315 
        +
        12316  UpdateHasEmptyBlock();
        +
        12317  IncrementallySortBlocks();
        +
        12318  }
        +
        12319 
        +
        12320  // Destruction of a free block. Deferred until this point, outside of mutex
        +
        12321  // lock, for performance reason.
        +
        12322  if(pBlockToDelete != VMA_NULL)
        +
        12323  {
        +
        12324  VMA_DEBUG_LOG(" Deleted empty block");
        +
        12325  pBlockToDelete->Destroy(m_hAllocator);
        +
        12326  vma_delete(m_hAllocator, pBlockToDelete);
        +
        12327  }
        +
        12328 }
        +
        12329 
        +
        12330 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
        +
        12331 {
        +
        12332  VkDeviceSize result = 0;
        +
        12333  for(size_t i = m_Blocks.size(); i--; )
        +
        12334  {
        +
        12335  result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
        +
        12336  if(result >= m_PreferredBlockSize)
        +
        12337  {
        +
        12338  break;
        +
        12339  }
        +
        12340  }
        +
        12341  return result;
        +
        12342 }
        +
        12343 
        +
        12344 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
        +
        12345 {
        +
        12346  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        +
        12347  {
        +
        12348  if(m_Blocks[blockIndex] == pBlock)
        +
        12349  {
        +
        12350  VmaVectorRemove(m_Blocks, blockIndex);
        +
        12351  return;
        +
        12352  }
        +
        12353  }
        +
        12354  VMA_ASSERT(0);
        +
        12355 }
        +
        12356 
        +
        12357 void VmaBlockVector::IncrementallySortBlocks()
        +
        12358 {
        +
        12359  if(m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
        +
        12360  {
        +
        12361  // Bubble sort only until first swap.
        +
        12362  for(size_t i = 1; i < m_Blocks.size(); ++i)
        +
        12363  {
        +
        12364  if(m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
        +
        12365  {
        +
        12366  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
        +
        12367  return;
        +
        12368  }
        +
        12369  }
        +
        12370  }
        +
        12371 }
        +
        12372 
        +
        12373 VkResult VmaBlockVector::AllocateFromBlock(
        +
        12374  VmaDeviceMemoryBlock* pBlock,
        +
        12375  uint32_t currentFrameIndex,
        +
        12376  VkDeviceSize size,
        +
        12377  VkDeviceSize alignment,
        +
        12378  VmaAllocationCreateFlags allocFlags,
        +
        12379  void* pUserData,
        +
        12380  VmaSuballocationType suballocType,
        +
        12381  uint32_t strategy,
        +
        12382  VmaAllocation* pAllocation)
        +
        12383 {
        +
        12384  VMA_ASSERT((allocFlags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) == 0);
        +
        12385  const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
        +
        12386  const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        +
        12387  const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
        +
        12388 
        +
        12389  VmaAllocationRequest currRequest = {};
        +
        12390  if(pBlock->m_pMetadata->CreateAllocationRequest(
        +
        12391  currentFrameIndex,
        +
        12392  m_FrameInUseCount,
        +
        12393  m_BufferImageGranularity,
        +
        12394  size,
        +
        12395  alignment,
        +
        12396  isUpperAddress,
        +
        12397  suballocType,
        +
        12398  false, // canMakeOtherLost
        +
        12399  strategy,
        +
        12400  &currRequest))
        +
        12401  {
        +
        12402  // Allocate from pCurrBlock.
        +
        12403  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
        +
        12404 
        +
        12405  if(mapped)
        +
        12406  {
        +
        12407  VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
        +
        12408  if(res != VK_SUCCESS)
        +
        12409  {
        +
        12410  return res;
        +
        12411  }
        +
        12412  }
        +
        12413 
        +
        12414  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
        +
        12415  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
        +
        12416  pBlock->m_pMetadata->Alloc(currRequest, suballocType, size, *pAllocation);
        +
        12417  UpdateHasEmptyBlock();
        +
        12418  (*pAllocation)->InitBlockAllocation(
        +
        12419  pBlock,
        +
        12420  currRequest.offset,
        +
        12421  alignment,
        +
        12422  size,
        +
        12423  m_MemoryTypeIndex,
        +
        12424  suballocType,
        +
        12425  mapped,
        +
        12426  (allocFlags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        +
        12427  VMA_HEAVY_ASSERT(pBlock->Validate());
        +
        12428  (*pAllocation)->SetUserData(m_hAllocator, pUserData);
        +
        12429  m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
        +
        12430  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        +
        12431  {
        +
        12432  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        +
        12433  }
        +
        12434  if(IsCorruptionDetectionEnabled())
        +
        12435  {
        +
        12436  VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
        +
        12437  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        +
        12438  }
        +
        12439  return VK_SUCCESS;
        +
        12440  }
        +
        12441  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        12442 }
        +
        12443 
        +
        12444 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
        +
        12445 {
        +
        12446  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        +
        12447  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
        +
        12448  allocInfo.allocationSize = blockSize;
        +
        12449  VkDeviceMemory mem = VK_NULL_HANDLE;
        +
        12450  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
        +
        12451  if(res < 0)
        +
        12452  {
        +
        12453  return res;
        +
        12454  }
        +
        12455 
        +
        12456  // New VkDeviceMemory successfully created.
        +
        12457 
        +
        12458  // Create new Allocation for it.
        +
        12459  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
        +
        12460  pBlock->Init(
        +
        12461  m_hAllocator,
        +
        12462  m_hParentPool,
        +
        12463  m_MemoryTypeIndex,
        +
        12464  mem,
        +
        12465  allocInfo.allocationSize,
        +
        12466  m_NextBlockId++,
        +
        12467  m_Algorithm);
        +
        12468 
        +
        12469  m_Blocks.push_back(pBlock);
        +
        12470  if(pNewBlockIndex != VMA_NULL)
        +
        12471  {
        +
        12472  *pNewBlockIndex = m_Blocks.size() - 1;
        +
        12473  }
        +
        12474 
        +
        12475  return VK_SUCCESS;
        +
        12476 }
        +
        12477 
        +
        12478 void VmaBlockVector::ApplyDefragmentationMovesCpu(
        +
        12479  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        +
        12480  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves)
        +
        12481 {
        +
        12482  const size_t blockCount = m_Blocks.size();
        +
        12483  const bool isNonCoherent = m_hAllocator->IsMemoryTypeNonCoherent(m_MemoryTypeIndex);
        +
        12484 
        +
        12485  enum BLOCK_FLAG
        +
        12486  {
        +
        12487  BLOCK_FLAG_USED = 0x00000001,
        +
        12488  BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION = 0x00000002,
        +
        12489  };
        12490 
        -
        12491  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
        -
        12492 
        -
        12493  // Go over all blocks. Get mapped pointer or map if necessary.
        -
        12494  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
        -
        12495  {
        -
        12496  BlockInfo& currBlockInfo = blockInfo[blockIndex];
        -
        12497  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        -
        12498  if((currBlockInfo.flags & BLOCK_FLAG_USED) != 0)
        -
        12499  {
        -
        12500  currBlockInfo.pMappedData = pBlock->GetMappedData();
        -
        12501  // It is not originally mapped - map it.
        -
        12502  if(currBlockInfo.pMappedData == VMA_NULL)
        -
        12503  {
        -
        12504  pDefragCtx->res = pBlock->Map(m_hAllocator, 1, &currBlockInfo.pMappedData);
        -
        12505  if(pDefragCtx->res == VK_SUCCESS)
        -
        12506  {
        -
        12507  currBlockInfo.flags |= BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION;
        -
        12508  }
        -
        12509  }
        -
        12510  }
        -
        12511  }
        -
        12512 
        -
        12513  // Go over all moves. Do actual data transfer.
        -
        12514  if(pDefragCtx->res == VK_SUCCESS)
        -
        12515  {
        -
        12516  const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
        -
        12517  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
        -
        12518 
        -
        12519  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        -
        12520  {
        -
        12521  const VmaDefragmentationMove& move = moves[moveIndex];
        -
        12522 
        -
        12523  const BlockInfo& srcBlockInfo = blockInfo[move.srcBlockIndex];
        -
        12524  const BlockInfo& dstBlockInfo = blockInfo[move.dstBlockIndex];
        -
        12525 
        -
        12526  VMA_ASSERT(srcBlockInfo.pMappedData && dstBlockInfo.pMappedData);
        -
        12527 
        -
        12528  // Invalidate source.
        -
        12529  if(isNonCoherent)
        -
        12530  {
        -
        12531  VmaDeviceMemoryBlock* const pSrcBlock = m_Blocks[move.srcBlockIndex];
        -
        12532  memRange.memory = pSrcBlock->GetDeviceMemory();
        -
        12533  memRange.offset = VmaAlignDown(move.srcOffset, nonCoherentAtomSize);
        -
        12534  memRange.size = VMA_MIN(
        -
        12535  VmaAlignUp(move.size + (move.srcOffset - memRange.offset), nonCoherentAtomSize),
        -
        12536  pSrcBlock->m_pMetadata->GetSize() - memRange.offset);
        -
        12537  (*m_hAllocator->GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
        -
        12538  }
        -
        12539 
        -
        12540  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
        -
        12541  memmove(
        -
        12542  reinterpret_cast<char*>(dstBlockInfo.pMappedData) + move.dstOffset,
        -
        12543  reinterpret_cast<char*>(srcBlockInfo.pMappedData) + move.srcOffset,
        -
        12544  static_cast<size_t>(move.size));
        +
        12491  struct BlockInfo
        +
        12492  {
        +
        12493  uint32_t flags;
        +
        12494  void* pMappedData;
        +
        12495  };
        +
        12496  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> >
        +
        12497  blockInfo(blockCount, BlockInfo(), VmaStlAllocator<BlockInfo>(m_hAllocator->GetAllocationCallbacks()));
        +
        12498  memset(blockInfo.data(), 0, blockCount * sizeof(BlockInfo));
        +
        12499 
        +
        12500  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
        +
        12501  const size_t moveCount = moves.size();
        +
        12502  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        +
        12503  {
        +
        12504  const VmaDefragmentationMove& move = moves[moveIndex];
        +
        12505  blockInfo[move.srcBlockIndex].flags |= BLOCK_FLAG_USED;
        +
        12506  blockInfo[move.dstBlockIndex].flags |= BLOCK_FLAG_USED;
        +
        12507  }
        +
        12508 
        +
        12509  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
        +
        12510 
        +
        12511  // Go over all blocks. Get mapped pointer or map if necessary.
        +
        12512  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
        +
        12513  {
        +
        12514  BlockInfo& currBlockInfo = blockInfo[blockIndex];
        +
        12515  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        +
        12516  if((currBlockInfo.flags & BLOCK_FLAG_USED) != 0)
        +
        12517  {
        +
        12518  currBlockInfo.pMappedData = pBlock->GetMappedData();
        +
        12519  // It is not originally mapped - map it.
        +
        12520  if(currBlockInfo.pMappedData == VMA_NULL)
        +
        12521  {
        +
        12522  pDefragCtx->res = pBlock->Map(m_hAllocator, 1, &currBlockInfo.pMappedData);
        +
        12523  if(pDefragCtx->res == VK_SUCCESS)
        +
        12524  {
        +
        12525  currBlockInfo.flags |= BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION;
        +
        12526  }
        +
        12527  }
        +
        12528  }
        +
        12529  }
        +
        12530 
        +
        12531  // Go over all moves. Do actual data transfer.
        +
        12532  if(pDefragCtx->res == VK_SUCCESS)
        +
        12533  {
        +
        12534  const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
        +
        12535  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
        +
        12536 
        +
        12537  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        +
        12538  {
        +
        12539  const VmaDefragmentationMove& move = moves[moveIndex];
        +
        12540 
        +
        12541  const BlockInfo& srcBlockInfo = blockInfo[move.srcBlockIndex];
        +
        12542  const BlockInfo& dstBlockInfo = blockInfo[move.dstBlockIndex];
        +
        12543 
        +
        12544  VMA_ASSERT(srcBlockInfo.pMappedData && dstBlockInfo.pMappedData);
        12545 
        -
        12546  if(IsCorruptionDetectionEnabled())
        -
        12547  {
        -
        12548  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset - VMA_DEBUG_MARGIN);
        -
        12549  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset + move.size);
        -
        12550  }
        -
        12551 
        -
        12552  // Flush destination.
        -
        12553  if(isNonCoherent)
        -
        12554  {
        -
        12555  VmaDeviceMemoryBlock* const pDstBlock = m_Blocks[move.dstBlockIndex];
        -
        12556  memRange.memory = pDstBlock->GetDeviceMemory();
        -
        12557  memRange.offset = VmaAlignDown(move.dstOffset, nonCoherentAtomSize);
        -
        12558  memRange.size = VMA_MIN(
        -
        12559  VmaAlignUp(move.size + (move.dstOffset - memRange.offset), nonCoherentAtomSize),
        -
        12560  pDstBlock->m_pMetadata->GetSize() - memRange.offset);
        -
        12561  (*m_hAllocator->GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
        -
        12562  }
        -
        12563  }
        -
        12564  }
        -
        12565 
        -
        12566  // Go over all blocks in reverse order. Unmap those that were mapped just for defragmentation.
        -
        12567  // Regardless of pCtx->res == VK_SUCCESS.
        -
        12568  for(size_t blockIndex = blockCount; blockIndex--; )
        -
        12569  {
        -
        12570  const BlockInfo& currBlockInfo = blockInfo[blockIndex];
        -
        12571  if((currBlockInfo.flags & BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION) != 0)
        -
        12572  {
        -
        12573  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        -
        12574  pBlock->Unmap(m_hAllocator, 1);
        -
        12575  }
        -
        12576  }
        -
        12577 }
        -
        12578 
        -
        12579 void VmaBlockVector::ApplyDefragmentationMovesGpu(
        -
        12580  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        -
        12581  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        12582  VkCommandBuffer commandBuffer)
        -
        12583 {
        -
        12584  const size_t blockCount = m_Blocks.size();
        -
        12585 
        -
        12586  pDefragCtx->blockContexts.resize(blockCount);
        -
        12587  memset(pDefragCtx->blockContexts.data(), 0, blockCount * sizeof(VmaBlockDefragmentationContext));
        -
        12588 
        -
        12589  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
        -
        12590  const size_t moveCount = moves.size();
        -
        12591  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        -
        12592  {
        -
        12593  const VmaDefragmentationMove& move = moves[moveIndex];
        -
        12594  pDefragCtx->blockContexts[move.srcBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
        -
        12595  pDefragCtx->blockContexts[move.dstBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
        -
        12596  }
        -
        12597 
        -
        12598  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
        -
        12599 
        -
        12600  // Go over all blocks. Create and bind buffer for whole block if necessary.
        -
        12601  {
        -
        12602  VkBufferCreateInfo bufCreateInfo;
        -
        12603  VmaFillGpuDefragmentationBufferCreateInfo(bufCreateInfo);
        -
        12604 
        -
        12605  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
        -
        12606  {
        -
        12607  VmaBlockDefragmentationContext& currBlockCtx = pDefragCtx->blockContexts[blockIndex];
        -
        12608  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        -
        12609  if((currBlockCtx.flags & VmaBlockDefragmentationContext::BLOCK_FLAG_USED) != 0)
        -
        12610  {
        -
        12611  bufCreateInfo.size = pBlock->m_pMetadata->GetSize();
        -
        12612  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkCreateBuffer)(
        -
        12613  m_hAllocator->m_hDevice, &bufCreateInfo, m_hAllocator->GetAllocationCallbacks(), &currBlockCtx.hBuffer);
        -
        12614  if(pDefragCtx->res == VK_SUCCESS)
        -
        12615  {
        -
        12616  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkBindBufferMemory)(
        -
        12617  m_hAllocator->m_hDevice, currBlockCtx.hBuffer, pBlock->GetDeviceMemory(), 0);
        -
        12618  }
        -
        12619  }
        -
        12620  }
        -
        12621  }
        +
        12546  // Invalidate source.
        +
        12547  if(isNonCoherent)
        +
        12548  {
        +
        12549  VmaDeviceMemoryBlock* const pSrcBlock = m_Blocks[move.srcBlockIndex];
        +
        12550  memRange.memory = pSrcBlock->GetDeviceMemory();
        +
        12551  memRange.offset = VmaAlignDown(move.srcOffset, nonCoherentAtomSize);
        +
        12552  memRange.size = VMA_MIN(
        +
        12553  VmaAlignUp(move.size + (move.srcOffset - memRange.offset), nonCoherentAtomSize),
        +
        12554  pSrcBlock->m_pMetadata->GetSize() - memRange.offset);
        +
        12555  (*m_hAllocator->GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
        +
        12556  }
        +
        12557 
        +
        12558  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
        +
        12559  memmove(
        +
        12560  reinterpret_cast<char*>(dstBlockInfo.pMappedData) + move.dstOffset,
        +
        12561  reinterpret_cast<char*>(srcBlockInfo.pMappedData) + move.srcOffset,
        +
        12562  static_cast<size_t>(move.size));
        +
        12563 
        +
        12564  if(IsCorruptionDetectionEnabled())
        +
        12565  {
        +
        12566  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset - VMA_DEBUG_MARGIN);
        +
        12567  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset + move.size);
        +
        12568  }
        +
        12569 
        +
        12570  // Flush destination.
        +
        12571  if(isNonCoherent)
        +
        12572  {
        +
        12573  VmaDeviceMemoryBlock* const pDstBlock = m_Blocks[move.dstBlockIndex];
        +
        12574  memRange.memory = pDstBlock->GetDeviceMemory();
        +
        12575  memRange.offset = VmaAlignDown(move.dstOffset, nonCoherentAtomSize);
        +
        12576  memRange.size = VMA_MIN(
        +
        12577  VmaAlignUp(move.size + (move.dstOffset - memRange.offset), nonCoherentAtomSize),
        +
        12578  pDstBlock->m_pMetadata->GetSize() - memRange.offset);
        +
        12579  (*m_hAllocator->GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
        +
        12580  }
        +
        12581  }
        +
        12582  }
        +
        12583 
        +
        12584  // Go over all blocks in reverse order. Unmap those that were mapped just for defragmentation.
        +
        12585  // Regardless of pCtx->res == VK_SUCCESS.
        +
        12586  for(size_t blockIndex = blockCount; blockIndex--; )
        +
        12587  {
        +
        12588  const BlockInfo& currBlockInfo = blockInfo[blockIndex];
        +
        12589  if((currBlockInfo.flags & BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION) != 0)
        +
        12590  {
        +
        12591  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        +
        12592  pBlock->Unmap(m_hAllocator, 1);
        +
        12593  }
        +
        12594  }
        +
        12595 }
        +
        12596 
        +
        12597 void VmaBlockVector::ApplyDefragmentationMovesGpu(
        +
        12598  class VmaBlockVectorDefragmentationContext* pDefragCtx,
        +
        12599  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        12600  VkCommandBuffer commandBuffer)
        +
        12601 {
        +
        12602  const size_t blockCount = m_Blocks.size();
        +
        12603 
        +
        12604  pDefragCtx->blockContexts.resize(blockCount);
        +
        12605  memset(pDefragCtx->blockContexts.data(), 0, blockCount * sizeof(VmaBlockDefragmentationContext));
        +
        12606 
        +
        12607  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
        +
        12608  const size_t moveCount = moves.size();
        +
        12609  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        +
        12610  {
        +
        12611  const VmaDefragmentationMove& move = moves[moveIndex];
        +
        12612  pDefragCtx->blockContexts[move.srcBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
        +
        12613  pDefragCtx->blockContexts[move.dstBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
        +
        12614  }
        +
        12615 
        +
        12616  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
        +
        12617 
        +
        12618  // Go over all blocks. Create and bind buffer for whole block if necessary.
        +
        12619  {
        +
        12620  VkBufferCreateInfo bufCreateInfo;
        +
        12621  VmaFillGpuDefragmentationBufferCreateInfo(bufCreateInfo);
        12622 
        -
        12623  // Go over all moves. Post data transfer commands to command buffer.
        -
        12624  if(pDefragCtx->res == VK_SUCCESS)
        -
        12625  {
        -
        12626  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        -
        12627  {
        -
        12628  const VmaDefragmentationMove& move = moves[moveIndex];
        -
        12629 
        -
        12630  const VmaBlockDefragmentationContext& srcBlockCtx = pDefragCtx->blockContexts[move.srcBlockIndex];
        -
        12631  const VmaBlockDefragmentationContext& dstBlockCtx = pDefragCtx->blockContexts[move.dstBlockIndex];
        -
        12632 
        -
        12633  VMA_ASSERT(srcBlockCtx.hBuffer && dstBlockCtx.hBuffer);
        -
        12634 
        -
        12635  VkBufferCopy region = {
        -
        12636  move.srcOffset,
        -
        12637  move.dstOffset,
        -
        12638  move.size };
        -
        12639  (*m_hAllocator->GetVulkanFunctions().vkCmdCopyBuffer)(
        -
        12640  commandBuffer, srcBlockCtx.hBuffer, dstBlockCtx.hBuffer, 1, &region);
        -
        12641  }
        -
        12642  }
        -
        12643 
        -
        12644  // Save buffers to defrag context for later destruction.
        -
        12645  if(pDefragCtx->res == VK_SUCCESS && moveCount > 0)
        -
        12646  {
        -
        12647  pDefragCtx->res = VK_NOT_READY;
        -
        12648  }
        -
        12649 }
        +
        12623  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
        +
        12624  {
        +
        12625  VmaBlockDefragmentationContext& currBlockCtx = pDefragCtx->blockContexts[blockIndex];
        +
        12626  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        +
        12627  if((currBlockCtx.flags & VmaBlockDefragmentationContext::BLOCK_FLAG_USED) != 0)
        +
        12628  {
        +
        12629  bufCreateInfo.size = pBlock->m_pMetadata->GetSize();
        +
        12630  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkCreateBuffer)(
        +
        12631  m_hAllocator->m_hDevice, &bufCreateInfo, m_hAllocator->GetAllocationCallbacks(), &currBlockCtx.hBuffer);
        +
        12632  if(pDefragCtx->res == VK_SUCCESS)
        +
        12633  {
        +
        12634  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkBindBufferMemory)(
        +
        12635  m_hAllocator->m_hDevice, currBlockCtx.hBuffer, pBlock->GetDeviceMemory(), 0);
        +
        12636  }
        +
        12637  }
        +
        12638  }
        +
        12639  }
        +
        12640 
        +
        12641  // Go over all moves. Post data transfer commands to command buffer.
        +
        12642  if(pDefragCtx->res == VK_SUCCESS)
        +
        12643  {
        +
        12644  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
        +
        12645  {
        +
        12646  const VmaDefragmentationMove& move = moves[moveIndex];
        +
        12647 
        +
        12648  const VmaBlockDefragmentationContext& srcBlockCtx = pDefragCtx->blockContexts[move.srcBlockIndex];
        +
        12649  const VmaBlockDefragmentationContext& dstBlockCtx = pDefragCtx->blockContexts[move.dstBlockIndex];
        12650 
        -
        12651 void VmaBlockVector::FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats)
        -
        12652 {
        -
        12653  m_HasEmptyBlock = false;
        -
        12654  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        -
        12655  {
        -
        12656  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        -
        12657  if(pBlock->m_pMetadata->IsEmpty())
        -
        12658  {
        -
        12659  if(m_Blocks.size() > m_MinBlockCount)
        -
        12660  {
        -
        12661  if(pDefragmentationStats != VMA_NULL)
        -
        12662  {
        -
        12663  ++pDefragmentationStats->deviceMemoryBlocksFreed;
        -
        12664  pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();
        -
        12665  }
        -
        12666 
        -
        12667  VmaVectorRemove(m_Blocks, blockIndex);
        -
        12668  pBlock->Destroy(m_hAllocator);
        -
        12669  vma_delete(m_hAllocator, pBlock);
        -
        12670  }
        -
        12671  else
        -
        12672  {
        -
        12673  m_HasEmptyBlock = true;
        -
        12674  }
        -
        12675  }
        -
        12676  }
        -
        12677 }
        -
        12678 
        -
        12679 #if VMA_STATS_STRING_ENABLED
        -
        12680 
        -
        12681 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
        -
        12682 {
        -
        12683  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        -
        12684 
        -
        12685  json.BeginObject();
        -
        12686 
        -
        12687  if(IsCustomPool())
        -
        12688  {
        -
        12689  const char* poolName = m_hParentPool->GetName();
        -
        12690  if(poolName != VMA_NULL && poolName[0] != '\0')
        -
        12691  {
        -
        12692  json.WriteString("Name");
        -
        12693  json.WriteString(poolName);
        -
        12694  }
        -
        12695 
        -
        12696  json.WriteString("MemoryTypeIndex");
        -
        12697  json.WriteNumber(m_MemoryTypeIndex);
        -
        12698 
        -
        12699  json.WriteString("BlockSize");
        -
        12700  json.WriteNumber(m_PreferredBlockSize);
        -
        12701 
        -
        12702  json.WriteString("BlockCount");
        -
        12703  json.BeginObject(true);
        -
        12704  if(m_MinBlockCount > 0)
        -
        12705  {
        -
        12706  json.WriteString("Min");
        -
        12707  json.WriteNumber((uint64_t)m_MinBlockCount);
        -
        12708  }
        -
        12709  if(m_MaxBlockCount < SIZE_MAX)
        -
        12710  {
        -
        12711  json.WriteString("Max");
        -
        12712  json.WriteNumber((uint64_t)m_MaxBlockCount);
        -
        12713  }
        -
        12714  json.WriteString("Cur");
        -
        12715  json.WriteNumber((uint64_t)m_Blocks.size());
        -
        12716  json.EndObject();
        -
        12717 
        -
        12718  if(m_FrameInUseCount > 0)
        -
        12719  {
        -
        12720  json.WriteString("FrameInUseCount");
        -
        12721  json.WriteNumber(m_FrameInUseCount);
        -
        12722  }
        -
        12723 
        -
        12724  if(m_Algorithm != 0)
        -
        12725  {
        -
        12726  json.WriteString("Algorithm");
        -
        12727  json.WriteString(VmaAlgorithmToStr(m_Algorithm));
        -
        12728  }
        -
        12729  }
        -
        12730  else
        -
        12731  {
        -
        12732  json.WriteString("PreferredBlockSize");
        -
        12733  json.WriteNumber(m_PreferredBlockSize);
        -
        12734  }
        -
        12735 
        -
        12736  json.WriteString("Blocks");
        -
        12737  json.BeginObject();
        -
        12738  for(size_t i = 0; i < m_Blocks.size(); ++i)
        -
        12739  {
        -
        12740  json.BeginString();
        -
        12741  json.ContinueString(m_Blocks[i]->GetId());
        -
        12742  json.EndString();
        -
        12743 
        -
        12744  m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
        -
        12745  }
        -
        12746  json.EndObject();
        -
        12747 
        -
        12748  json.EndObject();
        -
        12749 }
        -
        12750 
        -
        12751 #endif // #if VMA_STATS_STRING_ENABLED
        -
        12752 
        -
        12753 void VmaBlockVector::Defragment(
        -
        12754  class VmaBlockVectorDefragmentationContext* pCtx,
        -
        12755  VmaDefragmentationStats* pStats,
        -
        12756  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
        -
        12757  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
        -
        12758  VkCommandBuffer commandBuffer)
        -
        12759 {
        -
        12760  pCtx->res = VK_SUCCESS;
        -
        12761 
        -
        12762  const VkMemoryPropertyFlags memPropFlags =
        -
        12763  m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags;
        -
        12764  const bool isHostVisible = (memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;
        -
        12765 
        -
        12766  const bool canDefragmentOnCpu = maxCpuBytesToMove > 0 && maxCpuAllocationsToMove > 0 &&
        -
        12767  isHostVisible;
        -
        12768  const bool canDefragmentOnGpu = maxGpuBytesToMove > 0 && maxGpuAllocationsToMove > 0 &&
        -
        12769  !IsCorruptionDetectionEnabled() &&
        -
        12770  ((1u << m_MemoryTypeIndex) & m_hAllocator->GetGpuDefragmentationMemoryTypeBits()) != 0;
        -
        12771 
        -
        12772  // There are options to defragment this memory type.
        -
        12773  if(canDefragmentOnCpu || canDefragmentOnGpu)
        -
        12774  {
        -
        12775  bool defragmentOnGpu;
        -
        12776  // There is only one option to defragment this memory type.
        -
        12777  if(canDefragmentOnGpu != canDefragmentOnCpu)
        -
        12778  {
        -
        12779  defragmentOnGpu = canDefragmentOnGpu;
        -
        12780  }
        -
        12781  // Both options are available: Heuristics to choose the best one.
        -
        12782  else
        -
        12783  {
        -
        12784  defragmentOnGpu = (memPropFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0 ||
        -
        12785  m_hAllocator->IsIntegratedGpu();
        -
        12786  }
        -
        12787 
        -
        12788  bool overlappingMoveSupported = !defragmentOnGpu;
        -
        12789 
        -
        12790  if(m_hAllocator->m_UseMutex)
        -
        12791  {
        -
        12792  m_Mutex.LockWrite();
        -
        12793  pCtx->mutexLocked = true;
        -
        12794  }
        -
        12795 
        -
        12796  pCtx->Begin(overlappingMoveSupported);
        +
        12651  VMA_ASSERT(srcBlockCtx.hBuffer && dstBlockCtx.hBuffer);
        +
        12652 
        +
        12653  VkBufferCopy region = {
        +
        12654  move.srcOffset,
        +
        12655  move.dstOffset,
        +
        12656  move.size };
        +
        12657  (*m_hAllocator->GetVulkanFunctions().vkCmdCopyBuffer)(
        +
        12658  commandBuffer, srcBlockCtx.hBuffer, dstBlockCtx.hBuffer, 1, &region);
        +
        12659  }
        +
        12660  }
        +
        12661 
        +
        12662  // Save buffers to defrag context for later destruction.
        +
        12663  if(pDefragCtx->res == VK_SUCCESS && moveCount > 0)
        +
        12664  {
        +
        12665  pDefragCtx->res = VK_NOT_READY;
        +
        12666  }
        +
        12667 }
        +
        12668 
        +
        12669 void VmaBlockVector::FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats)
        +
        12670 {
        +
        12671  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        +
        12672  {
        +
        12673  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        +
        12674  if(pBlock->m_pMetadata->IsEmpty())
        +
        12675  {
        +
        12676  if(m_Blocks.size() > m_MinBlockCount)
        +
        12677  {
        +
        12678  if(pDefragmentationStats != VMA_NULL)
        +
        12679  {
        +
        12680  ++pDefragmentationStats->deviceMemoryBlocksFreed;
        +
        12681  pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();
        +
        12682  }
        +
        12683 
        +
        12684  VmaVectorRemove(m_Blocks, blockIndex);
        +
        12685  pBlock->Destroy(m_hAllocator);
        +
        12686  vma_delete(m_hAllocator, pBlock);
        +
        12687  }
        +
        12688  else
        +
        12689  {
        +
        12690  break;
        +
        12691  }
        +
        12692  }
        +
        12693  }
        +
        12694  UpdateHasEmptyBlock();
        +
        12695 }
        +
        12696 
        +
        12697 void VmaBlockVector::UpdateHasEmptyBlock()
        +
        12698 {
        +
        12699  m_HasEmptyBlock = false;
        +
        12700  for(size_t index = 0, count = m_Blocks.size(); index < count; ++index)
        +
        12701  {
        +
        12702  VmaDeviceMemoryBlock* const pBlock = m_Blocks[index];
        +
        12703  if(pBlock->m_pMetadata->IsEmpty())
        +
        12704  {
        +
        12705  m_HasEmptyBlock = true;
        +
        12706  break;
        +
        12707  }
        +
        12708  }
        +
        12709 }
        +
        12710 
        +
        12711 #if VMA_STATS_STRING_ENABLED
        +
        12712 
        +
        12713 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
        +
        12714 {
        +
        12715  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        +
        12716 
        +
        12717  json.BeginObject();
        +
        12718 
        +
        12719  if(IsCustomPool())
        +
        12720  {
        +
        12721  const char* poolName = m_hParentPool->GetName();
        +
        12722  if(poolName != VMA_NULL && poolName[0] != '\0')
        +
        12723  {
        +
        12724  json.WriteString("Name");
        +
        12725  json.WriteString(poolName);
        +
        12726  }
        +
        12727 
        +
        12728  json.WriteString("MemoryTypeIndex");
        +
        12729  json.WriteNumber(m_MemoryTypeIndex);
        +
        12730 
        +
        12731  json.WriteString("BlockSize");
        +
        12732  json.WriteNumber(m_PreferredBlockSize);
        +
        12733 
        +
        12734  json.WriteString("BlockCount");
        +
        12735  json.BeginObject(true);
        +
        12736  if(m_MinBlockCount > 0)
        +
        12737  {
        +
        12738  json.WriteString("Min");
        +
        12739  json.WriteNumber((uint64_t)m_MinBlockCount);
        +
        12740  }
        +
        12741  if(m_MaxBlockCount < SIZE_MAX)
        +
        12742  {
        +
        12743  json.WriteString("Max");
        +
        12744  json.WriteNumber((uint64_t)m_MaxBlockCount);
        +
        12745  }
        +
        12746  json.WriteString("Cur");
        +
        12747  json.WriteNumber((uint64_t)m_Blocks.size());
        +
        12748  json.EndObject();
        +
        12749 
        +
        12750  if(m_FrameInUseCount > 0)
        +
        12751  {
        +
        12752  json.WriteString("FrameInUseCount");
        +
        12753  json.WriteNumber(m_FrameInUseCount);
        +
        12754  }
        +
        12755 
        +
        12756  if(m_Algorithm != 0)
        +
        12757  {
        +
        12758  json.WriteString("Algorithm");
        +
        12759  json.WriteString(VmaAlgorithmToStr(m_Algorithm));
        +
        12760  }
        +
        12761  }
        +
        12762  else
        +
        12763  {
        +
        12764  json.WriteString("PreferredBlockSize");
        +
        12765  json.WriteNumber(m_PreferredBlockSize);
        +
        12766  }
        +
        12767 
        +
        12768  json.WriteString("Blocks");
        +
        12769  json.BeginObject();
        +
        12770  for(size_t i = 0; i < m_Blocks.size(); ++i)
        +
        12771  {
        +
        12772  json.BeginString();
        +
        12773  json.ContinueString(m_Blocks[i]->GetId());
        +
        12774  json.EndString();
        +
        12775 
        +
        12776  m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
        +
        12777  }
        +
        12778  json.EndObject();
        +
        12779 
        +
        12780  json.EndObject();
        +
        12781 }
        +
        12782 
        +
        12783 #endif // #if VMA_STATS_STRING_ENABLED
        +
        12784 
        +
        12785 void VmaBlockVector::Defragment(
        +
        12786  class VmaBlockVectorDefragmentationContext* pCtx,
        +
        12787  VmaDefragmentationStats* pStats,
        +
        12788  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
        +
        12789  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
        +
        12790  VkCommandBuffer commandBuffer)
        +
        12791 {
        +
        12792  pCtx->res = VK_SUCCESS;
        +
        12793 
        +
        12794  const VkMemoryPropertyFlags memPropFlags =
        +
        12795  m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags;
        +
        12796  const bool isHostVisible = (memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;
        12797 
        -
        12798  // Defragment.
        -
        12799 
        -
        12800  const VkDeviceSize maxBytesToMove = defragmentOnGpu ? maxGpuBytesToMove : maxCpuBytesToMove;
        -
        12801  const uint32_t maxAllocationsToMove = defragmentOnGpu ? maxGpuAllocationsToMove : maxCpuAllocationsToMove;
        -
        12802  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> > moves =
        -
        12803  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >(VmaStlAllocator<VmaDefragmentationMove>(m_hAllocator->GetAllocationCallbacks()));
        -
        12804  pCtx->res = pCtx->GetAlgorithm()->Defragment(moves, maxBytesToMove, maxAllocationsToMove);
        -
        12805 
        -
        12806  // Accumulate statistics.
        -
        12807  if(pStats != VMA_NULL)
        -
        12808  {
        -
        12809  const VkDeviceSize bytesMoved = pCtx->GetAlgorithm()->GetBytesMoved();
        -
        12810  const uint32_t allocationsMoved = pCtx->GetAlgorithm()->GetAllocationsMoved();
        -
        12811  pStats->bytesMoved += bytesMoved;
        -
        12812  pStats->allocationsMoved += allocationsMoved;
        -
        12813  VMA_ASSERT(bytesMoved <= maxBytesToMove);
        -
        12814  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
        -
        12815  if(defragmentOnGpu)
        -
        12816  {
        -
        12817  maxGpuBytesToMove -= bytesMoved;
        -
        12818  maxGpuAllocationsToMove -= allocationsMoved;
        -
        12819  }
        -
        12820  else
        -
        12821  {
        -
        12822  maxCpuBytesToMove -= bytesMoved;
        -
        12823  maxCpuAllocationsToMove -= allocationsMoved;
        -
        12824  }
        -
        12825  }
        -
        12826 
        -
        12827  if(pCtx->res >= VK_SUCCESS)
        -
        12828  {
        -
        12829  if(defragmentOnGpu)
        -
        12830  {
        -
        12831  ApplyDefragmentationMovesGpu(pCtx, moves, commandBuffer);
        -
        12832  }
        -
        12833  else
        -
        12834  {
        -
        12835  ApplyDefragmentationMovesCpu(pCtx, moves);
        -
        12836  }
        -
        12837  }
        -
        12838  }
        -
        12839 }
        -
        12840 
        -
        12841 void VmaBlockVector::DefragmentationEnd(
        -
        12842  class VmaBlockVectorDefragmentationContext* pCtx,
        -
        12843  VmaDefragmentationStats* pStats)
        -
        12844 {
        -
        12845  // Destroy buffers.
        -
        12846  for(size_t blockIndex = pCtx->blockContexts.size(); blockIndex--; )
        -
        12847  {
        -
        12848  VmaBlockDefragmentationContext& blockCtx = pCtx->blockContexts[blockIndex];
        -
        12849  if(blockCtx.hBuffer)
        -
        12850  {
        -
        12851  (*m_hAllocator->GetVulkanFunctions().vkDestroyBuffer)(
        -
        12852  m_hAllocator->m_hDevice, blockCtx.hBuffer, m_hAllocator->GetAllocationCallbacks());
        -
        12853  }
        -
        12854  }
        -
        12855 
        -
        12856  if(pCtx->res >= VK_SUCCESS)
        -
        12857  {
        -
        12858  FreeEmptyBlocks(pStats);
        -
        12859  }
        -
        12860 
        -
        12861  if(pCtx->mutexLocked)
        -
        12862  {
        -
        12863  VMA_ASSERT(m_hAllocator->m_UseMutex);
        -
        12864  m_Mutex.UnlockWrite();
        -
        12865  }
        -
        12866 }
        -
        12867 
        -
        12868 size_t VmaBlockVector::CalcAllocationCount() const
        -
        12869 {
        -
        12870  size_t result = 0;
        -
        12871  for(size_t i = 0; i < m_Blocks.size(); ++i)
        -
        12872  {
        -
        12873  result += m_Blocks[i]->m_pMetadata->GetAllocationCount();
        -
        12874  }
        -
        12875  return result;
        -
        12876 }
        -
        12877 
        -
        12878 bool VmaBlockVector::IsBufferImageGranularityConflictPossible() const
        -
        12879 {
        -
        12880  if(m_BufferImageGranularity == 1)
        -
        12881  {
        -
        12882  return false;
        -
        12883  }
        -
        12884  VmaSuballocationType lastSuballocType = VMA_SUBALLOCATION_TYPE_FREE;
        -
        12885  for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)
        -
        12886  {
        -
        12887  VmaDeviceMemoryBlock* const pBlock = m_Blocks[i];
        -
        12888  VMA_ASSERT(m_Algorithm == 0);
        -
        12889  VmaBlockMetadata_Generic* const pMetadata = (VmaBlockMetadata_Generic*)pBlock->m_pMetadata;
        -
        12890  if(pMetadata->IsBufferImageGranularityConflictPossible(m_BufferImageGranularity, lastSuballocType))
        -
        12891  {
        -
        12892  return true;
        -
        12893  }
        -
        12894  }
        -
        12895  return false;
        -
        12896 }
        -
        12897 
        -
        12898 void VmaBlockVector::MakePoolAllocationsLost(
        -
        12899  uint32_t currentFrameIndex,
        -
        12900  size_t* pLostAllocationCount)
        -
        12901 {
        -
        12902  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
        -
        12903  size_t lostAllocationCount = 0;
        -
        12904  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        -
        12905  {
        -
        12906  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        -
        12907  VMA_ASSERT(pBlock);
        -
        12908  lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
        -
        12909  }
        -
        12910  if(pLostAllocationCount != VMA_NULL)
        -
        12911  {
        -
        12912  *pLostAllocationCount = lostAllocationCount;
        -
        12913  }
        -
        12914 }
        -
        12915 
        -
        12916 VkResult VmaBlockVector::CheckCorruption()
        -
        12917 {
        -
        12918  if(!IsCorruptionDetectionEnabled())
        -
        12919  {
        -
        12920  return VK_ERROR_FEATURE_NOT_PRESENT;
        -
        12921  }
        -
        12922 
        -
        12923  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        -
        12924  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        -
        12925  {
        -
        12926  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        -
        12927  VMA_ASSERT(pBlock);
        -
        12928  VkResult res = pBlock->CheckCorruption(m_hAllocator);
        -
        12929  if(res != VK_SUCCESS)
        -
        12930  {
        -
        12931  return res;
        -
        12932  }
        -
        12933  }
        -
        12934  return VK_SUCCESS;
        -
        12935 }
        -
        12936 
        -
        12937 void VmaBlockVector::AddStats(VmaStats* pStats)
        -
        12938 {
        -
        12939  const uint32_t memTypeIndex = m_MemoryTypeIndex;
        -
        12940  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
        -
        12941 
        -
        12942  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        -
        12943 
        -
        12944  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        -
        12945  {
        -
        12946  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        -
        12947  VMA_ASSERT(pBlock);
        -
        12948  VMA_HEAVY_ASSERT(pBlock->Validate());
        -
        12949  VmaStatInfo allocationStatInfo;
        -
        12950  pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);
        -
        12951  VmaAddStatInfo(pStats->total, allocationStatInfo);
        -
        12952  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        -
        12953  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        -
        12954  }
        -
        12955 }
        -
        12956 
        -
        12958 // VmaDefragmentationAlgorithm_Generic members definition
        -
        12959 
        -
        12960 VmaDefragmentationAlgorithm_Generic::VmaDefragmentationAlgorithm_Generic(
        -
        12961  VmaAllocator hAllocator,
        -
        12962  VmaBlockVector* pBlockVector,
        -
        12963  uint32_t currentFrameIndex,
        -
        12964  bool overlappingMoveSupported) :
        -
        12965  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
        -
        12966  m_AllocationCount(0),
        -
        12967  m_AllAllocations(false),
        -
        12968  m_BytesMoved(0),
        -
        12969  m_AllocationsMoved(0),
        -
        12970  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
        -
        12971 {
        -
        12972  // Create block info for each block.
        -
        12973  const size_t blockCount = m_pBlockVector->m_Blocks.size();
        -
        12974  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        -
        12975  {
        -
        12976  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
        -
        12977  pBlockInfo->m_OriginalBlockIndex = blockIndex;
        -
        12978  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
        -
        12979  m_Blocks.push_back(pBlockInfo);
        -
        12980  }
        -
        12981 
        -
        12982  // Sort them by m_pBlock pointer value.
        -
        12983  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
        -
        12984 }
        -
        12985 
        -
        12986 VmaDefragmentationAlgorithm_Generic::~VmaDefragmentationAlgorithm_Generic()
        -
        12987 {
        -
        12988  for(size_t i = m_Blocks.size(); i--; )
        -
        12989  {
        -
        12990  vma_delete(m_hAllocator, m_Blocks[i]);
        -
        12991  }
        -
        12992 }
        -
        12993 
        -
        12994 void VmaDefragmentationAlgorithm_Generic::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        -
        12995 {
        -
        12996  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
        -
        12997  if(hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        -
        12998  {
        -
        12999  VmaDeviceMemoryBlock* pBlock = hAlloc->GetBlock();
        -
        13000  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
        -
        13001  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
        -
        13002  {
        -
        13003  AllocationInfo allocInfo = AllocationInfo(hAlloc, pChanged);
        -
        13004  (*it)->m_Allocations.push_back(allocInfo);
        -
        13005  }
        -
        13006  else
        -
        13007  {
        -
        13008  VMA_ASSERT(0);
        -
        13009  }
        -
        13010 
        -
        13011  ++m_AllocationCount;
        +
        12798  const bool canDefragmentOnCpu = maxCpuBytesToMove > 0 && maxCpuAllocationsToMove > 0 &&
        +
        12799  isHostVisible;
        +
        12800  const bool canDefragmentOnGpu = maxGpuBytesToMove > 0 && maxGpuAllocationsToMove > 0 &&
        +
        12801  !IsCorruptionDetectionEnabled() &&
        +
        12802  ((1u << m_MemoryTypeIndex) & m_hAllocator->GetGpuDefragmentationMemoryTypeBits()) != 0;
        +
        12803 
        +
        12804  // There are options to defragment this memory type.
        +
        12805  if(canDefragmentOnCpu || canDefragmentOnGpu)
        +
        12806  {
        +
        12807  bool defragmentOnGpu;
        +
        12808  // There is only one option to defragment this memory type.
        +
        12809  if(canDefragmentOnGpu != canDefragmentOnCpu)
        +
        12810  {
        +
        12811  defragmentOnGpu = canDefragmentOnGpu;
        +
        12812  }
        +
        12813  // Both options are available: Heuristics to choose the best one.
        +
        12814  else
        +
        12815  {
        +
        12816  defragmentOnGpu = (memPropFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0 ||
        +
        12817  m_hAllocator->IsIntegratedGpu();
        +
        12818  }
        +
        12819 
        +
        12820  bool overlappingMoveSupported = !defragmentOnGpu;
        +
        12821 
        +
        12822  if(m_hAllocator->m_UseMutex)
        +
        12823  {
        +
        12824  m_Mutex.LockWrite();
        +
        12825  pCtx->mutexLocked = true;
        +
        12826  }
        +
        12827 
        +
        12828  pCtx->Begin(overlappingMoveSupported);
        +
        12829 
        +
        12830  // Defragment.
        +
        12831 
        +
        12832  const VkDeviceSize maxBytesToMove = defragmentOnGpu ? maxGpuBytesToMove : maxCpuBytesToMove;
        +
        12833  const uint32_t maxAllocationsToMove = defragmentOnGpu ? maxGpuAllocationsToMove : maxCpuAllocationsToMove;
        +
        12834  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> > moves =
        +
        12835  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >(VmaStlAllocator<VmaDefragmentationMove>(m_hAllocator->GetAllocationCallbacks()));
        +
        12836  pCtx->res = pCtx->GetAlgorithm()->Defragment(moves, maxBytesToMove, maxAllocationsToMove);
        +
        12837 
        +
        12838  // Accumulate statistics.
        +
        12839  if(pStats != VMA_NULL)
        +
        12840  {
        +
        12841  const VkDeviceSize bytesMoved = pCtx->GetAlgorithm()->GetBytesMoved();
        +
        12842  const uint32_t allocationsMoved = pCtx->GetAlgorithm()->GetAllocationsMoved();
        +
        12843  pStats->bytesMoved += bytesMoved;
        +
        12844  pStats->allocationsMoved += allocationsMoved;
        +
        12845  VMA_ASSERT(bytesMoved <= maxBytesToMove);
        +
        12846  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
        +
        12847  if(defragmentOnGpu)
        +
        12848  {
        +
        12849  maxGpuBytesToMove -= bytesMoved;
        +
        12850  maxGpuAllocationsToMove -= allocationsMoved;
        +
        12851  }
        +
        12852  else
        +
        12853  {
        +
        12854  maxCpuBytesToMove -= bytesMoved;
        +
        12855  maxCpuAllocationsToMove -= allocationsMoved;
        +
        12856  }
        +
        12857  }
        +
        12858 
        +
        12859  if(pCtx->res >= VK_SUCCESS)
        +
        12860  {
        +
        12861  if(defragmentOnGpu)
        +
        12862  {
        +
        12863  ApplyDefragmentationMovesGpu(pCtx, moves, commandBuffer);
        +
        12864  }
        +
        12865  else
        +
        12866  {
        +
        12867  ApplyDefragmentationMovesCpu(pCtx, moves);
        +
        12868  }
        +
        12869  }
        +
        12870  }
        +
        12871 }
        +
        12872 
        +
        12873 void VmaBlockVector::DefragmentationEnd(
        +
        12874  class VmaBlockVectorDefragmentationContext* pCtx,
        +
        12875  VmaDefragmentationStats* pStats)
        +
        12876 {
        +
        12877  // Destroy buffers.
        +
        12878  for(size_t blockIndex = pCtx->blockContexts.size(); blockIndex--; )
        +
        12879  {
        +
        12880  VmaBlockDefragmentationContext& blockCtx = pCtx->blockContexts[blockIndex];
        +
        12881  if(blockCtx.hBuffer)
        +
        12882  {
        +
        12883  (*m_hAllocator->GetVulkanFunctions().vkDestroyBuffer)(
        +
        12884  m_hAllocator->m_hDevice, blockCtx.hBuffer, m_hAllocator->GetAllocationCallbacks());
        +
        12885  }
        +
        12886  }
        +
        12887 
        +
        12888  if(pCtx->res >= VK_SUCCESS)
        +
        12889  {
        +
        12890  FreeEmptyBlocks(pStats);
        +
        12891  }
        +
        12892 
        +
        12893  if(pCtx->mutexLocked)
        +
        12894  {
        +
        12895  VMA_ASSERT(m_hAllocator->m_UseMutex);
        +
        12896  m_Mutex.UnlockWrite();
        +
        12897  }
        +
        12898 }
        +
        12899 
        +
        12900 size_t VmaBlockVector::CalcAllocationCount() const
        +
        12901 {
        +
        12902  size_t result = 0;
        +
        12903  for(size_t i = 0; i < m_Blocks.size(); ++i)
        +
        12904  {
        +
        12905  result += m_Blocks[i]->m_pMetadata->GetAllocationCount();
        +
        12906  }
        +
        12907  return result;
        +
        12908 }
        +
        12909 
        +
        12910 bool VmaBlockVector::IsBufferImageGranularityConflictPossible() const
        +
        12911 {
        +
        12912  if(m_BufferImageGranularity == 1)
        +
        12913  {
        +
        12914  return false;
        +
        12915  }
        +
        12916  VmaSuballocationType lastSuballocType = VMA_SUBALLOCATION_TYPE_FREE;
        +
        12917  for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)
        +
        12918  {
        +
        12919  VmaDeviceMemoryBlock* const pBlock = m_Blocks[i];
        +
        12920  VMA_ASSERT(m_Algorithm == 0);
        +
        12921  VmaBlockMetadata_Generic* const pMetadata = (VmaBlockMetadata_Generic*)pBlock->m_pMetadata;
        +
        12922  if(pMetadata->IsBufferImageGranularityConflictPossible(m_BufferImageGranularity, lastSuballocType))
        +
        12923  {
        +
        12924  return true;
        +
        12925  }
        +
        12926  }
        +
        12927  return false;
        +
        12928 }
        +
        12929 
        +
        12930 void VmaBlockVector::MakePoolAllocationsLost(
        +
        12931  uint32_t currentFrameIndex,
        +
        12932  size_t* pLostAllocationCount)
        +
        12933 {
        +
        12934  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
        +
        12935  size_t lostAllocationCount = 0;
        +
        12936  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        +
        12937  {
        +
        12938  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        +
        12939  VMA_ASSERT(pBlock);
        +
        12940  lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
        +
        12941  }
        +
        12942  if(pLostAllocationCount != VMA_NULL)
        +
        12943  {
        +
        12944  *pLostAllocationCount = lostAllocationCount;
        +
        12945  }
        +
        12946 }
        +
        12947 
        +
        12948 VkResult VmaBlockVector::CheckCorruption()
        +
        12949 {
        +
        12950  if(!IsCorruptionDetectionEnabled())
        +
        12951  {
        +
        12952  return VK_ERROR_FEATURE_NOT_PRESENT;
        +
        12953  }
        +
        12954 
        +
        12955  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        +
        12956  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        +
        12957  {
        +
        12958  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        +
        12959  VMA_ASSERT(pBlock);
        +
        12960  VkResult res = pBlock->CheckCorruption(m_hAllocator);
        +
        12961  if(res != VK_SUCCESS)
        +
        12962  {
        +
        12963  return res;
        +
        12964  }
        +
        12965  }
        +
        12966  return VK_SUCCESS;
        +
        12967 }
        +
        12968 
        +
        12969 void VmaBlockVector::AddStats(VmaStats* pStats)
        +
        12970 {
        +
        12971  const uint32_t memTypeIndex = m_MemoryTypeIndex;
        +
        12972  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
        +
        12973 
        +
        12974  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
        +
        12975 
        +
        12976  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        +
        12977  {
        +
        12978  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        +
        12979  VMA_ASSERT(pBlock);
        +
        12980  VMA_HEAVY_ASSERT(pBlock->Validate());
        +
        12981  VmaStatInfo allocationStatInfo;
        +
        12982  pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);
        +
        12983  VmaAddStatInfo(pStats->total, allocationStatInfo);
        +
        12984  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        +
        12985  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        +
        12986  }
        +
        12987 }
        +
        12988 
        +
        12990 // VmaDefragmentationAlgorithm_Generic members definition
        +
        12991 
        +
        12992 VmaDefragmentationAlgorithm_Generic::VmaDefragmentationAlgorithm_Generic(
        +
        12993  VmaAllocator hAllocator,
        +
        12994  VmaBlockVector* pBlockVector,
        +
        12995  uint32_t currentFrameIndex,
        +
        12996  bool overlappingMoveSupported) :
        +
        12997  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
        +
        12998  m_AllocationCount(0),
        +
        12999  m_AllAllocations(false),
        +
        13000  m_BytesMoved(0),
        +
        13001  m_AllocationsMoved(0),
        +
        13002  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
        +
        13003 {
        +
        13004  // Create block info for each block.
        +
        13005  const size_t blockCount = m_pBlockVector->m_Blocks.size();
        +
        13006  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        +
        13007  {
        +
        13008  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
        +
        13009  pBlockInfo->m_OriginalBlockIndex = blockIndex;
        +
        13010  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
        +
        13011  m_Blocks.push_back(pBlockInfo);
        13012  }
        -
        13013 }
        -
        13014 
        -
        13015 VkResult VmaDefragmentationAlgorithm_Generic::DefragmentRound(
        -
        13016  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        13017  VkDeviceSize maxBytesToMove,
        -
        13018  uint32_t maxAllocationsToMove)
        +
        13013 
        +
        13014  // Sort them by m_pBlock pointer value.
        +
        13015  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
        +
        13016 }
        +
        13017 
        +
        13018 VmaDefragmentationAlgorithm_Generic::~VmaDefragmentationAlgorithm_Generic()
        13019 {
        -
        13020  if(m_Blocks.empty())
        +
        13020  for(size_t i = m_Blocks.size(); i--; )
        13021  {
        -
        13022  return VK_SUCCESS;
        +
        13022  vma_delete(m_hAllocator, m_Blocks[i]);
        13023  }
        -
        13024 
        -
        13025  // This is a choice based on research.
        -
        13026  // Option 1:
        -
        13027  uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT;
        -
        13028  // Option 2:
        -
        13029  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT;
        -
        13030  // Option 3:
        -
        13031  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT;
        -
        13032 
        -
        13033  size_t srcBlockMinIndex = 0;
        -
        13034  // When FAST_ALGORITHM, move allocations from only last out of blocks that contain non-movable allocations.
        -
        13035  /*
        -
        13036  if(m_AlgorithmFlags & VMA_DEFRAGMENTATION_FAST_ALGORITHM_BIT)
        -
        13037  {
        -
        13038  const size_t blocksWithNonMovableCount = CalcBlocksWithNonMovableCount();
        -
        13039  if(blocksWithNonMovableCount > 0)
        -
        13040  {
        -
        13041  srcBlockMinIndex = blocksWithNonMovableCount - 1;
        -
        13042  }
        -
        13043  }
        -
        13044  */
        -
        13045 
        -
        13046  size_t srcBlockIndex = m_Blocks.size() - 1;
        -
        13047  size_t srcAllocIndex = SIZE_MAX;
        -
        13048  for(;;)
        -
        13049  {
        -
        13050  // 1. Find next allocation to move.
        -
        13051  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
        -
        13052  // 1.2. Then start from last to first m_Allocations.
        -
        13053  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
        -
        13054  {
        -
        13055  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
        -
        13056  {
        -
        13057  // Finished: no more allocations to process.
        -
        13058  if(srcBlockIndex == srcBlockMinIndex)
        -
        13059  {
        -
        13060  return VK_SUCCESS;
        -
        13061  }
        -
        13062  else
        -
        13063  {
        -
        13064  --srcBlockIndex;
        -
        13065  srcAllocIndex = SIZE_MAX;
        -
        13066  }
        -
        13067  }
        -
        13068  else
        -
        13069  {
        -
        13070  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
        -
        13071  }
        -
        13072  }
        -
        13073 
        -
        13074  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
        -
        13075  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
        -
        13076 
        -
        13077  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
        -
        13078  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
        -
        13079  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
        -
        13080  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
        -
        13081 
        -
        13082  // 2. Try to find new place for this allocation in preceding or current block.
        -
        13083  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
        -
        13084  {
        -
        13085  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
        -
        13086  VmaAllocationRequest dstAllocRequest;
        -
        13087  if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(
        -
        13088  m_CurrentFrameIndex,
        -
        13089  m_pBlockVector->GetFrameInUseCount(),
        -
        13090  m_pBlockVector->GetBufferImageGranularity(),
        -
        13091  size,
        -
        13092  alignment,
        -
        13093  false, // upperAddress
        -
        13094  suballocType,
        -
        13095  false, // canMakeOtherLost
        -
        13096  strategy,
        -
        13097  &dstAllocRequest) &&
        -
        13098  MoveMakesSense(
        -
        13099  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
        -
        13100  {
        -
        13101  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
        -
        13102 
        -
        13103  // Reached limit on number of allocations or bytes to move.
        -
        13104  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
        -
        13105  (m_BytesMoved + size > maxBytesToMove))
        -
        13106  {
        -
        13107  return VK_SUCCESS;
        -
        13108  }
        -
        13109 
        -
        13110  VmaDefragmentationMove move;
        -
        13111  move.srcBlockIndex = pSrcBlockInfo->m_OriginalBlockIndex;
        -
        13112  move.dstBlockIndex = pDstBlockInfo->m_OriginalBlockIndex;
        -
        13113  move.srcOffset = srcOffset;
        -
        13114  move.dstOffset = dstAllocRequest.offset;
        -
        13115  move.size = size;
        -
        13116  moves.push_back(move);
        -
        13117 
        -
        13118  pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(
        -
        13119  dstAllocRequest,
        -
        13120  suballocType,
        -
        13121  size,
        -
        13122  allocInfo.m_hAllocation);
        -
        13123  pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);
        -
        13124 
        -
        13125  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
        -
        13126 
        -
        13127  if(allocInfo.m_pChanged != VMA_NULL)
        -
        13128  {
        -
        13129  *allocInfo.m_pChanged = VK_TRUE;
        -
        13130  }
        -
        13131 
        -
        13132  ++m_AllocationsMoved;
        -
        13133  m_BytesMoved += size;
        +
        13024 }
        +
        13025 
        +
        13026 void VmaDefragmentationAlgorithm_Generic::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        +
        13027 {
        +
        13028  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
        +
        13029  if(hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        +
        13030  {
        +
        13031  VmaDeviceMemoryBlock* pBlock = hAlloc->GetBlock();
        +
        13032  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
        +
        13033  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
        +
        13034  {
        +
        13035  AllocationInfo allocInfo = AllocationInfo(hAlloc, pChanged);
        +
        13036  (*it)->m_Allocations.push_back(allocInfo);
        +
        13037  }
        +
        13038  else
        +
        13039  {
        +
        13040  VMA_ASSERT(0);
        +
        13041  }
        +
        13042 
        +
        13043  ++m_AllocationCount;
        +
        13044  }
        +
        13045 }
        +
        13046 
        +
        13047 VkResult VmaDefragmentationAlgorithm_Generic::DefragmentRound(
        +
        13048  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        13049  VkDeviceSize maxBytesToMove,
        +
        13050  uint32_t maxAllocationsToMove)
        +
        13051 {
        +
        13052  if(m_Blocks.empty())
        +
        13053  {
        +
        13054  return VK_SUCCESS;
        +
        13055  }
        +
        13056 
        +
        13057  // This is a choice based on research.
        +
        13058  // Option 1:
        +
        13059  uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT;
        +
        13060  // Option 2:
        +
        13061  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT;
        +
        13062  // Option 3:
        +
        13063  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT;
        +
        13064 
        +
        13065  size_t srcBlockMinIndex = 0;
        +
        13066  // When FAST_ALGORITHM, move allocations from only last out of blocks that contain non-movable allocations.
        +
        13067  /*
        +
        13068  if(m_AlgorithmFlags & VMA_DEFRAGMENTATION_FAST_ALGORITHM_BIT)
        +
        13069  {
        +
        13070  const size_t blocksWithNonMovableCount = CalcBlocksWithNonMovableCount();
        +
        13071  if(blocksWithNonMovableCount > 0)
        +
        13072  {
        +
        13073  srcBlockMinIndex = blocksWithNonMovableCount - 1;
        +
        13074  }
        +
        13075  }
        +
        13076  */
        +
        13077 
        +
        13078  size_t srcBlockIndex = m_Blocks.size() - 1;
        +
        13079  size_t srcAllocIndex = SIZE_MAX;
        +
        13080  for(;;)
        +
        13081  {
        +
        13082  // 1. Find next allocation to move.
        +
        13083  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
        +
        13084  // 1.2. Then start from last to first m_Allocations.
        +
        13085  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
        +
        13086  {
        +
        13087  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
        +
        13088  {
        +
        13089  // Finished: no more allocations to process.
        +
        13090  if(srcBlockIndex == srcBlockMinIndex)
        +
        13091  {
        +
        13092  return VK_SUCCESS;
        +
        13093  }
        +
        13094  else
        +
        13095  {
        +
        13096  --srcBlockIndex;
        +
        13097  srcAllocIndex = SIZE_MAX;
        +
        13098  }
        +
        13099  }
        +
        13100  else
        +
        13101  {
        +
        13102  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
        +
        13103  }
        +
        13104  }
        +
        13105 
        +
        13106  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
        +
        13107  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
        +
        13108 
        +
        13109  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
        +
        13110  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
        +
        13111  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
        +
        13112  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
        +
        13113 
        +
        13114  // 2. Try to find new place for this allocation in preceding or current block.
        +
        13115  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
        +
        13116  {
        +
        13117  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
        +
        13118  VmaAllocationRequest dstAllocRequest;
        +
        13119  if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(
        +
        13120  m_CurrentFrameIndex,
        +
        13121  m_pBlockVector->GetFrameInUseCount(),
        +
        13122  m_pBlockVector->GetBufferImageGranularity(),
        +
        13123  size,
        +
        13124  alignment,
        +
        13125  false, // upperAddress
        +
        13126  suballocType,
        +
        13127  false, // canMakeOtherLost
        +
        13128  strategy,
        +
        13129  &dstAllocRequest) &&
        +
        13130  MoveMakesSense(
        +
        13131  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
        +
        13132  {
        +
        13133  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
        13134 
        -
        13135  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
        -
        13136 
        -
        13137  break;
        -
        13138  }
        -
        13139  }
        -
        13140 
        -
        13141  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
        -
        13142 
        -
        13143  if(srcAllocIndex > 0)
        -
        13144  {
        -
        13145  --srcAllocIndex;
        -
        13146  }
        -
        13147  else
        -
        13148  {
        -
        13149  if(srcBlockIndex > 0)
        -
        13150  {
        -
        13151  --srcBlockIndex;
        -
        13152  srcAllocIndex = SIZE_MAX;
        -
        13153  }
        -
        13154  else
        -
        13155  {
        -
        13156  return VK_SUCCESS;
        -
        13157  }
        -
        13158  }
        -
        13159  }
        -
        13160 }
        -
        13161 
        -
        13162 size_t VmaDefragmentationAlgorithm_Generic::CalcBlocksWithNonMovableCount() const
        -
        13163 {
        -
        13164  size_t result = 0;
        -
        13165  for(size_t i = 0; i < m_Blocks.size(); ++i)
        -
        13166  {
        -
        13167  if(m_Blocks[i]->m_HasNonMovableAllocations)
        -
        13168  {
        -
        13169  ++result;
        -
        13170  }
        -
        13171  }
        -
        13172  return result;
        -
        13173 }
        +
        13135  // Reached limit on number of allocations or bytes to move.
        +
        13136  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
        +
        13137  (m_BytesMoved + size > maxBytesToMove))
        +
        13138  {
        +
        13139  return VK_SUCCESS;
        +
        13140  }
        +
        13141 
        +
        13142  VmaDefragmentationMove move;
        +
        13143  move.srcBlockIndex = pSrcBlockInfo->m_OriginalBlockIndex;
        +
        13144  move.dstBlockIndex = pDstBlockInfo->m_OriginalBlockIndex;
        +
        13145  move.srcOffset = srcOffset;
        +
        13146  move.dstOffset = dstAllocRequest.offset;
        +
        13147  move.size = size;
        +
        13148  moves.push_back(move);
        +
        13149 
        +
        13150  pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(
        +
        13151  dstAllocRequest,
        +
        13152  suballocType,
        +
        13153  size,
        +
        13154  allocInfo.m_hAllocation);
        +
        13155  pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);
        +
        13156 
        +
        13157  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
        +
        13158 
        +
        13159  if(allocInfo.m_pChanged != VMA_NULL)
        +
        13160  {
        +
        13161  *allocInfo.m_pChanged = VK_TRUE;
        +
        13162  }
        +
        13163 
        +
        13164  ++m_AllocationsMoved;
        +
        13165  m_BytesMoved += size;
        +
        13166 
        +
        13167  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
        +
        13168 
        +
        13169  break;
        +
        13170  }
        +
        13171  }
        +
        13172 
        +
        13173  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
        13174 
        -
        13175 VkResult VmaDefragmentationAlgorithm_Generic::Defragment(
        -
        13176  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        13177  VkDeviceSize maxBytesToMove,
        -
        13178  uint32_t maxAllocationsToMove)
        -
        13179 {
        -
        13180  if(!m_AllAllocations && m_AllocationCount == 0)
        -
        13181  {
        -
        13182  return VK_SUCCESS;
        -
        13183  }
        -
        13184 
        -
        13185  const size_t blockCount = m_Blocks.size();
        -
        13186  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        -
        13187  {
        -
        13188  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
        -
        13189 
        -
        13190  if(m_AllAllocations)
        -
        13191  {
        -
        13192  VmaBlockMetadata_Generic* pMetadata = (VmaBlockMetadata_Generic*)pBlockInfo->m_pBlock->m_pMetadata;
        -
        13193  for(VmaSuballocationList::const_iterator it = pMetadata->m_Suballocations.begin();
        -
        13194  it != pMetadata->m_Suballocations.end();
        -
        13195  ++it)
        -
        13196  {
        -
        13197  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        -
        13198  {
        -
        13199  AllocationInfo allocInfo = AllocationInfo(it->hAllocation, VMA_NULL);
        -
        13200  pBlockInfo->m_Allocations.push_back(allocInfo);
        -
        13201  }
        -
        13202  }
        -
        13203  }
        -
        13204 
        -
        13205  pBlockInfo->CalcHasNonMovableAllocations();
        -
        13206 
        -
        13207  // This is a choice based on research.
        -
        13208  // Option 1:
        -
        13209  pBlockInfo->SortAllocationsByOffsetDescending();
        -
        13210  // Option 2:
        -
        13211  //pBlockInfo->SortAllocationsBySizeDescending();
        -
        13212  }
        -
        13213 
        -
        13214  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
        -
        13215  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
        +
        13175  if(srcAllocIndex > 0)
        +
        13176  {
        +
        13177  --srcAllocIndex;
        +
        13178  }
        +
        13179  else
        +
        13180  {
        +
        13181  if(srcBlockIndex > 0)
        +
        13182  {
        +
        13183  --srcBlockIndex;
        +
        13184  srcAllocIndex = SIZE_MAX;
        +
        13185  }
        +
        13186  else
        +
        13187  {
        +
        13188  return VK_SUCCESS;
        +
        13189  }
        +
        13190  }
        +
        13191  }
        +
        13192 }
        +
        13193 
        +
        13194 size_t VmaDefragmentationAlgorithm_Generic::CalcBlocksWithNonMovableCount() const
        +
        13195 {
        +
        13196  size_t result = 0;
        +
        13197  for(size_t i = 0; i < m_Blocks.size(); ++i)
        +
        13198  {
        +
        13199  if(m_Blocks[i]->m_HasNonMovableAllocations)
        +
        13200  {
        +
        13201  ++result;
        +
        13202  }
        +
        13203  }
        +
        13204  return result;
        +
        13205 }
        +
        13206 
        +
        13207 VkResult VmaDefragmentationAlgorithm_Generic::Defragment(
        +
        13208  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        13209  VkDeviceSize maxBytesToMove,
        +
        13210  uint32_t maxAllocationsToMove)
        +
        13211 {
        +
        13212  if(!m_AllAllocations && m_AllocationCount == 0)
        +
        13213  {
        +
        13214  return VK_SUCCESS;
        +
        13215  }
        13216 
        -
        13217  // This is a choice based on research.
        -
        13218  const uint32_t roundCount = 2;
        -
        13219 
        -
        13220  // Execute defragmentation rounds (the main part).
        -
        13221  VkResult result = VK_SUCCESS;
        -
        13222  for(uint32_t round = 0; (round < roundCount) && (result == VK_SUCCESS); ++round)
        -
        13223  {
        -
        13224  result = DefragmentRound(moves, maxBytesToMove, maxAllocationsToMove);
        -
        13225  }
        -
        13226 
        -
        13227  return result;
        -
        13228 }
        -
        13229 
        -
        13230 bool VmaDefragmentationAlgorithm_Generic::MoveMakesSense(
        -
        13231  size_t dstBlockIndex, VkDeviceSize dstOffset,
        -
        13232  size_t srcBlockIndex, VkDeviceSize srcOffset)
        -
        13233 {
        -
        13234  if(dstBlockIndex < srcBlockIndex)
        -
        13235  {
        -
        13236  return true;
        -
        13237  }
        -
        13238  if(dstBlockIndex > srcBlockIndex)
        -
        13239  {
        -
        13240  return false;
        -
        13241  }
        -
        13242  if(dstOffset < srcOffset)
        -
        13243  {
        -
        13244  return true;
        -
        13245  }
        -
        13246  return false;
        -
        13247 }
        +
        13217  const size_t blockCount = m_Blocks.size();
        +
        13218  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        +
        13219  {
        +
        13220  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
        +
        13221 
        +
        13222  if(m_AllAllocations)
        +
        13223  {
        +
        13224  VmaBlockMetadata_Generic* pMetadata = (VmaBlockMetadata_Generic*)pBlockInfo->m_pBlock->m_pMetadata;
        +
        13225  for(VmaSuballocationList::const_iterator it = pMetadata->m_Suballocations.begin();
        +
        13226  it != pMetadata->m_Suballocations.end();
        +
        13227  ++it)
        +
        13228  {
        +
        13229  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        +
        13230  {
        +
        13231  AllocationInfo allocInfo = AllocationInfo(it->hAllocation, VMA_NULL);
        +
        13232  pBlockInfo->m_Allocations.push_back(allocInfo);
        +
        13233  }
        +
        13234  }
        +
        13235  }
        +
        13236 
        +
        13237  pBlockInfo->CalcHasNonMovableAllocations();
        +
        13238 
        +
        13239  // This is a choice based on research.
        +
        13240  // Option 1:
        +
        13241  pBlockInfo->SortAllocationsByOffsetDescending();
        +
        13242  // Option 2:
        +
        13243  //pBlockInfo->SortAllocationsBySizeDescending();
        +
        13244  }
        +
        13245 
        +
        13246  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
        +
        13247  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
        13248 
        -
        13250 // VmaDefragmentationAlgorithm_Fast
        +
        13249  // This is a choice based on research.
        +
        13250  const uint32_t roundCount = 2;
        13251 
        -
        13252 VmaDefragmentationAlgorithm_Fast::VmaDefragmentationAlgorithm_Fast(
        -
        13253  VmaAllocator hAllocator,
        -
        13254  VmaBlockVector* pBlockVector,
        -
        13255  uint32_t currentFrameIndex,
        -
        13256  bool overlappingMoveSupported) :
        -
        13257  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
        -
        13258  m_OverlappingMoveSupported(overlappingMoveSupported),
        -
        13259  m_AllocationCount(0),
        -
        13260  m_AllAllocations(false),
        -
        13261  m_BytesMoved(0),
        -
        13262  m_AllocationsMoved(0),
        -
        13263  m_BlockInfos(VmaStlAllocator<BlockInfo>(hAllocator->GetAllocationCallbacks()))
        -
        13264 {
        -
        13265  VMA_ASSERT(VMA_DEBUG_MARGIN == 0);
        -
        13266 
        -
        13267 }
        -
        13268 
        -
        13269 VmaDefragmentationAlgorithm_Fast::~VmaDefragmentationAlgorithm_Fast()
        -
        13270 {
        -
        13271 }
        -
        13272 
        -
        13273 VkResult VmaDefragmentationAlgorithm_Fast::Defragment(
        -
        13274  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        -
        13275  VkDeviceSize maxBytesToMove,
        -
        13276  uint32_t maxAllocationsToMove)
        -
        13277 {
        -
        13278  VMA_ASSERT(m_AllAllocations || m_pBlockVector->CalcAllocationCount() == m_AllocationCount);
        -
        13279 
        -
        13280  const size_t blockCount = m_pBlockVector->GetBlockCount();
        -
        13281  if(blockCount == 0 || maxBytesToMove == 0 || maxAllocationsToMove == 0)
        -
        13282  {
        -
        13283  return VK_SUCCESS;
        -
        13284  }
        -
        13285 
        -
        13286  PreprocessMetadata();
        -
        13287 
        -
        13288  // Sort blocks in order from most destination.
        -
        13289 
        -
        13290  m_BlockInfos.resize(blockCount);
        -
        13291  for(size_t i = 0; i < blockCount; ++i)
        -
        13292  {
        -
        13293  m_BlockInfos[i].origBlockIndex = i;
        -
        13294  }
        -
        13295 
        -
        13296  VMA_SORT(m_BlockInfos.begin(), m_BlockInfos.end(), [this](const BlockInfo& lhs, const BlockInfo& rhs) -> bool {
        -
        13297  return m_pBlockVector->GetBlock(lhs.origBlockIndex)->m_pMetadata->GetSumFreeSize() <
        -
        13298  m_pBlockVector->GetBlock(rhs.origBlockIndex)->m_pMetadata->GetSumFreeSize();
        -
        13299  });
        +
        13252  // Execute defragmentation rounds (the main part).
        +
        13253  VkResult result = VK_SUCCESS;
        +
        13254  for(uint32_t round = 0; (round < roundCount) && (result == VK_SUCCESS); ++round)
        +
        13255  {
        +
        13256  result = DefragmentRound(moves, maxBytesToMove, maxAllocationsToMove);
        +
        13257  }
        +
        13258 
        +
        13259  return result;
        +
        13260 }
        +
        13261 
        +
        13262 bool VmaDefragmentationAlgorithm_Generic::MoveMakesSense(
        +
        13263  size_t dstBlockIndex, VkDeviceSize dstOffset,
        +
        13264  size_t srcBlockIndex, VkDeviceSize srcOffset)
        +
        13265 {
        +
        13266  if(dstBlockIndex < srcBlockIndex)
        +
        13267  {
        +
        13268  return true;
        +
        13269  }
        +
        13270  if(dstBlockIndex > srcBlockIndex)
        +
        13271  {
        +
        13272  return false;
        +
        13273  }
        +
        13274  if(dstOffset < srcOffset)
        +
        13275  {
        +
        13276  return true;
        +
        13277  }
        +
        13278  return false;
        +
        13279 }
        +
        13280 
        +
        13282 // VmaDefragmentationAlgorithm_Fast
        +
        13283 
        +
        13284 VmaDefragmentationAlgorithm_Fast::VmaDefragmentationAlgorithm_Fast(
        +
        13285  VmaAllocator hAllocator,
        +
        13286  VmaBlockVector* pBlockVector,
        +
        13287  uint32_t currentFrameIndex,
        +
        13288  bool overlappingMoveSupported) :
        +
        13289  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
        +
        13290  m_OverlappingMoveSupported(overlappingMoveSupported),
        +
        13291  m_AllocationCount(0),
        +
        13292  m_AllAllocations(false),
        +
        13293  m_BytesMoved(0),
        +
        13294  m_AllocationsMoved(0),
        +
        13295  m_BlockInfos(VmaStlAllocator<BlockInfo>(hAllocator->GetAllocationCallbacks()))
        +
        13296 {
        +
        13297  VMA_ASSERT(VMA_DEBUG_MARGIN == 0);
        +
        13298 
        +
        13299 }
        13300 
        -
        13301  // THE MAIN ALGORITHM
        -
        13302 
        -
        13303  FreeSpaceDatabase freeSpaceDb;
        +
        13301 VmaDefragmentationAlgorithm_Fast::~VmaDefragmentationAlgorithm_Fast()
        +
        13302 {
        +
        13303 }
        13304 
        -
        13305  size_t dstBlockInfoIndex = 0;
        -
        13306  size_t dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
        -
        13307  VmaDeviceMemoryBlock* pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
        -
        13308  VmaBlockMetadata_Generic* pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
        -
        13309  VkDeviceSize dstBlockSize = pDstMetadata->GetSize();
        -
        13310  VkDeviceSize dstOffset = 0;
        +
        13305 VkResult VmaDefragmentationAlgorithm_Fast::Defragment(
        +
        13306  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
        +
        13307  VkDeviceSize maxBytesToMove,
        +
        13308  uint32_t maxAllocationsToMove)
        +
        13309 {
        +
        13310  VMA_ASSERT(m_AllAllocations || m_pBlockVector->CalcAllocationCount() == m_AllocationCount);
        13311 
        -
        13312  bool end = false;
        -
        13313  for(size_t srcBlockInfoIndex = 0; !end && srcBlockInfoIndex < blockCount; ++srcBlockInfoIndex)
        +
        13312  const size_t blockCount = m_pBlockVector->GetBlockCount();
        +
        13313  if(blockCount == 0 || maxBytesToMove == 0 || maxAllocationsToMove == 0)
        13314  {
        -
        13315  const size_t srcOrigBlockIndex = m_BlockInfos[srcBlockInfoIndex].origBlockIndex;
        -
        13316  VmaDeviceMemoryBlock* const pSrcBlock = m_pBlockVector->GetBlock(srcOrigBlockIndex);
        -
        13317  VmaBlockMetadata_Generic* const pSrcMetadata = (VmaBlockMetadata_Generic*)pSrcBlock->m_pMetadata;
        -
        13318  for(VmaSuballocationList::iterator srcSuballocIt = pSrcMetadata->m_Suballocations.begin();
        -
        13319  !end && srcSuballocIt != pSrcMetadata->m_Suballocations.end(); )
        -
        13320  {
        -
        13321  VmaAllocation_T* const pAlloc = srcSuballocIt->hAllocation;
        -
        13322  const VkDeviceSize srcAllocAlignment = pAlloc->GetAlignment();
        -
        13323  const VkDeviceSize srcAllocSize = srcSuballocIt->size;
        -
        13324  if(m_AllocationsMoved == maxAllocationsToMove ||
        -
        13325  m_BytesMoved + srcAllocSize > maxBytesToMove)
        -
        13326  {
        -
        13327  end = true;
        -
        13328  break;
        -
        13329  }
        -
        13330  const VkDeviceSize srcAllocOffset = srcSuballocIt->offset;
        -
        13331 
        -
        13332  // Try to place it in one of free spaces from the database.
        -
        13333  size_t freeSpaceInfoIndex;
        -
        13334  VkDeviceSize dstAllocOffset;
        -
        13335  if(freeSpaceDb.Fetch(srcAllocAlignment, srcAllocSize,
        -
        13336  freeSpaceInfoIndex, dstAllocOffset))
        -
        13337  {
        -
        13338  size_t freeSpaceOrigBlockIndex = m_BlockInfos[freeSpaceInfoIndex].origBlockIndex;
        -
        13339  VmaDeviceMemoryBlock* pFreeSpaceBlock = m_pBlockVector->GetBlock(freeSpaceOrigBlockIndex);
        -
        13340  VmaBlockMetadata_Generic* pFreeSpaceMetadata = (VmaBlockMetadata_Generic*)pFreeSpaceBlock->m_pMetadata;
        -
        13341 
        -
        13342  // Same block
        -
        13343  if(freeSpaceInfoIndex == srcBlockInfoIndex)
        -
        13344  {
        -
        13345  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
        -
        13346 
        -
        13347  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
        -
        13348 
        -
        13349  VmaSuballocation suballoc = *srcSuballocIt;
        -
        13350  suballoc.offset = dstAllocOffset;
        -
        13351  suballoc.hAllocation->ChangeOffset(dstAllocOffset);
        -
        13352  m_BytesMoved += srcAllocSize;
        -
        13353  ++m_AllocationsMoved;
        -
        13354 
        -
        13355  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
        -
        13356  ++nextSuballocIt;
        -
        13357  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
        -
        13358  srcSuballocIt = nextSuballocIt;
        -
        13359 
        -
        13360  InsertSuballoc(pFreeSpaceMetadata, suballoc);
        -
        13361 
        -
        13362  VmaDefragmentationMove move = {
        -
        13363  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
        -
        13364  srcAllocOffset, dstAllocOffset,
        -
        13365  srcAllocSize };
        -
        13366  moves.push_back(move);
        -
        13367  }
        -
        13368  // Different block
        -
        13369  else
        -
        13370  {
        -
        13371  // MOVE OPTION 2: Move the allocation to a different block.
        -
        13372 
        -
        13373  VMA_ASSERT(freeSpaceInfoIndex < srcBlockInfoIndex);
        -
        13374 
        -
        13375  VmaSuballocation suballoc = *srcSuballocIt;
        -
        13376  suballoc.offset = dstAllocOffset;
        -
        13377  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pFreeSpaceBlock, dstAllocOffset);
        -
        13378  m_BytesMoved += srcAllocSize;
        -
        13379  ++m_AllocationsMoved;
        +
        13315  return VK_SUCCESS;
        +
        13316  }
        +
        13317 
        +
        13318  PreprocessMetadata();
        +
        13319 
        +
        13320  // Sort blocks in order from most destination.
        +
        13321 
        +
        13322  m_BlockInfos.resize(blockCount);
        +
        13323  for(size_t i = 0; i < blockCount; ++i)
        +
        13324  {
        +
        13325  m_BlockInfos[i].origBlockIndex = i;
        +
        13326  }
        +
        13327 
        +
        13328  VMA_SORT(m_BlockInfos.begin(), m_BlockInfos.end(), [this](const BlockInfo& lhs, const BlockInfo& rhs) -> bool {
        +
        13329  return m_pBlockVector->GetBlock(lhs.origBlockIndex)->m_pMetadata->GetSumFreeSize() <
        +
        13330  m_pBlockVector->GetBlock(rhs.origBlockIndex)->m_pMetadata->GetSumFreeSize();
        +
        13331  });
        +
        13332 
        +
        13333  // THE MAIN ALGORITHM
        +
        13334 
        +
        13335  FreeSpaceDatabase freeSpaceDb;
        +
        13336 
        +
        13337  size_t dstBlockInfoIndex = 0;
        +
        13338  size_t dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
        +
        13339  VmaDeviceMemoryBlock* pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
        +
        13340  VmaBlockMetadata_Generic* pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
        +
        13341  VkDeviceSize dstBlockSize = pDstMetadata->GetSize();
        +
        13342  VkDeviceSize dstOffset = 0;
        +
        13343 
        +
        13344  bool end = false;
        +
        13345  for(size_t srcBlockInfoIndex = 0; !end && srcBlockInfoIndex < blockCount; ++srcBlockInfoIndex)
        +
        13346  {
        +
        13347  const size_t srcOrigBlockIndex = m_BlockInfos[srcBlockInfoIndex].origBlockIndex;
        +
        13348  VmaDeviceMemoryBlock* const pSrcBlock = m_pBlockVector->GetBlock(srcOrigBlockIndex);
        +
        13349  VmaBlockMetadata_Generic* const pSrcMetadata = (VmaBlockMetadata_Generic*)pSrcBlock->m_pMetadata;
        +
        13350  for(VmaSuballocationList::iterator srcSuballocIt = pSrcMetadata->m_Suballocations.begin();
        +
        13351  !end && srcSuballocIt != pSrcMetadata->m_Suballocations.end(); )
        +
        13352  {
        +
        13353  VmaAllocation_T* const pAlloc = srcSuballocIt->hAllocation;
        +
        13354  const VkDeviceSize srcAllocAlignment = pAlloc->GetAlignment();
        +
        13355  const VkDeviceSize srcAllocSize = srcSuballocIt->size;
        +
        13356  if(m_AllocationsMoved == maxAllocationsToMove ||
        +
        13357  m_BytesMoved + srcAllocSize > maxBytesToMove)
        +
        13358  {
        +
        13359  end = true;
        +
        13360  break;
        +
        13361  }
        +
        13362  const VkDeviceSize srcAllocOffset = srcSuballocIt->offset;
        +
        13363 
        +
        13364  // Try to place it in one of free spaces from the database.
        +
        13365  size_t freeSpaceInfoIndex;
        +
        13366  VkDeviceSize dstAllocOffset;
        +
        13367  if(freeSpaceDb.Fetch(srcAllocAlignment, srcAllocSize,
        +
        13368  freeSpaceInfoIndex, dstAllocOffset))
        +
        13369  {
        +
        13370  size_t freeSpaceOrigBlockIndex = m_BlockInfos[freeSpaceInfoIndex].origBlockIndex;
        +
        13371  VmaDeviceMemoryBlock* pFreeSpaceBlock = m_pBlockVector->GetBlock(freeSpaceOrigBlockIndex);
        +
        13372  VmaBlockMetadata_Generic* pFreeSpaceMetadata = (VmaBlockMetadata_Generic*)pFreeSpaceBlock->m_pMetadata;
        +
        13373 
        +
        13374  // Same block
        +
        13375  if(freeSpaceInfoIndex == srcBlockInfoIndex)
        +
        13376  {
        +
        13377  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
        +
        13378 
        +
        13379  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
        13380 
        -
        13381  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
        -
        13382  ++nextSuballocIt;
        -
        13383  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
        -
        13384  srcSuballocIt = nextSuballocIt;
        -
        13385 
        -
        13386  InsertSuballoc(pFreeSpaceMetadata, suballoc);
        -
        13387 
        -
        13388  VmaDefragmentationMove move = {
        -
        13389  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
        -
        13390  srcAllocOffset, dstAllocOffset,
        -
        13391  srcAllocSize };
        -
        13392  moves.push_back(move);
        -
        13393  }
        -
        13394  }
        -
        13395  else
        -
        13396  {
        -
        13397  dstAllocOffset = VmaAlignUp(dstOffset, srcAllocAlignment);
        -
        13398 
        -
        13399  // If the allocation doesn't fit before the end of dstBlock, forward to next block.
        -
        13400  while(dstBlockInfoIndex < srcBlockInfoIndex &&
        -
        13401  dstAllocOffset + srcAllocSize > dstBlockSize)
        +
        13381  VmaSuballocation suballoc = *srcSuballocIt;
        +
        13382  suballoc.offset = dstAllocOffset;
        +
        13383  suballoc.hAllocation->ChangeOffset(dstAllocOffset);
        +
        13384  m_BytesMoved += srcAllocSize;
        +
        13385  ++m_AllocationsMoved;
        +
        13386 
        +
        13387  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
        +
        13388  ++nextSuballocIt;
        +
        13389  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
        +
        13390  srcSuballocIt = nextSuballocIt;
        +
        13391 
        +
        13392  InsertSuballoc(pFreeSpaceMetadata, suballoc);
        +
        13393 
        +
        13394  VmaDefragmentationMove move = {
        +
        13395  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
        +
        13396  srcAllocOffset, dstAllocOffset,
        +
        13397  srcAllocSize };
        +
        13398  moves.push_back(move);
        +
        13399  }
        +
        13400  // Different block
        +
        13401  else
        13402  {
        -
        13403  // But before that, register remaining free space at the end of dst block.
        -
        13404  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, dstBlockSize - dstOffset);
        -
        13405 
        -
        13406  ++dstBlockInfoIndex;
        -
        13407  dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
        -
        13408  pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
        -
        13409  pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
        -
        13410  dstBlockSize = pDstMetadata->GetSize();
        -
        13411  dstOffset = 0;
        -
        13412  dstAllocOffset = 0;
        -
        13413  }
        -
        13414 
        -
        13415  // Same block
        -
        13416  if(dstBlockInfoIndex == srcBlockInfoIndex)
        -
        13417  {
        -
        13418  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
        +
        13403  // MOVE OPTION 2: Move the allocation to a different block.
        +
        13404 
        +
        13405  VMA_ASSERT(freeSpaceInfoIndex < srcBlockInfoIndex);
        +
        13406 
        +
        13407  VmaSuballocation suballoc = *srcSuballocIt;
        +
        13408  suballoc.offset = dstAllocOffset;
        +
        13409  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pFreeSpaceBlock, dstAllocOffset);
        +
        13410  m_BytesMoved += srcAllocSize;
        +
        13411  ++m_AllocationsMoved;
        +
        13412 
        +
        13413  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
        +
        13414  ++nextSuballocIt;
        +
        13415  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
        +
        13416  srcSuballocIt = nextSuballocIt;
        +
        13417 
        +
        13418  InsertSuballoc(pFreeSpaceMetadata, suballoc);
        13419 
        -
        13420  const bool overlap = dstAllocOffset + srcAllocSize > srcAllocOffset;
        -
        13421 
        -
        13422  bool skipOver = overlap;
        -
        13423  if(overlap && m_OverlappingMoveSupported && dstAllocOffset < srcAllocOffset)
        -
        13424  {
        -
        13425  // If destination and source place overlap, skip if it would move it
        -
        13426  // by only < 1/64 of its size.
        -
        13427  skipOver = (srcAllocOffset - dstAllocOffset) * 64 < srcAllocSize;
        -
        13428  }
        -
        13429 
        -
        13430  if(skipOver)
        -
        13431  {
        -
        13432  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, srcAllocOffset - dstOffset);
        -
        13433 
        -
        13434  dstOffset = srcAllocOffset + srcAllocSize;
        -
        13435  ++srcSuballocIt;
        -
        13436  }
        -
        13437  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
        -
        13438  else
        -
        13439  {
        -
        13440  srcSuballocIt->offset = dstAllocOffset;
        -
        13441  srcSuballocIt->hAllocation->ChangeOffset(dstAllocOffset);
        -
        13442  dstOffset = dstAllocOffset + srcAllocSize;
        -
        13443  m_BytesMoved += srcAllocSize;
        -
        13444  ++m_AllocationsMoved;
        -
        13445  ++srcSuballocIt;
        -
        13446  VmaDefragmentationMove move = {
        -
        13447  srcOrigBlockIndex, dstOrigBlockIndex,
        -
        13448  srcAllocOffset, dstAllocOffset,
        -
        13449  srcAllocSize };
        -
        13450  moves.push_back(move);
        -
        13451  }
        -
        13452  }
        -
        13453  // Different block
        -
        13454  else
        -
        13455  {
        -
        13456  // MOVE OPTION 2: Move the allocation to a different block.
        -
        13457 
        -
        13458  VMA_ASSERT(dstBlockInfoIndex < srcBlockInfoIndex);
        -
        13459  VMA_ASSERT(dstAllocOffset + srcAllocSize <= dstBlockSize);
        -
        13460 
        -
        13461  VmaSuballocation suballoc = *srcSuballocIt;
        -
        13462  suballoc.offset = dstAllocOffset;
        -
        13463  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlock, dstAllocOffset);
        -
        13464  dstOffset = dstAllocOffset + srcAllocSize;
        -
        13465  m_BytesMoved += srcAllocSize;
        -
        13466  ++m_AllocationsMoved;
        -
        13467 
        -
        13468  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
        -
        13469  ++nextSuballocIt;
        -
        13470  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
        -
        13471  srcSuballocIt = nextSuballocIt;
        -
        13472 
        -
        13473  pDstMetadata->m_Suballocations.push_back(suballoc);
        -
        13474 
        -
        13475  VmaDefragmentationMove move = {
        -
        13476  srcOrigBlockIndex, dstOrigBlockIndex,
        -
        13477  srcAllocOffset, dstAllocOffset,
        -
        13478  srcAllocSize };
        -
        13479  moves.push_back(move);
        -
        13480  }
        -
        13481  }
        -
        13482  }
        -
        13483  }
        -
        13484 
        -
        13485  m_BlockInfos.clear();
        -
        13486 
        -
        13487  PostprocessMetadata();
        -
        13488 
        -
        13489  return VK_SUCCESS;
        -
        13490 }
        -
        13491 
        -
        13492 void VmaDefragmentationAlgorithm_Fast::PreprocessMetadata()
        -
        13493 {
        -
        13494  const size_t blockCount = m_pBlockVector->GetBlockCount();
        -
        13495  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        -
        13496  {
        -
        13497  VmaBlockMetadata_Generic* const pMetadata =
        -
        13498  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
        -
        13499  pMetadata->m_FreeCount = 0;
        -
        13500  pMetadata->m_SumFreeSize = pMetadata->GetSize();
        -
        13501  pMetadata->m_FreeSuballocationsBySize.clear();
        -
        13502  for(VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
        -
        13503  it != pMetadata->m_Suballocations.end(); )
        -
        13504  {
        -
        13505  if(it->type == VMA_SUBALLOCATION_TYPE_FREE)
        -
        13506  {
        -
        13507  VmaSuballocationList::iterator nextIt = it;
        -
        13508  ++nextIt;
        -
        13509  pMetadata->m_Suballocations.erase(it);
        -
        13510  it = nextIt;
        -
        13511  }
        -
        13512  else
        -
        13513  {
        -
        13514  ++it;
        -
        13515  }
        -
        13516  }
        -
        13517  }
        -
        13518 }
        -
        13519 
        -
        13520 void VmaDefragmentationAlgorithm_Fast::PostprocessMetadata()
        -
        13521 {
        -
        13522  const size_t blockCount = m_pBlockVector->GetBlockCount();
        -
        13523  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        -
        13524  {
        -
        13525  VmaBlockMetadata_Generic* const pMetadata =
        -
        13526  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
        -
        13527  const VkDeviceSize blockSize = pMetadata->GetSize();
        -
        13528 
        -
        13529  // No allocations in this block - entire area is free.
        -
        13530  if(pMetadata->m_Suballocations.empty())
        -
        13531  {
        -
        13532  pMetadata->m_FreeCount = 1;
        -
        13533  //pMetadata->m_SumFreeSize is already set to blockSize.
        -
        13534  VmaSuballocation suballoc = {
        -
        13535  0, // offset
        -
        13536  blockSize, // size
        -
        13537  VMA_NULL, // hAllocation
        -
        13538  VMA_SUBALLOCATION_TYPE_FREE };
        -
        13539  pMetadata->m_Suballocations.push_back(suballoc);
        -
        13540  pMetadata->RegisterFreeSuballocation(pMetadata->m_Suballocations.begin());
        -
        13541  }
        -
        13542  // There are some allocations in this block.
        -
        13543  else
        -
        13544  {
        -
        13545  VkDeviceSize offset = 0;
        -
        13546  VmaSuballocationList::iterator it;
        -
        13547  for(it = pMetadata->m_Suballocations.begin();
        -
        13548  it != pMetadata->m_Suballocations.end();
        -
        13549  ++it)
        -
        13550  {
        -
        13551  VMA_ASSERT(it->type != VMA_SUBALLOCATION_TYPE_FREE);
        -
        13552  VMA_ASSERT(it->offset >= offset);
        -
        13553 
        -
        13554  // Need to insert preceding free space.
        -
        13555  if(it->offset > offset)
        -
        13556  {
        -
        13557  ++pMetadata->m_FreeCount;
        -
        13558  const VkDeviceSize freeSize = it->offset - offset;
        -
        13559  VmaSuballocation suballoc = {
        -
        13560  offset, // offset
        -
        13561  freeSize, // size
        -
        13562  VMA_NULL, // hAllocation
        -
        13563  VMA_SUBALLOCATION_TYPE_FREE };
        -
        13564  VmaSuballocationList::iterator precedingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
        -
        13565  if(freeSize >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        -
        13566  {
        -
        13567  pMetadata->m_FreeSuballocationsBySize.push_back(precedingFreeIt);
        -
        13568  }
        -
        13569  }
        -
        13570 
        -
        13571  pMetadata->m_SumFreeSize -= it->size;
        -
        13572  offset = it->offset + it->size;
        -
        13573  }
        -
        13574 
        -
        13575  // Need to insert trailing free space.
        -
        13576  if(offset < blockSize)
        -
        13577  {
        -
        13578  ++pMetadata->m_FreeCount;
        -
        13579  const VkDeviceSize freeSize = blockSize - offset;
        -
        13580  VmaSuballocation suballoc = {
        -
        13581  offset, // offset
        -
        13582  freeSize, // size
        -
        13583  VMA_NULL, // hAllocation
        -
        13584  VMA_SUBALLOCATION_TYPE_FREE };
        -
        13585  VMA_ASSERT(it == pMetadata->m_Suballocations.end());
        -
        13586  VmaSuballocationList::iterator trailingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
        -
        13587  if(freeSize > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        13420  VmaDefragmentationMove move = {
        +
        13421  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
        +
        13422  srcAllocOffset, dstAllocOffset,
        +
        13423  srcAllocSize };
        +
        13424  moves.push_back(move);
        +
        13425  }
        +
        13426  }
        +
        13427  else
        +
        13428  {
        +
        13429  dstAllocOffset = VmaAlignUp(dstOffset, srcAllocAlignment);
        +
        13430 
        +
        13431  // If the allocation doesn't fit before the end of dstBlock, forward to next block.
        +
        13432  while(dstBlockInfoIndex < srcBlockInfoIndex &&
        +
        13433  dstAllocOffset + srcAllocSize > dstBlockSize)
        +
        13434  {
        +
        13435  // But before that, register remaining free space at the end of dst block.
        +
        13436  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, dstBlockSize - dstOffset);
        +
        13437 
        +
        13438  ++dstBlockInfoIndex;
        +
        13439  dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
        +
        13440  pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
        +
        13441  pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
        +
        13442  dstBlockSize = pDstMetadata->GetSize();
        +
        13443  dstOffset = 0;
        +
        13444  dstAllocOffset = 0;
        +
        13445  }
        +
        13446 
        +
        13447  // Same block
        +
        13448  if(dstBlockInfoIndex == srcBlockInfoIndex)
        +
        13449  {
        +
        13450  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
        +
        13451 
        +
        13452  const bool overlap = dstAllocOffset + srcAllocSize > srcAllocOffset;
        +
        13453 
        +
        13454  bool skipOver = overlap;
        +
        13455  if(overlap && m_OverlappingMoveSupported && dstAllocOffset < srcAllocOffset)
        +
        13456  {
        +
        13457  // If destination and source place overlap, skip if it would move it
        +
        13458  // by only < 1/64 of its size.
        +
        13459  skipOver = (srcAllocOffset - dstAllocOffset) * 64 < srcAllocSize;
        +
        13460  }
        +
        13461 
        +
        13462  if(skipOver)
        +
        13463  {
        +
        13464  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, srcAllocOffset - dstOffset);
        +
        13465 
        +
        13466  dstOffset = srcAllocOffset + srcAllocSize;
        +
        13467  ++srcSuballocIt;
        +
        13468  }
        +
        13469  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
        +
        13470  else
        +
        13471  {
        +
        13472  srcSuballocIt->offset = dstAllocOffset;
        +
        13473  srcSuballocIt->hAllocation->ChangeOffset(dstAllocOffset);
        +
        13474  dstOffset = dstAllocOffset + srcAllocSize;
        +
        13475  m_BytesMoved += srcAllocSize;
        +
        13476  ++m_AllocationsMoved;
        +
        13477  ++srcSuballocIt;
        +
        13478  VmaDefragmentationMove move = {
        +
        13479  srcOrigBlockIndex, dstOrigBlockIndex,
        +
        13480  srcAllocOffset, dstAllocOffset,
        +
        13481  srcAllocSize };
        +
        13482  moves.push_back(move);
        +
        13483  }
        +
        13484  }
        +
        13485  // Different block
        +
        13486  else
        +
        13487  {
        +
        13488  // MOVE OPTION 2: Move the allocation to a different block.
        +
        13489 
        +
        13490  VMA_ASSERT(dstBlockInfoIndex < srcBlockInfoIndex);
        +
        13491  VMA_ASSERT(dstAllocOffset + srcAllocSize <= dstBlockSize);
        +
        13492 
        +
        13493  VmaSuballocation suballoc = *srcSuballocIt;
        +
        13494  suballoc.offset = dstAllocOffset;
        +
        13495  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlock, dstAllocOffset);
        +
        13496  dstOffset = dstAllocOffset + srcAllocSize;
        +
        13497  m_BytesMoved += srcAllocSize;
        +
        13498  ++m_AllocationsMoved;
        +
        13499 
        +
        13500  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
        +
        13501  ++nextSuballocIt;
        +
        13502  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
        +
        13503  srcSuballocIt = nextSuballocIt;
        +
        13504 
        +
        13505  pDstMetadata->m_Suballocations.push_back(suballoc);
        +
        13506 
        +
        13507  VmaDefragmentationMove move = {
        +
        13508  srcOrigBlockIndex, dstOrigBlockIndex,
        +
        13509  srcAllocOffset, dstAllocOffset,
        +
        13510  srcAllocSize };
        +
        13511  moves.push_back(move);
        +
        13512  }
        +
        13513  }
        +
        13514  }
        +
        13515  }
        +
        13516 
        +
        13517  m_BlockInfos.clear();
        +
        13518 
        +
        13519  PostprocessMetadata();
        +
        13520 
        +
        13521  return VK_SUCCESS;
        +
        13522 }
        +
        13523 
        +
        13524 void VmaDefragmentationAlgorithm_Fast::PreprocessMetadata()
        +
        13525 {
        +
        13526  const size_t blockCount = m_pBlockVector->GetBlockCount();
        +
        13527  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        +
        13528  {
        +
        13529  VmaBlockMetadata_Generic* const pMetadata =
        +
        13530  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
        +
        13531  pMetadata->m_FreeCount = 0;
        +
        13532  pMetadata->m_SumFreeSize = pMetadata->GetSize();
        +
        13533  pMetadata->m_FreeSuballocationsBySize.clear();
        +
        13534  for(VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
        +
        13535  it != pMetadata->m_Suballocations.end(); )
        +
        13536  {
        +
        13537  if(it->type == VMA_SUBALLOCATION_TYPE_FREE)
        +
        13538  {
        +
        13539  VmaSuballocationList::iterator nextIt = it;
        +
        13540  ++nextIt;
        +
        13541  pMetadata->m_Suballocations.erase(it);
        +
        13542  it = nextIt;
        +
        13543  }
        +
        13544  else
        +
        13545  {
        +
        13546  ++it;
        +
        13547  }
        +
        13548  }
        +
        13549  }
        +
        13550 }
        +
        13551 
        +
        13552 void VmaDefragmentationAlgorithm_Fast::PostprocessMetadata()
        +
        13553 {
        +
        13554  const size_t blockCount = m_pBlockVector->GetBlockCount();
        +
        13555  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        +
        13556  {
        +
        13557  VmaBlockMetadata_Generic* const pMetadata =
        +
        13558  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
        +
        13559  const VkDeviceSize blockSize = pMetadata->GetSize();
        +
        13560 
        +
        13561  // No allocations in this block - entire area is free.
        +
        13562  if(pMetadata->m_Suballocations.empty())
        +
        13563  {
        +
        13564  pMetadata->m_FreeCount = 1;
        +
        13565  //pMetadata->m_SumFreeSize is already set to blockSize.
        +
        13566  VmaSuballocation suballoc = {
        +
        13567  0, // offset
        +
        13568  blockSize, // size
        +
        13569  VMA_NULL, // hAllocation
        +
        13570  VMA_SUBALLOCATION_TYPE_FREE };
        +
        13571  pMetadata->m_Suballocations.push_back(suballoc);
        +
        13572  pMetadata->RegisterFreeSuballocation(pMetadata->m_Suballocations.begin());
        +
        13573  }
        +
        13574  // There are some allocations in this block.
        +
        13575  else
        +
        13576  {
        +
        13577  VkDeviceSize offset = 0;
        +
        13578  VmaSuballocationList::iterator it;
        +
        13579  for(it = pMetadata->m_Suballocations.begin();
        +
        13580  it != pMetadata->m_Suballocations.end();
        +
        13581  ++it)
        +
        13582  {
        +
        13583  VMA_ASSERT(it->type != VMA_SUBALLOCATION_TYPE_FREE);
        +
        13584  VMA_ASSERT(it->offset >= offset);
        +
        13585 
        +
        13586  // Need to insert preceding free space.
        +
        13587  if(it->offset > offset)
        13588  {
        -
        13589  pMetadata->m_FreeSuballocationsBySize.push_back(trailingFreeIt);
        -
        13590  }
        -
        13591  }
        -
        13592 
        -
        13593  VMA_SORT(
        -
        13594  pMetadata->m_FreeSuballocationsBySize.begin(),
        -
        13595  pMetadata->m_FreeSuballocationsBySize.end(),
        -
        13596  VmaSuballocationItemSizeLess());
        -
        13597  }
        -
        13598 
        -
        13599  VMA_HEAVY_ASSERT(pMetadata->Validate());
        -
        13600  }
        -
        13601 }
        +
        13589  ++pMetadata->m_FreeCount;
        +
        13590  const VkDeviceSize freeSize = it->offset - offset;
        +
        13591  VmaSuballocation suballoc = {
        +
        13592  offset, // offset
        +
        13593  freeSize, // size
        +
        13594  VMA_NULL, // hAllocation
        +
        13595  VMA_SUBALLOCATION_TYPE_FREE };
        +
        13596  VmaSuballocationList::iterator precedingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
        +
        13597  if(freeSize >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        13598  {
        +
        13599  pMetadata->m_FreeSuballocationsBySize.push_back(precedingFreeIt);
        +
        13600  }
        +
        13601  }
        13602 
        -
        13603 void VmaDefragmentationAlgorithm_Fast::InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc)
        -
        13604 {
        -
        13605  // TODO: Optimize somehow. Remember iterator instead of searching for it linearly.
        -
        13606  VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
        -
        13607  while(it != pMetadata->m_Suballocations.end())
        -
        13608  {
        -
        13609  if(it->offset < suballoc.offset)
        -
        13610  {
        -
        13611  ++it;
        -
        13612  }
        -
        13613  }
        -
        13614  pMetadata->m_Suballocations.insert(it, suballoc);
        -
        13615 }
        -
        13616 
        -
        13618 // VmaBlockVectorDefragmentationContext
        -
        13619 
        -
        13620 VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext(
        -
        13621  VmaAllocator hAllocator,
        -
        13622  VmaPool hCustomPool,
        -
        13623  VmaBlockVector* pBlockVector,
        -
        13624  uint32_t currFrameIndex) :
        -
        13625  res(VK_SUCCESS),
        -
        13626  mutexLocked(false),
        -
        13627  blockContexts(VmaStlAllocator<VmaBlockDefragmentationContext>(hAllocator->GetAllocationCallbacks())),
        -
        13628  m_hAllocator(hAllocator),
        -
        13629  m_hCustomPool(hCustomPool),
        -
        13630  m_pBlockVector(pBlockVector),
        -
        13631  m_CurrFrameIndex(currFrameIndex),
        -
        13632  m_pAlgorithm(VMA_NULL),
        -
        13633  m_Allocations(VmaStlAllocator<AllocInfo>(hAllocator->GetAllocationCallbacks())),
        -
        13634  m_AllAllocations(false)
        -
        13635 {
        -
        13636 }
        -
        13637 
        -
        13638 VmaBlockVectorDefragmentationContext::~VmaBlockVectorDefragmentationContext()
        -
        13639 {
        -
        13640  vma_delete(m_hAllocator, m_pAlgorithm);
        -
        13641 }
        -
        13642 
        -
        13643 void VmaBlockVectorDefragmentationContext::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        -
        13644 {
        -
        13645  AllocInfo info = { hAlloc, pChanged };
        -
        13646  m_Allocations.push_back(info);
        +
        13603  pMetadata->m_SumFreeSize -= it->size;
        +
        13604  offset = it->offset + it->size;
        +
        13605  }
        +
        13606 
        +
        13607  // Need to insert trailing free space.
        +
        13608  if(offset < blockSize)
        +
        13609  {
        +
        13610  ++pMetadata->m_FreeCount;
        +
        13611  const VkDeviceSize freeSize = blockSize - offset;
        +
        13612  VmaSuballocation suballoc = {
        +
        13613  offset, // offset
        +
        13614  freeSize, // size
        +
        13615  VMA_NULL, // hAllocation
        +
        13616  VMA_SUBALLOCATION_TYPE_FREE };
        +
        13617  VMA_ASSERT(it == pMetadata->m_Suballocations.end());
        +
        13618  VmaSuballocationList::iterator trailingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
        +
        13619  if(freeSize > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        +
        13620  {
        +
        13621  pMetadata->m_FreeSuballocationsBySize.push_back(trailingFreeIt);
        +
        13622  }
        +
        13623  }
        +
        13624 
        +
        13625  VMA_SORT(
        +
        13626  pMetadata->m_FreeSuballocationsBySize.begin(),
        +
        13627  pMetadata->m_FreeSuballocationsBySize.end(),
        +
        13628  VmaSuballocationItemSizeLess());
        +
        13629  }
        +
        13630 
        +
        13631  VMA_HEAVY_ASSERT(pMetadata->Validate());
        +
        13632  }
        +
        13633 }
        +
        13634 
        +
        13635 void VmaDefragmentationAlgorithm_Fast::InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc)
        +
        13636 {
        +
        13637  // TODO: Optimize somehow. Remember iterator instead of searching for it linearly.
        +
        13638  VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
        +
        13639  while(it != pMetadata->m_Suballocations.end())
        +
        13640  {
        +
        13641  if(it->offset < suballoc.offset)
        +
        13642  {
        +
        13643  ++it;
        +
        13644  }
        +
        13645  }
        +
        13646  pMetadata->m_Suballocations.insert(it, suballoc);
        13647 }
        13648 
        -
        13649 void VmaBlockVectorDefragmentationContext::Begin(bool overlappingMoveSupported)
        -
        13650 {
        -
        13651  const bool allAllocations = m_AllAllocations ||
        -
        13652  m_Allocations.size() == m_pBlockVector->CalcAllocationCount();
        -
        13653 
        -
        13654  /********************************
        -
        13655  HERE IS THE CHOICE OF DEFRAGMENTATION ALGORITHM.
        -
        13656  ********************************/
        -
        13657 
        -
        13658  /*
        -
        13659  Fast algorithm is supported only when certain criteria are met:
        -
        13660  - VMA_DEBUG_MARGIN is 0.
        -
        13661  - All allocations in this block vector are moveable.
        -
        13662  - There is no possibility of image/buffer granularity conflict.
        -
        13663  */
        -
        13664  if(VMA_DEBUG_MARGIN == 0 &&
        -
        13665  allAllocations &&
        -
        13666  !m_pBlockVector->IsBufferImageGranularityConflictPossible())
        -
        13667  {
        -
        13668  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Fast)(
        -
        13669  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
        -
        13670  }
        -
        13671  else
        -
        13672  {
        -
        13673  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Generic)(
        -
        13674  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
        -
        13675  }
        -
        13676 
        -
        13677  if(allAllocations)
        -
        13678  {
        -
        13679  m_pAlgorithm->AddAll();
        -
        13680  }
        -
        13681  else
        -
        13682  {
        -
        13683  for(size_t i = 0, count = m_Allocations.size(); i < count; ++i)
        -
        13684  {
        -
        13685  m_pAlgorithm->AddAllocation(m_Allocations[i].hAlloc, m_Allocations[i].pChanged);
        -
        13686  }
        -
        13687  }
        -
        13688 }
        +
        13650 // VmaBlockVectorDefragmentationContext
        +
        13651 
        +
        13652 VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext(
        +
        13653  VmaAllocator hAllocator,
        +
        13654  VmaPool hCustomPool,
        +
        13655  VmaBlockVector* pBlockVector,
        +
        13656  uint32_t currFrameIndex) :
        +
        13657  res(VK_SUCCESS),
        +
        13658  mutexLocked(false),
        +
        13659  blockContexts(VmaStlAllocator<VmaBlockDefragmentationContext>(hAllocator->GetAllocationCallbacks())),
        +
        13660  m_hAllocator(hAllocator),
        +
        13661  m_hCustomPool(hCustomPool),
        +
        13662  m_pBlockVector(pBlockVector),
        +
        13663  m_CurrFrameIndex(currFrameIndex),
        +
        13664  m_pAlgorithm(VMA_NULL),
        +
        13665  m_Allocations(VmaStlAllocator<AllocInfo>(hAllocator->GetAllocationCallbacks())),
        +
        13666  m_AllAllocations(false)
        +
        13667 {
        +
        13668 }
        +
        13669 
        +
        13670 VmaBlockVectorDefragmentationContext::~VmaBlockVectorDefragmentationContext()
        +
        13671 {
        +
        13672  vma_delete(m_hAllocator, m_pAlgorithm);
        +
        13673 }
        +
        13674 
        +
        13675 void VmaBlockVectorDefragmentationContext::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        +
        13676 {
        +
        13677  AllocInfo info = { hAlloc, pChanged };
        +
        13678  m_Allocations.push_back(info);
        +
        13679 }
        +
        13680 
        +
        13681 void VmaBlockVectorDefragmentationContext::Begin(bool overlappingMoveSupported)
        +
        13682 {
        +
        13683  const bool allAllocations = m_AllAllocations ||
        +
        13684  m_Allocations.size() == m_pBlockVector->CalcAllocationCount();
        +
        13685 
        +
        13686  /********************************
        +
        13687  HERE IS THE CHOICE OF DEFRAGMENTATION ALGORITHM.
        +
        13688  ********************************/
        13689 
        -
        13691 // VmaDefragmentationContext
        -
        13692 
        -
        13693 VmaDefragmentationContext_T::VmaDefragmentationContext_T(
        -
        13694  VmaAllocator hAllocator,
        -
        13695  uint32_t currFrameIndex,
        -
        13696  uint32_t flags,
        -
        13697  VmaDefragmentationStats* pStats) :
        -
        13698  m_hAllocator(hAllocator),
        -
        13699  m_CurrFrameIndex(currFrameIndex),
        -
        13700  m_Flags(flags),
        -
        13701  m_pStats(pStats),
        -
        13702  m_CustomPoolContexts(VmaStlAllocator<VmaBlockVectorDefragmentationContext*>(hAllocator->GetAllocationCallbacks()))
        -
        13703 {
        -
        13704  memset(m_DefaultPoolContexts, 0, sizeof(m_DefaultPoolContexts));
        -
        13705 }
        -
        13706 
        -
        13707 VmaDefragmentationContext_T::~VmaDefragmentationContext_T()
        -
        13708 {
        -
        13709  for(size_t i = m_CustomPoolContexts.size(); i--; )
        +
        13690  /*
        +
        13691  Fast algorithm is supported only when certain criteria are met:
        +
        13692  - VMA_DEBUG_MARGIN is 0.
        +
        13693  - All allocations in this block vector are moveable.
        +
        13694  - There is no possibility of image/buffer granularity conflict.
        +
        13695  */
        +
        13696  if(VMA_DEBUG_MARGIN == 0 &&
        +
        13697  allAllocations &&
        +
        13698  !m_pBlockVector->IsBufferImageGranularityConflictPossible())
        +
        13699  {
        +
        13700  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Fast)(
        +
        13701  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
        +
        13702  }
        +
        13703  else
        +
        13704  {
        +
        13705  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Generic)(
        +
        13706  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
        +
        13707  }
        +
        13708 
        +
        13709  if(allAllocations)
        13710  {
        -
        13711  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[i];
        -
        13712  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
        -
        13713  vma_delete(m_hAllocator, pBlockVectorCtx);
        -
        13714  }
        -
        13715  for(size_t i = m_hAllocator->m_MemProps.memoryTypeCount; i--; )
        -
        13716  {
        -
        13717  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[i];
        -
        13718  if(pBlockVectorCtx)
        -
        13719  {
        -
        13720  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
        -
        13721  vma_delete(m_hAllocator, pBlockVectorCtx);
        -
        13722  }
        -
        13723  }
        -
        13724 }
        -
        13725 
        -
        13726 void VmaDefragmentationContext_T::AddPools(uint32_t poolCount, VmaPool* pPools)
        -
        13727 {
        -
        13728  for(uint32_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        -
        13729  {
        -
        13730  VmaPool pool = pPools[poolIndex];
        -
        13731  VMA_ASSERT(pool);
        -
        13732  // Pools with algorithm other than default are not defragmented.
        -
        13733  if(pool->m_BlockVector.GetAlgorithm() == 0)
        -
        13734  {
        -
        13735  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
        -
        13736 
        -
        13737  for(size_t i = m_CustomPoolContexts.size(); i--; )
        -
        13738  {
        -
        13739  if(m_CustomPoolContexts[i]->GetCustomPool() == pool)
        -
        13740  {
        -
        13741  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
        -
        13742  break;
        -
        13743  }
        -
        13744  }
        -
        13745 
        -
        13746  if(!pBlockVectorDefragCtx)
        -
        13747  {
        -
        13748  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
        -
        13749  m_hAllocator,
        -
        13750  pool,
        -
        13751  &pool->m_BlockVector,
        -
        13752  m_CurrFrameIndex);
        -
        13753  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
        -
        13754  }
        -
        13755 
        -
        13756  pBlockVectorDefragCtx->AddAll();
        -
        13757  }
        -
        13758  }
        -
        13759 }
        -
        13760 
        -
        13761 void VmaDefragmentationContext_T::AddAllocations(
        -
        13762  uint32_t allocationCount,
        -
        13763  VmaAllocation* pAllocations,
        -
        13764  VkBool32* pAllocationsChanged)
        -
        13765 {
        -
        13766  // Dispatch pAllocations among defragmentators. Create them when necessary.
        -
        13767  for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        -
        13768  {
        -
        13769  const VmaAllocation hAlloc = pAllocations[allocIndex];
        -
        13770  VMA_ASSERT(hAlloc);
        -
        13771  // DedicatedAlloc cannot be defragmented.
        -
        13772  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
        -
        13773  // Lost allocation cannot be defragmented.
        -
        13774  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
        -
        13775  {
        -
        13776  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
        -
        13777 
        -
        13778  const VmaPool hAllocPool = hAlloc->GetBlock()->GetParentPool();
        -
        13779  // This allocation belongs to custom pool.
        -
        13780  if(hAllocPool != VK_NULL_HANDLE)
        -
        13781  {
        -
        13782  // Pools with algorithm other than default are not defragmented.
        -
        13783  if(hAllocPool->m_BlockVector.GetAlgorithm() == 0)
        -
        13784  {
        -
        13785  for(size_t i = m_CustomPoolContexts.size(); i--; )
        -
        13786  {
        -
        13787  if(m_CustomPoolContexts[i]->GetCustomPool() == hAllocPool)
        -
        13788  {
        -
        13789  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
        -
        13790  break;
        -
        13791  }
        -
        13792  }
        -
        13793  if(!pBlockVectorDefragCtx)
        -
        13794  {
        -
        13795  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
        -
        13796  m_hAllocator,
        -
        13797  hAllocPool,
        -
        13798  &hAllocPool->m_BlockVector,
        -
        13799  m_CurrFrameIndex);
        -
        13800  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
        -
        13801  }
        -
        13802  }
        -
        13803  }
        -
        13804  // This allocation belongs to default pool.
        -
        13805  else
        -
        13806  {
        -
        13807  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
        -
        13808  pBlockVectorDefragCtx = m_DefaultPoolContexts[memTypeIndex];
        -
        13809  if(!pBlockVectorDefragCtx)
        -
        13810  {
        -
        13811  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
        -
        13812  m_hAllocator,
        -
        13813  VMA_NULL, // hCustomPool
        -
        13814  m_hAllocator->m_pBlockVectors[memTypeIndex],
        -
        13815  m_CurrFrameIndex);
        -
        13816  m_DefaultPoolContexts[memTypeIndex] = pBlockVectorDefragCtx;
        -
        13817  }
        -
        13818  }
        -
        13819 
        -
        13820  if(pBlockVectorDefragCtx)
        -
        13821  {
        -
        13822  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
        -
        13823  &pAllocationsChanged[allocIndex] : VMA_NULL;
        -
        13824  pBlockVectorDefragCtx->AddAllocation(hAlloc, pChanged);
        -
        13825  }
        -
        13826  }
        -
        13827  }
        -
        13828 }
        -
        13829 
        -
        13830 VkResult VmaDefragmentationContext_T::Defragment(
        -
        13831  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
        -
        13832  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
        -
        13833  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats)
        -
        13834 {
        -
        13835  if(pStats)
        -
        13836  {
        -
        13837  memset(pStats, 0, sizeof(VmaDefragmentationStats));
        -
        13838  }
        -
        13839 
        -
        13840  if(commandBuffer == VK_NULL_HANDLE)
        -
        13841  {
        -
        13842  maxGpuBytesToMove = 0;
        -
        13843  maxGpuAllocationsToMove = 0;
        -
        13844  }
        -
        13845 
        -
        13846  VkResult res = VK_SUCCESS;
        -
        13847 
        -
        13848  // Process default pools.
        -
        13849  for(uint32_t memTypeIndex = 0;
        -
        13850  memTypeIndex < m_hAllocator->GetMemoryTypeCount() && res >= VK_SUCCESS;
        -
        13851  ++memTypeIndex)
        -
        13852  {
        -
        13853  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];
        -
        13854  if(pBlockVectorCtx)
        -
        13855  {
        -
        13856  VMA_ASSERT(pBlockVectorCtx->GetBlockVector());
        -
        13857  pBlockVectorCtx->GetBlockVector()->Defragment(
        -
        13858  pBlockVectorCtx,
        -
        13859  pStats,
        -
        13860  maxCpuBytesToMove, maxCpuAllocationsToMove,
        -
        13861  maxGpuBytesToMove, maxGpuAllocationsToMove,
        -
        13862  commandBuffer);
        -
        13863  if(pBlockVectorCtx->res != VK_SUCCESS)
        -
        13864  {
        -
        13865  res = pBlockVectorCtx->res;
        -
        13866  }
        -
        13867  }
        -
        13868  }
        -
        13869 
        -
        13870  // Process custom pools.
        -
        13871  for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();
        -
        13872  customCtxIndex < customCtxCount && res >= VK_SUCCESS;
        -
        13873  ++customCtxIndex)
        -
        13874  {
        -
        13875  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];
        -
        13876  VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());
        -
        13877  pBlockVectorCtx->GetBlockVector()->Defragment(
        -
        13878  pBlockVectorCtx,
        -
        13879  pStats,
        -
        13880  maxCpuBytesToMove, maxCpuAllocationsToMove,
        -
        13881  maxGpuBytesToMove, maxGpuAllocationsToMove,
        -
        13882  commandBuffer);
        -
        13883  if(pBlockVectorCtx->res != VK_SUCCESS)
        -
        13884  {
        -
        13885  res = pBlockVectorCtx->res;
        -
        13886  }
        -
        13887  }
        -
        13888 
        -
        13889  return res;
        -
        13890 }
        -
        13891 
        -
        13893 // VmaRecorder
        -
        13894 
        -
        13895 #if VMA_RECORDING_ENABLED
        -
        13896 
        -
        13897 VmaRecorder::VmaRecorder() :
        -
        13898  m_UseMutex(true),
        -
        13899  m_Flags(0),
        -
        13900  m_File(VMA_NULL),
        -
        13901  m_Freq(INT64_MAX),
        -
        13902  m_StartCounter(INT64_MAX)
        -
        13903 {
        -
        13904 }
        -
        13905 
        -
        13906 VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
        -
        13907 {
        -
        13908  m_UseMutex = useMutex;
        -
        13909  m_Flags = settings.flags;
        -
        13910 
        -
        13911  QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq);
        -
        13912  QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter);
        -
        13913 
        -
        13914  // Open file for writing.
        -
        13915  errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
        -
        13916  if(err != 0)
        -
        13917  {
        -
        13918  return VK_ERROR_INITIALIZATION_FAILED;
        +
        13711  m_pAlgorithm->AddAll();
        +
        13712  }
        +
        13713  else
        +
        13714  {
        +
        13715  for(size_t i = 0, count = m_Allocations.size(); i < count; ++i)
        +
        13716  {
        +
        13717  m_pAlgorithm->AddAllocation(m_Allocations[i].hAlloc, m_Allocations[i].pChanged);
        +
        13718  }
        +
        13719  }
        +
        13720 }
        +
        13721 
        +
        13723 // VmaDefragmentationContext
        +
        13724 
        +
        13725 VmaDefragmentationContext_T::VmaDefragmentationContext_T(
        +
        13726  VmaAllocator hAllocator,
        +
        13727  uint32_t currFrameIndex,
        +
        13728  uint32_t flags,
        +
        13729  VmaDefragmentationStats* pStats) :
        +
        13730  m_hAllocator(hAllocator),
        +
        13731  m_CurrFrameIndex(currFrameIndex),
        +
        13732  m_Flags(flags),
        +
        13733  m_pStats(pStats),
        +
        13734  m_CustomPoolContexts(VmaStlAllocator<VmaBlockVectorDefragmentationContext*>(hAllocator->GetAllocationCallbacks()))
        +
        13735 {
        +
        13736  memset(m_DefaultPoolContexts, 0, sizeof(m_DefaultPoolContexts));
        +
        13737 }
        +
        13738 
        +
        13739 VmaDefragmentationContext_T::~VmaDefragmentationContext_T()
        +
        13740 {
        +
        13741  for(size_t i = m_CustomPoolContexts.size(); i--; )
        +
        13742  {
        +
        13743  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[i];
        +
        13744  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
        +
        13745  vma_delete(m_hAllocator, pBlockVectorCtx);
        +
        13746  }
        +
        13747  for(size_t i = m_hAllocator->m_MemProps.memoryTypeCount; i--; )
        +
        13748  {
        +
        13749  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[i];
        +
        13750  if(pBlockVectorCtx)
        +
        13751  {
        +
        13752  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
        +
        13753  vma_delete(m_hAllocator, pBlockVectorCtx);
        +
        13754  }
        +
        13755  }
        +
        13756 }
        +
        13757 
        +
        13758 void VmaDefragmentationContext_T::AddPools(uint32_t poolCount, VmaPool* pPools)
        +
        13759 {
        +
        13760  for(uint32_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        +
        13761  {
        +
        13762  VmaPool pool = pPools[poolIndex];
        +
        13763  VMA_ASSERT(pool);
        +
        13764  // Pools with algorithm other than default are not defragmented.
        +
        13765  if(pool->m_BlockVector.GetAlgorithm() == 0)
        +
        13766  {
        +
        13767  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
        +
        13768 
        +
        13769  for(size_t i = m_CustomPoolContexts.size(); i--; )
        +
        13770  {
        +
        13771  if(m_CustomPoolContexts[i]->GetCustomPool() == pool)
        +
        13772  {
        +
        13773  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
        +
        13774  break;
        +
        13775  }
        +
        13776  }
        +
        13777 
        +
        13778  if(!pBlockVectorDefragCtx)
        +
        13779  {
        +
        13780  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
        +
        13781  m_hAllocator,
        +
        13782  pool,
        +
        13783  &pool->m_BlockVector,
        +
        13784  m_CurrFrameIndex);
        +
        13785  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
        +
        13786  }
        +
        13787 
        +
        13788  pBlockVectorDefragCtx->AddAll();
        +
        13789  }
        +
        13790  }
        +
        13791 }
        +
        13792 
        +
        13793 void VmaDefragmentationContext_T::AddAllocations(
        +
        13794  uint32_t allocationCount,
        +
        13795  VmaAllocation* pAllocations,
        +
        13796  VkBool32* pAllocationsChanged)
        +
        13797 {
        +
        13798  // Dispatch pAllocations among defragmentators. Create them when necessary.
        +
        13799  for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        +
        13800  {
        +
        13801  const VmaAllocation hAlloc = pAllocations[allocIndex];
        +
        13802  VMA_ASSERT(hAlloc);
        +
        13803  // DedicatedAlloc cannot be defragmented.
        +
        13804  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
        +
        13805  // Lost allocation cannot be defragmented.
        +
        13806  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
        +
        13807  {
        +
        13808  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
        +
        13809 
        +
        13810  const VmaPool hAllocPool = hAlloc->GetBlock()->GetParentPool();
        +
        13811  // This allocation belongs to custom pool.
        +
        13812  if(hAllocPool != VK_NULL_HANDLE)
        +
        13813  {
        +
        13814  // Pools with algorithm other than default are not defragmented.
        +
        13815  if(hAllocPool->m_BlockVector.GetAlgorithm() == 0)
        +
        13816  {
        +
        13817  for(size_t i = m_CustomPoolContexts.size(); i--; )
        +
        13818  {
        +
        13819  if(m_CustomPoolContexts[i]->GetCustomPool() == hAllocPool)
        +
        13820  {
        +
        13821  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
        +
        13822  break;
        +
        13823  }
        +
        13824  }
        +
        13825  if(!pBlockVectorDefragCtx)
        +
        13826  {
        +
        13827  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
        +
        13828  m_hAllocator,
        +
        13829  hAllocPool,
        +
        13830  &hAllocPool->m_BlockVector,
        +
        13831  m_CurrFrameIndex);
        +
        13832  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
        +
        13833  }
        +
        13834  }
        +
        13835  }
        +
        13836  // This allocation belongs to default pool.
        +
        13837  else
        +
        13838  {
        +
        13839  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
        +
        13840  pBlockVectorDefragCtx = m_DefaultPoolContexts[memTypeIndex];
        +
        13841  if(!pBlockVectorDefragCtx)
        +
        13842  {
        +
        13843  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
        +
        13844  m_hAllocator,
        +
        13845  VMA_NULL, // hCustomPool
        +
        13846  m_hAllocator->m_pBlockVectors[memTypeIndex],
        +
        13847  m_CurrFrameIndex);
        +
        13848  m_DefaultPoolContexts[memTypeIndex] = pBlockVectorDefragCtx;
        +
        13849  }
        +
        13850  }
        +
        13851 
        +
        13852  if(pBlockVectorDefragCtx)
        +
        13853  {
        +
        13854  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
        +
        13855  &pAllocationsChanged[allocIndex] : VMA_NULL;
        +
        13856  pBlockVectorDefragCtx->AddAllocation(hAlloc, pChanged);
        +
        13857  }
        +
        13858  }
        +
        13859  }
        +
        13860 }
        +
        13861 
        +
        13862 VkResult VmaDefragmentationContext_T::Defragment(
        +
        13863  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
        +
        13864  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
        +
        13865  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats)
        +
        13866 {
        +
        13867  if(pStats)
        +
        13868  {
        +
        13869  memset(pStats, 0, sizeof(VmaDefragmentationStats));
        +
        13870  }
        +
        13871 
        +
        13872  if(commandBuffer == VK_NULL_HANDLE)
        +
        13873  {
        +
        13874  maxGpuBytesToMove = 0;
        +
        13875  maxGpuAllocationsToMove = 0;
        +
        13876  }
        +
        13877 
        +
        13878  VkResult res = VK_SUCCESS;
        +
        13879 
        +
        13880  // Process default pools.
        +
        13881  for(uint32_t memTypeIndex = 0;
        +
        13882  memTypeIndex < m_hAllocator->GetMemoryTypeCount() && res >= VK_SUCCESS;
        +
        13883  ++memTypeIndex)
        +
        13884  {
        +
        13885  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];
        +
        13886  if(pBlockVectorCtx)
        +
        13887  {
        +
        13888  VMA_ASSERT(pBlockVectorCtx->GetBlockVector());
        +
        13889  pBlockVectorCtx->GetBlockVector()->Defragment(
        +
        13890  pBlockVectorCtx,
        +
        13891  pStats,
        +
        13892  maxCpuBytesToMove, maxCpuAllocationsToMove,
        +
        13893  maxGpuBytesToMove, maxGpuAllocationsToMove,
        +
        13894  commandBuffer);
        +
        13895  if(pBlockVectorCtx->res != VK_SUCCESS)
        +
        13896  {
        +
        13897  res = pBlockVectorCtx->res;
        +
        13898  }
        +
        13899  }
        +
        13900  }
        +
        13901 
        +
        13902  // Process custom pools.
        +
        13903  for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();
        +
        13904  customCtxIndex < customCtxCount && res >= VK_SUCCESS;
        +
        13905  ++customCtxIndex)
        +
        13906  {
        +
        13907  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];
        +
        13908  VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());
        +
        13909  pBlockVectorCtx->GetBlockVector()->Defragment(
        +
        13910  pBlockVectorCtx,
        +
        13911  pStats,
        +
        13912  maxCpuBytesToMove, maxCpuAllocationsToMove,
        +
        13913  maxGpuBytesToMove, maxGpuAllocationsToMove,
        +
        13914  commandBuffer);
        +
        13915  if(pBlockVectorCtx->res != VK_SUCCESS)
        +
        13916  {
        +
        13917  res = pBlockVectorCtx->res;
        +
        13918  }
        13919  }
        13920 
        -
        13921  // Write header.
        -
        13922  fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
        -
        13923  fprintf(m_File, "%s\n", "1,7");
        -
        13924 
        -
        13925  return VK_SUCCESS;
        -
        13926 }
        -
        13927 
        -
        13928 VmaRecorder::~VmaRecorder()
        -
        13929 {
        -
        13930  if(m_File != VMA_NULL)
        -
        13931  {
        -
        13932  fclose(m_File);
        -
        13933  }
        -
        13934 }
        -
        13935 
        -
        13936 void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
        -
        13937 {
        -
        13938  CallParams callParams;
        -
        13939  GetBasicParams(callParams);
        -
        13940 
        -
        13941  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        13942  fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
        -
        13943  Flush();
        -
        13944 }
        +
        13921  return res;
        +
        13922 }
        +
        13923 
        +
        13925 // VmaRecorder
        +
        13926 
        +
        13927 #if VMA_RECORDING_ENABLED
        +
        13928 
        +
        13929 VmaRecorder::VmaRecorder() :
        +
        13930  m_UseMutex(true),
        +
        13931  m_Flags(0),
        +
        13932  m_File(VMA_NULL),
        +
        13933  m_Freq(INT64_MAX),
        +
        13934  m_StartCounter(INT64_MAX)
        +
        13935 {
        +
        13936 }
        +
        13937 
        +
        13938 VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
        +
        13939 {
        +
        13940  m_UseMutex = useMutex;
        +
        13941  m_Flags = settings.flags;
        +
        13942 
        +
        13943  QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq);
        +
        13944  QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter);
        13945 
        -
        13946 void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
        -
        13947 {
        -
        13948  CallParams callParams;
        -
        13949  GetBasicParams(callParams);
        -
        13950 
        -
        13951  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        13952  fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
        -
        13953  Flush();
        -
        13954 }
        -
        13955 
        -
        13956 void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
        -
        13957 {
        -
        13958  CallParams callParams;
        -
        13959  GetBasicParams(callParams);
        -
        13960 
        -
        13961  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        13962  fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        13963  createInfo.memoryTypeIndex,
        -
        13964  createInfo.flags,
        -
        13965  createInfo.blockSize,
        -
        13966  (uint64_t)createInfo.minBlockCount,
        -
        13967  (uint64_t)createInfo.maxBlockCount,
        -
        13968  createInfo.frameInUseCount,
        -
        13969  pool);
        -
        13970  Flush();
        -
        13971 }
        +
        13946  // Open file for writing.
        +
        13947  errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
        +
        13948  if(err != 0)
        +
        13949  {
        +
        13950  return VK_ERROR_INITIALIZATION_FAILED;
        +
        13951  }
        +
        13952 
        +
        13953  // Write header.
        +
        13954  fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
        +
        13955  fprintf(m_File, "%s\n", "1,8");
        +
        13956 
        +
        13957  return VK_SUCCESS;
        +
        13958 }
        +
        13959 
        +
        13960 VmaRecorder::~VmaRecorder()
        +
        13961 {
        +
        13962  if(m_File != VMA_NULL)
        +
        13963  {
        +
        13964  fclose(m_File);
        +
        13965  }
        +
        13966 }
        +
        13967 
        +
        13968 void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
        +
        13969 {
        +
        13970  CallParams callParams;
        +
        13971  GetBasicParams(callParams);
        13972 
        -
        13973 void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
        -
        13974 {
        -
        13975  CallParams callParams;
        -
        13976  GetBasicParams(callParams);
        +
        13973  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        13974  fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
        +
        13975  Flush();
        +
        13976 }
        13977 
        -
        13978  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        13979  fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        13980  pool);
        -
        13981  Flush();
        -
        13982 }
        -
        13983 
        -
        13984 void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
        -
        13985  const VkMemoryRequirements& vkMemReq,
        -
        13986  const VmaAllocationCreateInfo& createInfo,
        -
        13987  VmaAllocation allocation)
        -
        13988 {
        -
        13989  CallParams callParams;
        -
        13990  GetBasicParams(callParams);
        -
        13991 
        -
        13992  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        13993  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        -
        13994  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        -
        13995  vkMemReq.size,
        -
        13996  vkMemReq.alignment,
        -
        13997  vkMemReq.memoryTypeBits,
        -
        13998  createInfo.flags,
        -
        13999  createInfo.usage,
        -
        14000  createInfo.requiredFlags,
        -
        14001  createInfo.preferredFlags,
        -
        14002  createInfo.memoryTypeBits,
        -
        14003  createInfo.pool,
        -
        14004  allocation,
        -
        14005  userDataStr.GetString());
        -
        14006  Flush();
        -
        14007 }
        -
        14008 
        -
        14009 void VmaRecorder::RecordAllocateMemoryPages(uint32_t frameIndex,
        -
        14010  const VkMemoryRequirements& vkMemReq,
        -
        14011  const VmaAllocationCreateInfo& createInfo,
        -
        14012  uint64_t allocationCount,
        -
        14013  const VmaAllocation* pAllocations)
        -
        14014 {
        -
        14015  CallParams callParams;
        -
        14016  GetBasicParams(callParams);
        -
        14017 
        -
        14018  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14019  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        -
        14020  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryPages,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,", callParams.threadId, callParams.time, frameIndex,
        -
        14021  vkMemReq.size,
        -
        14022  vkMemReq.alignment,
        -
        14023  vkMemReq.memoryTypeBits,
        -
        14024  createInfo.flags,
        -
        14025  createInfo.usage,
        -
        14026  createInfo.requiredFlags,
        -
        14027  createInfo.preferredFlags,
        -
        14028  createInfo.memoryTypeBits,
        -
        14029  createInfo.pool);
        -
        14030  PrintPointerList(allocationCount, pAllocations);
        -
        14031  fprintf(m_File, ",%s\n", userDataStr.GetString());
        -
        14032  Flush();
        -
        14033 }
        -
        14034 
        -
        14035 void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        -
        14036  const VkMemoryRequirements& vkMemReq,
        -
        14037  bool requiresDedicatedAllocation,
        -
        14038  bool prefersDedicatedAllocation,
        -
        14039  const VmaAllocationCreateInfo& createInfo,
        -
        14040  VmaAllocation allocation)
        -
        14041 {
        -
        14042  CallParams callParams;
        -
        14043  GetBasicParams(callParams);
        -
        14044 
        -
        14045  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14046  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        -
        14047  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForBuffer,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        -
        14048  vkMemReq.size,
        -
        14049  vkMemReq.alignment,
        -
        14050  vkMemReq.memoryTypeBits,
        -
        14051  requiresDedicatedAllocation ? 1 : 0,
        -
        14052  prefersDedicatedAllocation ? 1 : 0,
        -
        14053  createInfo.flags,
        -
        14054  createInfo.usage,
        -
        14055  createInfo.requiredFlags,
        -
        14056  createInfo.preferredFlags,
        -
        14057  createInfo.memoryTypeBits,
        -
        14058  createInfo.pool,
        -
        14059  allocation,
        -
        14060  userDataStr.GetString());
        -
        14061  Flush();
        -
        14062 }
        -
        14063 
        -
        14064 void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
        -
        14065  const VkMemoryRequirements& vkMemReq,
        -
        14066  bool requiresDedicatedAllocation,
        -
        14067  bool prefersDedicatedAllocation,
        -
        14068  const VmaAllocationCreateInfo& createInfo,
        -
        14069  VmaAllocation allocation)
        -
        14070 {
        -
        14071  CallParams callParams;
        -
        14072  GetBasicParams(callParams);
        -
        14073 
        -
        14074  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14075  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        -
        14076  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForImage,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        -
        14077  vkMemReq.size,
        -
        14078  vkMemReq.alignment,
        -
        14079  vkMemReq.memoryTypeBits,
        -
        14080  requiresDedicatedAllocation ? 1 : 0,
        -
        14081  prefersDedicatedAllocation ? 1 : 0,
        -
        14082  createInfo.flags,
        -
        14083  createInfo.usage,
        -
        14084  createInfo.requiredFlags,
        -
        14085  createInfo.preferredFlags,
        -
        14086  createInfo.memoryTypeBits,
        -
        14087  createInfo.pool,
        -
        14088  allocation,
        -
        14089  userDataStr.GetString());
        -
        14090  Flush();
        -
        14091 }
        -
        14092 
        -
        14093 void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
        -
        14094  VmaAllocation allocation)
        -
        14095 {
        -
        14096  CallParams callParams;
        -
        14097  GetBasicParams(callParams);
        -
        14098 
        -
        14099  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14100  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14101  allocation);
        -
        14102  Flush();
        -
        14103 }
        -
        14104 
        -
        14105 void VmaRecorder::RecordFreeMemoryPages(uint32_t frameIndex,
        -
        14106  uint64_t allocationCount,
        -
        14107  const VmaAllocation* pAllocations)
        -
        14108 {
        -
        14109  CallParams callParams;
        -
        14110  GetBasicParams(callParams);
        -
        14111 
        -
        14112  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14113  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemoryPages,", callParams.threadId, callParams.time, frameIndex);
        -
        14114  PrintPointerList(allocationCount, pAllocations);
        -
        14115  fprintf(m_File, "\n");
        -
        14116  Flush();
        -
        14117 }
        -
        14118 
        -
        14119 void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
        -
        14120  VmaAllocation allocation,
        -
        14121  const void* pUserData)
        -
        14122 {
        -
        14123  CallParams callParams;
        -
        14124  GetBasicParams(callParams);
        -
        14125 
        -
        14126  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14127  UserDataString userDataStr(
        -
        14128  allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
        -
        14129  pUserData);
        -
        14130  fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        -
        14131  allocation,
        -
        14132  userDataStr.GetString());
        -
        14133  Flush();
        -
        14134 }
        -
        14135 
        -
        14136 void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
        -
        14137  VmaAllocation allocation)
        -
        14138 {
        -
        14139  CallParams callParams;
        -
        14140  GetBasicParams(callParams);
        -
        14141 
        -
        14142  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14143  fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14144  allocation);
        -
        14145  Flush();
        -
        14146 }
        -
        14147 
        -
        14148 void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
        -
        14149  VmaAllocation allocation)
        -
        14150 {
        -
        14151  CallParams callParams;
        -
        14152  GetBasicParams(callParams);
        -
        14153 
        -
        14154  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14155  fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14156  allocation);
        -
        14157  Flush();
        -
        14158 }
        -
        14159 
        -
        14160 void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
        -
        14161  VmaAllocation allocation)
        -
        14162 {
        -
        14163  CallParams callParams;
        -
        14164  GetBasicParams(callParams);
        -
        14165 
        -
        14166  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14167  fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14168  allocation);
        -
        14169  Flush();
        -
        14170 }
        -
        14171 
        -
        14172 void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
        -
        14173  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        -
        14174 {
        -
        14175  CallParams callParams;
        -
        14176  GetBasicParams(callParams);
        -
        14177 
        -
        14178  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14179  fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        -
        14180  allocation,
        -
        14181  offset,
        -
        14182  size);
        -
        14183  Flush();
        -
        14184 }
        +
        13978 void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
        +
        13979 {
        +
        13980  CallParams callParams;
        +
        13981  GetBasicParams(callParams);
        +
        13982 
        +
        13983  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        13984  fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
        +
        13985  Flush();
        +
        13986 }
        +
        13987 
        +
        13988 void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
        +
        13989 {
        +
        13990  CallParams callParams;
        +
        13991  GetBasicParams(callParams);
        +
        13992 
        +
        13993  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        13994  fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        13995  createInfo.memoryTypeIndex,
        +
        13996  createInfo.flags,
        +
        13997  createInfo.blockSize,
        +
        13998  (uint64_t)createInfo.minBlockCount,
        +
        13999  (uint64_t)createInfo.maxBlockCount,
        +
        14000  createInfo.frameInUseCount,
        +
        14001  pool);
        +
        14002  Flush();
        +
        14003 }
        +
        14004 
        +
        14005 void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
        +
        14006 {
        +
        14007  CallParams callParams;
        +
        14008  GetBasicParams(callParams);
        +
        14009 
        +
        14010  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14011  fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14012  pool);
        +
        14013  Flush();
        +
        14014 }
        +
        14015 
        +
        14016 void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
        +
        14017  const VkMemoryRequirements& vkMemReq,
        +
        14018  const VmaAllocationCreateInfo& createInfo,
        +
        14019  VmaAllocation allocation)
        +
        14020 {
        +
        14021  CallParams callParams;
        +
        14022  GetBasicParams(callParams);
        +
        14023 
        +
        14024  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14025  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        +
        14026  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        +
        14027  vkMemReq.size,
        +
        14028  vkMemReq.alignment,
        +
        14029  vkMemReq.memoryTypeBits,
        +
        14030  createInfo.flags,
        +
        14031  createInfo.usage,
        +
        14032  createInfo.requiredFlags,
        +
        14033  createInfo.preferredFlags,
        +
        14034  createInfo.memoryTypeBits,
        +
        14035  createInfo.pool,
        +
        14036  allocation,
        +
        14037  userDataStr.GetString());
        +
        14038  Flush();
        +
        14039 }
        +
        14040 
        +
        14041 void VmaRecorder::RecordAllocateMemoryPages(uint32_t frameIndex,
        +
        14042  const VkMemoryRequirements& vkMemReq,
        +
        14043  const VmaAllocationCreateInfo& createInfo,
        +
        14044  uint64_t allocationCount,
        +
        14045  const VmaAllocation* pAllocations)
        +
        14046 {
        +
        14047  CallParams callParams;
        +
        14048  GetBasicParams(callParams);
        +
        14049 
        +
        14050  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14051  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        +
        14052  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryPages,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,", callParams.threadId, callParams.time, frameIndex,
        +
        14053  vkMemReq.size,
        +
        14054  vkMemReq.alignment,
        +
        14055  vkMemReq.memoryTypeBits,
        +
        14056  createInfo.flags,
        +
        14057  createInfo.usage,
        +
        14058  createInfo.requiredFlags,
        +
        14059  createInfo.preferredFlags,
        +
        14060  createInfo.memoryTypeBits,
        +
        14061  createInfo.pool);
        +
        14062  PrintPointerList(allocationCount, pAllocations);
        +
        14063  fprintf(m_File, ",%s\n", userDataStr.GetString());
        +
        14064  Flush();
        +
        14065 }
        +
        14066 
        +
        14067 void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        +
        14068  const VkMemoryRequirements& vkMemReq,
        +
        14069  bool requiresDedicatedAllocation,
        +
        14070  bool prefersDedicatedAllocation,
        +
        14071  const VmaAllocationCreateInfo& createInfo,
        +
        14072  VmaAllocation allocation)
        +
        14073 {
        +
        14074  CallParams callParams;
        +
        14075  GetBasicParams(callParams);
        +
        14076 
        +
        14077  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14078  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        +
        14079  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForBuffer,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        +
        14080  vkMemReq.size,
        +
        14081  vkMemReq.alignment,
        +
        14082  vkMemReq.memoryTypeBits,
        +
        14083  requiresDedicatedAllocation ? 1 : 0,
        +
        14084  prefersDedicatedAllocation ? 1 : 0,
        +
        14085  createInfo.flags,
        +
        14086  createInfo.usage,
        +
        14087  createInfo.requiredFlags,
        +
        14088  createInfo.preferredFlags,
        +
        14089  createInfo.memoryTypeBits,
        +
        14090  createInfo.pool,
        +
        14091  allocation,
        +
        14092  userDataStr.GetString());
        +
        14093  Flush();
        +
        14094 }
        +
        14095 
        +
        14096 void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
        +
        14097  const VkMemoryRequirements& vkMemReq,
        +
        14098  bool requiresDedicatedAllocation,
        +
        14099  bool prefersDedicatedAllocation,
        +
        14100  const VmaAllocationCreateInfo& createInfo,
        +
        14101  VmaAllocation allocation)
        +
        14102 {
        +
        14103  CallParams callParams;
        +
        14104  GetBasicParams(callParams);
        +
        14105 
        +
        14106  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14107  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        +
        14108  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForImage,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        +
        14109  vkMemReq.size,
        +
        14110  vkMemReq.alignment,
        +
        14111  vkMemReq.memoryTypeBits,
        +
        14112  requiresDedicatedAllocation ? 1 : 0,
        +
        14113  prefersDedicatedAllocation ? 1 : 0,
        +
        14114  createInfo.flags,
        +
        14115  createInfo.usage,
        +
        14116  createInfo.requiredFlags,
        +
        14117  createInfo.preferredFlags,
        +
        14118  createInfo.memoryTypeBits,
        +
        14119  createInfo.pool,
        +
        14120  allocation,
        +
        14121  userDataStr.GetString());
        +
        14122  Flush();
        +
        14123 }
        +
        14124 
        +
        14125 void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
        +
        14126  VmaAllocation allocation)
        +
        14127 {
        +
        14128  CallParams callParams;
        +
        14129  GetBasicParams(callParams);
        +
        14130 
        +
        14131  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14132  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14133  allocation);
        +
        14134  Flush();
        +
        14135 }
        +
        14136 
        +
        14137 void VmaRecorder::RecordFreeMemoryPages(uint32_t frameIndex,
        +
        14138  uint64_t allocationCount,
        +
        14139  const VmaAllocation* pAllocations)
        +
        14140 {
        +
        14141  CallParams callParams;
        +
        14142  GetBasicParams(callParams);
        +
        14143 
        +
        14144  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14145  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemoryPages,", callParams.threadId, callParams.time, frameIndex);
        +
        14146  PrintPointerList(allocationCount, pAllocations);
        +
        14147  fprintf(m_File, "\n");
        +
        14148  Flush();
        +
        14149 }
        +
        14150 
        +
        14151 void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
        +
        14152  VmaAllocation allocation,
        +
        14153  const void* pUserData)
        +
        14154 {
        +
        14155  CallParams callParams;
        +
        14156  GetBasicParams(callParams);
        +
        14157 
        +
        14158  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14159  UserDataString userDataStr(
        +
        14160  allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
        +
        14161  pUserData);
        +
        14162  fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        +
        14163  allocation,
        +
        14164  userDataStr.GetString());
        +
        14165  Flush();
        +
        14166 }
        +
        14167 
        +
        14168 void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
        +
        14169  VmaAllocation allocation)
        +
        14170 {
        +
        14171  CallParams callParams;
        +
        14172  GetBasicParams(callParams);
        +
        14173 
        +
        14174  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14175  fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14176  allocation);
        +
        14177  Flush();
        +
        14178 }
        +
        14179 
        +
        14180 void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
        +
        14181  VmaAllocation allocation)
        +
        14182 {
        +
        14183  CallParams callParams;
        +
        14184  GetBasicParams(callParams);
        14185 
        -
        14186 void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
        -
        14187  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        -
        14188 {
        -
        14189  CallParams callParams;
        -
        14190  GetBasicParams(callParams);
        +
        14186  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14187  fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14188  allocation);
        +
        14189  Flush();
        +
        14190 }
        14191 
        -
        14192  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14193  fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        -
        14194  allocation,
        -
        14195  offset,
        -
        14196  size);
        -
        14197  Flush();
        -
        14198 }
        -
        14199 
        -
        14200 void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
        -
        14201  const VkBufferCreateInfo& bufCreateInfo,
        -
        14202  const VmaAllocationCreateInfo& allocCreateInfo,
        -
        14203  VmaAllocation allocation)
        -
        14204 {
        -
        14205  CallParams callParams;
        -
        14206  GetBasicParams(callParams);
        -
        14207 
        -
        14208  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14209  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        -
        14210  fprintf(m_File, "%u,%.3f,%u,vmaCreateBuffer,%u,%llu,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        -
        14211  bufCreateInfo.flags,
        -
        14212  bufCreateInfo.size,
        -
        14213  bufCreateInfo.usage,
        -
        14214  bufCreateInfo.sharingMode,
        -
        14215  allocCreateInfo.flags,
        -
        14216  allocCreateInfo.usage,
        -
        14217  allocCreateInfo.requiredFlags,
        -
        14218  allocCreateInfo.preferredFlags,
        -
        14219  allocCreateInfo.memoryTypeBits,
        -
        14220  allocCreateInfo.pool,
        -
        14221  allocation,
        -
        14222  userDataStr.GetString());
        -
        14223  Flush();
        -
        14224 }
        -
        14225 
        -
        14226 void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
        -
        14227  const VkImageCreateInfo& imageCreateInfo,
        -
        14228  const VmaAllocationCreateInfo& allocCreateInfo,
        -
        14229  VmaAllocation allocation)
        -
        14230 {
        -
        14231  CallParams callParams;
        -
        14232  GetBasicParams(callParams);
        -
        14233 
        -
        14234  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14235  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        -
        14236  fprintf(m_File, "%u,%.3f,%u,vmaCreateImage,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        -
        14237  imageCreateInfo.flags,
        -
        14238  imageCreateInfo.imageType,
        -
        14239  imageCreateInfo.format,
        -
        14240  imageCreateInfo.extent.width,
        -
        14241  imageCreateInfo.extent.height,
        -
        14242  imageCreateInfo.extent.depth,
        -
        14243  imageCreateInfo.mipLevels,
        -
        14244  imageCreateInfo.arrayLayers,
        -
        14245  imageCreateInfo.samples,
        -
        14246  imageCreateInfo.tiling,
        -
        14247  imageCreateInfo.usage,
        -
        14248  imageCreateInfo.sharingMode,
        -
        14249  imageCreateInfo.initialLayout,
        -
        14250  allocCreateInfo.flags,
        -
        14251  allocCreateInfo.usage,
        -
        14252  allocCreateInfo.requiredFlags,
        -
        14253  allocCreateInfo.preferredFlags,
        -
        14254  allocCreateInfo.memoryTypeBits,
        -
        14255  allocCreateInfo.pool,
        -
        14256  allocation,
        -
        14257  userDataStr.GetString());
        -
        14258  Flush();
        -
        14259 }
        -
        14260 
        -
        14261 void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
        -
        14262  VmaAllocation allocation)
        -
        14263 {
        -
        14264  CallParams callParams;
        -
        14265  GetBasicParams(callParams);
        -
        14266 
        -
        14267  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14268  fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14269  allocation);
        -
        14270  Flush();
        -
        14271 }
        -
        14272 
        -
        14273 void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
        -
        14274  VmaAllocation allocation)
        -
        14275 {
        -
        14276  CallParams callParams;
        -
        14277  GetBasicParams(callParams);
        -
        14278 
        -
        14279  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14280  fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14281  allocation);
        -
        14282  Flush();
        -
        14283 }
        -
        14284 
        -
        14285 void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
        -
        14286  VmaAllocation allocation)
        -
        14287 {
        -
        14288  CallParams callParams;
        -
        14289  GetBasicParams(callParams);
        -
        14290 
        -
        14291  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14292  fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14293  allocation);
        -
        14294  Flush();
        -
        14295 }
        -
        14296 
        -
        14297 void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
        -
        14298  VmaAllocation allocation)
        -
        14299 {
        -
        14300  CallParams callParams;
        -
        14301  GetBasicParams(callParams);
        -
        14302 
        -
        14303  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14304  fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14305  allocation);
        -
        14306  Flush();
        -
        14307 }
        -
        14308 
        -
        14309 void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
        -
        14310  VmaPool pool)
        -
        14311 {
        -
        14312  CallParams callParams;
        -
        14313  GetBasicParams(callParams);
        -
        14314 
        -
        14315  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14316  fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14317  pool);
        -
        14318  Flush();
        -
        14319 }
        -
        14320 
        -
        14321 void VmaRecorder::RecordDefragmentationBegin(uint32_t frameIndex,
        -
        14322  const VmaDefragmentationInfo2& info,
        -
        14323  VmaDefragmentationContext ctx)
        -
        14324 {
        -
        14325  CallParams callParams;
        -
        14326  GetBasicParams(callParams);
        -
        14327 
        -
        14328  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14329  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationBegin,%u,", callParams.threadId, callParams.time, frameIndex,
        -
        14330  info.flags);
        -
        14331  PrintPointerList(info.allocationCount, info.pAllocations);
        -
        14332  fprintf(m_File, ",");
        -
        14333  PrintPointerList(info.poolCount, info.pPools);
        -
        14334  fprintf(m_File, ",%llu,%u,%llu,%u,%p,%p\n",
        -
        14335  info.maxCpuBytesToMove,
        -
        14336  info.maxCpuAllocationsToMove,
        -
        14337  info.maxGpuBytesToMove,
        -
        14338  info.maxGpuAllocationsToMove,
        -
        14339  info.commandBuffer,
        -
        14340  ctx);
        -
        14341  Flush();
        -
        14342 }
        -
        14343 
        -
        14344 void VmaRecorder::RecordDefragmentationEnd(uint32_t frameIndex,
        -
        14345  VmaDefragmentationContext ctx)
        -
        14346 {
        -
        14347  CallParams callParams;
        -
        14348  GetBasicParams(callParams);
        -
        14349 
        -
        14350  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14351  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationEnd,%p\n", callParams.threadId, callParams.time, frameIndex,
        -
        14352  ctx);
        -
        14353  Flush();
        -
        14354 }
        -
        14355 
        -
        14356 void VmaRecorder::RecordSetPoolName(uint32_t frameIndex,
        -
        14357  VmaPool pool,
        -
        14358  const char* name)
        -
        14359 {
        -
        14360  CallParams callParams;
        -
        14361  GetBasicParams(callParams);
        -
        14362 
        -
        14363  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        -
        14364  fprintf(m_File, "%u,%.3f,%u,vmaSetPoolName,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        -
        14365  pool, name != VMA_NULL ? name : "");
        -
        14366  Flush();
        -
        14367 }
        -
        14368 
        -
        14369 VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
        -
        14370 {
        -
        14371  if(pUserData != VMA_NULL)
        -
        14372  {
        -
        14373  if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
        -
        14374  {
        -
        14375  m_Str = (const char*)pUserData;
        -
        14376  }
        -
        14377  else
        -
        14378  {
        -
        14379  sprintf_s(m_PtrStr, "%p", pUserData);
        -
        14380  m_Str = m_PtrStr;
        -
        14381  }
        -
        14382  }
        -
        14383  else
        -
        14384  {
        -
        14385  m_Str = "";
        -
        14386  }
        -
        14387 }
        -
        14388 
        -
        14389 void VmaRecorder::WriteConfiguration(
        -
        14390  const VkPhysicalDeviceProperties& devProps,
        -
        14391  const VkPhysicalDeviceMemoryProperties& memProps,
        -
        14392  bool dedicatedAllocationExtensionEnabled,
        -
        14393  bool bindMemory2ExtensionEnabled,
        -
        14394  bool memoryBudgetExtensionEnabled)
        -
        14395 {
        -
        14396  fprintf(m_File, "Config,Begin\n");
        -
        14397 
        -
        14398  fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
        -
        14399  fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
        -
        14400  fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
        -
        14401  fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
        -
        14402  fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
        -
        14403  fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
        -
        14404 
        -
        14405  fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
        -
        14406  fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
        -
        14407  fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
        -
        14408 
        -
        14409  fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
        -
        14410  for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
        -
        14411  {
        -
        14412  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
        -
        14413  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
        +
        14192 void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
        +
        14193  VmaAllocation allocation)
        +
        14194 {
        +
        14195  CallParams callParams;
        +
        14196  GetBasicParams(callParams);
        +
        14197 
        +
        14198  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14199  fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14200  allocation);
        +
        14201  Flush();
        +
        14202 }
        +
        14203 
        +
        14204 void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
        +
        14205  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        +
        14206 {
        +
        14207  CallParams callParams;
        +
        14208  GetBasicParams(callParams);
        +
        14209 
        +
        14210  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14211  fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        +
        14212  allocation,
        +
        14213  offset,
        +
        14214  size);
        +
        14215  Flush();
        +
        14216 }
        +
        14217 
        +
        14218 void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
        +
        14219  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        +
        14220 {
        +
        14221  CallParams callParams;
        +
        14222  GetBasicParams(callParams);
        +
        14223 
        +
        14224  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14225  fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        +
        14226  allocation,
        +
        14227  offset,
        +
        14228  size);
        +
        14229  Flush();
        +
        14230 }
        +
        14231 
        +
        14232 void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
        +
        14233  const VkBufferCreateInfo& bufCreateInfo,
        +
        14234  const VmaAllocationCreateInfo& allocCreateInfo,
        +
        14235  VmaAllocation allocation)
        +
        14236 {
        +
        14237  CallParams callParams;
        +
        14238  GetBasicParams(callParams);
        +
        14239 
        +
        14240  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14241  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        +
        14242  fprintf(m_File, "%u,%.3f,%u,vmaCreateBuffer,%u,%llu,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        +
        14243  bufCreateInfo.flags,
        +
        14244  bufCreateInfo.size,
        +
        14245  bufCreateInfo.usage,
        +
        14246  bufCreateInfo.sharingMode,
        +
        14247  allocCreateInfo.flags,
        +
        14248  allocCreateInfo.usage,
        +
        14249  allocCreateInfo.requiredFlags,
        +
        14250  allocCreateInfo.preferredFlags,
        +
        14251  allocCreateInfo.memoryTypeBits,
        +
        14252  allocCreateInfo.pool,
        +
        14253  allocation,
        +
        14254  userDataStr.GetString());
        +
        14255  Flush();
        +
        14256 }
        +
        14257 
        +
        14258 void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
        +
        14259  const VkImageCreateInfo& imageCreateInfo,
        +
        14260  const VmaAllocationCreateInfo& allocCreateInfo,
        +
        14261  VmaAllocation allocation)
        +
        14262 {
        +
        14263  CallParams callParams;
        +
        14264  GetBasicParams(callParams);
        +
        14265 
        +
        14266  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14267  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        +
        14268  fprintf(m_File, "%u,%.3f,%u,vmaCreateImage,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        +
        14269  imageCreateInfo.flags,
        +
        14270  imageCreateInfo.imageType,
        +
        14271  imageCreateInfo.format,
        +
        14272  imageCreateInfo.extent.width,
        +
        14273  imageCreateInfo.extent.height,
        +
        14274  imageCreateInfo.extent.depth,
        +
        14275  imageCreateInfo.mipLevels,
        +
        14276  imageCreateInfo.arrayLayers,
        +
        14277  imageCreateInfo.samples,
        +
        14278  imageCreateInfo.tiling,
        +
        14279  imageCreateInfo.usage,
        +
        14280  imageCreateInfo.sharingMode,
        +
        14281  imageCreateInfo.initialLayout,
        +
        14282  allocCreateInfo.flags,
        +
        14283  allocCreateInfo.usage,
        +
        14284  allocCreateInfo.requiredFlags,
        +
        14285  allocCreateInfo.preferredFlags,
        +
        14286  allocCreateInfo.memoryTypeBits,
        +
        14287  allocCreateInfo.pool,
        +
        14288  allocation,
        +
        14289  userDataStr.GetString());
        +
        14290  Flush();
        +
        14291 }
        +
        14292 
        +
        14293 void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
        +
        14294  VmaAllocation allocation)
        +
        14295 {
        +
        14296  CallParams callParams;
        +
        14297  GetBasicParams(callParams);
        +
        14298 
        +
        14299  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14300  fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14301  allocation);
        +
        14302  Flush();
        +
        14303 }
        +
        14304 
        +
        14305 void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
        +
        14306  VmaAllocation allocation)
        +
        14307 {
        +
        14308  CallParams callParams;
        +
        14309  GetBasicParams(callParams);
        +
        14310 
        +
        14311  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14312  fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14313  allocation);
        +
        14314  Flush();
        +
        14315 }
        +
        14316 
        +
        14317 void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
        +
        14318  VmaAllocation allocation)
        +
        14319 {
        +
        14320  CallParams callParams;
        +
        14321  GetBasicParams(callParams);
        +
        14322 
        +
        14323  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14324  fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14325  allocation);
        +
        14326  Flush();
        +
        14327 }
        +
        14328 
        +
        14329 void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
        +
        14330  VmaAllocation allocation)
        +
        14331 {
        +
        14332  CallParams callParams;
        +
        14333  GetBasicParams(callParams);
        +
        14334 
        +
        14335  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14336  fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14337  allocation);
        +
        14338  Flush();
        +
        14339 }
        +
        14340 
        +
        14341 void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
        +
        14342  VmaPool pool)
        +
        14343 {
        +
        14344  CallParams callParams;
        +
        14345  GetBasicParams(callParams);
        +
        14346 
        +
        14347  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14348  fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14349  pool);
        +
        14350  Flush();
        +
        14351 }
        +
        14352 
        +
        14353 void VmaRecorder::RecordDefragmentationBegin(uint32_t frameIndex,
        +
        14354  const VmaDefragmentationInfo2& info,
        +
        14355  VmaDefragmentationContext ctx)
        +
        14356 {
        +
        14357  CallParams callParams;
        +
        14358  GetBasicParams(callParams);
        +
        14359 
        +
        14360  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14361  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationBegin,%u,", callParams.threadId, callParams.time, frameIndex,
        +
        14362  info.flags);
        +
        14363  PrintPointerList(info.allocationCount, info.pAllocations);
        +
        14364  fprintf(m_File, ",");
        +
        14365  PrintPointerList(info.poolCount, info.pPools);
        +
        14366  fprintf(m_File, ",%llu,%u,%llu,%u,%p,%p\n",
        +
        14367  info.maxCpuBytesToMove,
        +
        14368  info.maxCpuAllocationsToMove,
        +
        14369  info.maxGpuBytesToMove,
        +
        14370  info.maxGpuAllocationsToMove,
        +
        14371  info.commandBuffer,
        +
        14372  ctx);
        +
        14373  Flush();
        +
        14374 }
        +
        14375 
        +
        14376 void VmaRecorder::RecordDefragmentationEnd(uint32_t frameIndex,
        +
        14377  VmaDefragmentationContext ctx)
        +
        14378 {
        +
        14379  CallParams callParams;
        +
        14380  GetBasicParams(callParams);
        +
        14381 
        +
        14382  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14383  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationEnd,%p\n", callParams.threadId, callParams.time, frameIndex,
        +
        14384  ctx);
        +
        14385  Flush();
        +
        14386 }
        +
        14387 
        +
        14388 void VmaRecorder::RecordSetPoolName(uint32_t frameIndex,
        +
        14389  VmaPool pool,
        +
        14390  const char* name)
        +
        14391 {
        +
        14392  CallParams callParams;
        +
        14393  GetBasicParams(callParams);
        +
        14394 
        +
        14395  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        +
        14396  fprintf(m_File, "%u,%.3f,%u,vmaSetPoolName,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        +
        14397  pool, name != VMA_NULL ? name : "");
        +
        14398  Flush();
        +
        14399 }
        +
        14400 
        +
        14401 VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
        +
        14402 {
        +
        14403  if(pUserData != VMA_NULL)
        +
        14404  {
        +
        14405  if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
        +
        14406  {
        +
        14407  m_Str = (const char*)pUserData;
        +
        14408  }
        +
        14409  else
        +
        14410  {
        +
        14411  sprintf_s(m_PtrStr, "%p", pUserData);
        +
        14412  m_Str = m_PtrStr;
        +
        14413  }
        14414  }
        -
        14415  fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
        -
        14416  for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
        -
        14417  {
        -
        14418  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
        -
        14419  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
        -
        14420  }
        -
        14421 
        -
        14422  fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
        -
        14423  fprintf(m_File, "Extension,VK_KHR_bind_memory2,%u\n", bindMemory2ExtensionEnabled ? 1 : 0);
        -
        14424  fprintf(m_File, "Extension,VK_EXT_memory_budget,%u\n", memoryBudgetExtensionEnabled ? 1 : 0);
        -
        14425 
        -
        14426  fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
        -
        14427  fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
        -
        14428  fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
        -
        14429  fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
        -
        14430  fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
        -
        14431  fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
        -
        14432  fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
        -
        14433  fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
        -
        14434  fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        -
        14435 
        -
        14436  fprintf(m_File, "Config,End\n");
        -
        14437 }
        -
        14438 
        -
        14439 void VmaRecorder::GetBasicParams(CallParams& outParams)
        -
        14440 {
        -
        14441  outParams.threadId = GetCurrentThreadId();
        -
        14442 
        -
        14443  LARGE_INTEGER counter;
        -
        14444  QueryPerformanceCounter(&counter);
        -
        14445  outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq;
        -
        14446 }
        -
        14447 
        -
        14448 void VmaRecorder::PrintPointerList(uint64_t count, const VmaAllocation* pItems)
        -
        14449 {
        -
        14450  if(count)
        -
        14451  {
        -
        14452  fprintf(m_File, "%p", pItems[0]);
        -
        14453  for(uint64_t i = 1; i < count; ++i)
        -
        14454  {
        -
        14455  fprintf(m_File, " %p", pItems[i]);
        -
        14456  }
        -
        14457  }
        -
        14458 }
        -
        14459 
        -
        14460 void VmaRecorder::Flush()
        -
        14461 {
        -
        14462  if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
        -
        14463  {
        -
        14464  fflush(m_File);
        -
        14465  }
        -
        14466 }
        -
        14467 
        -
        14468 #endif // #if VMA_RECORDING_ENABLED
        -
        14469 
        -
        14471 // VmaAllocationObjectAllocator
        -
        14472 
        -
        14473 VmaAllocationObjectAllocator::VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks) :
        -
        14474  m_Allocator(pAllocationCallbacks, 1024)
        +
        14415  else
        +
        14416  {
        +
        14417  m_Str = "";
        +
        14418  }
        +
        14419 }
        +
        14420 
        +
        14421 void VmaRecorder::WriteConfiguration(
        +
        14422  const VkPhysicalDeviceProperties& devProps,
        +
        14423  const VkPhysicalDeviceMemoryProperties& memProps,
        +
        14424  uint32_t vulkanApiVersion,
        +
        14425  bool dedicatedAllocationExtensionEnabled,
        +
        14426  bool bindMemory2ExtensionEnabled,
        +
        14427  bool memoryBudgetExtensionEnabled)
        +
        14428 {
        +
        14429  fprintf(m_File, "Config,Begin\n");
        +
        14430 
        +
        14431  fprintf(m_File, "VulkanApiVersion,%u,%u\n", VK_VERSION_MAJOR(vulkanApiVersion), VK_VERSION_MINOR(vulkanApiVersion));
        +
        14432 
        +
        14433  fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
        +
        14434  fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
        +
        14435  fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
        +
        14436  fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
        +
        14437  fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
        +
        14438  fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
        +
        14439 
        +
        14440  fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
        +
        14441  fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
        +
        14442  fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
        +
        14443 
        +
        14444  fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
        +
        14445  for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
        +
        14446  {
        +
        14447  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
        +
        14448  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
        +
        14449  }
        +
        14450  fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
        +
        14451  for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
        +
        14452  {
        +
        14453  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
        +
        14454  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
        +
        14455  }
        +
        14456 
        +
        14457  fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
        +
        14458  fprintf(m_File, "Extension,VK_KHR_bind_memory2,%u\n", bindMemory2ExtensionEnabled ? 1 : 0);
        +
        14459  fprintf(m_File, "Extension,VK_EXT_memory_budget,%u\n", memoryBudgetExtensionEnabled ? 1 : 0);
        +
        14460 
        +
        14461  fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
        +
        14462  fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
        +
        14463  fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
        +
        14464  fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
        +
        14465  fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
        +
        14466  fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
        +
        14467  fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
        +
        14468  fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
        +
        14469  fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        +
        14470 
        +
        14471  fprintf(m_File, "Config,End\n");
        +
        14472 }
        +
        14473 
        +
        14474 void VmaRecorder::GetBasicParams(CallParams& outParams)
        14475 {
        -
        14476 }
        +
        14476  outParams.threadId = GetCurrentThreadId();
        14477 
        -
        14478 VmaAllocation VmaAllocationObjectAllocator::Allocate()
        -
        14479 {
        -
        14480  VmaMutexLock mutexLock(m_Mutex);
        -
        14481  return m_Allocator.Alloc();
        -
        14482 }
        -
        14483 
        -
        14484 void VmaAllocationObjectAllocator::Free(VmaAllocation hAlloc)
        -
        14485 {
        -
        14486  VmaMutexLock mutexLock(m_Mutex);
        -
        14487  m_Allocator.Free(hAlloc);
        -
        14488 }
        -
        14489 
        -
        14491 // VmaAllocator_T
        -
        14492 
        -
        14493 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
        -
        14494  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
        -
        14495  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
        -
        14496  m_UseKhrBindMemory2((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0),
        -
        14497  m_UseExtMemoryBudget((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0),
        -
        14498  m_hDevice(pCreateInfo->device),
        -
        14499  m_hInstance(pCreateInfo->instance),
        -
        14500  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
        -
        14501  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
        -
        14502  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
        -
        14503  m_AllocationObjectAllocator(&m_AllocationCallbacks),
        -
        14504  m_HeapSizeLimitMask(0),
        -
        14505  m_PreferredLargeHeapBlockSize(0),
        -
        14506  m_PhysicalDevice(pCreateInfo->physicalDevice),
        -
        14507  m_CurrentFrameIndex(0),
        -
        14508  m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),
        -
        14509  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
        -
        14510  m_NextPoolId(0)
        -
        14511 #if VMA_RECORDING_ENABLED
        -
        14512  ,m_pRecorder(VMA_NULL)
        -
        14513 #endif
        +
        14478  LARGE_INTEGER counter;
        +
        14479  QueryPerformanceCounter(&counter);
        +
        14480  outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq;
        +
        14481 }
        +
        14482 
        +
        14483 void VmaRecorder::PrintPointerList(uint64_t count, const VmaAllocation* pItems)
        +
        14484 {
        +
        14485  if(count)
        +
        14486  {
        +
        14487  fprintf(m_File, "%p", pItems[0]);
        +
        14488  for(uint64_t i = 1; i < count; ++i)
        +
        14489  {
        +
        14490  fprintf(m_File, " %p", pItems[i]);
        +
        14491  }
        +
        14492  }
        +
        14493 }
        +
        14494 
        +
        14495 void VmaRecorder::Flush()
        +
        14496 {
        +
        14497  if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
        +
        14498  {
        +
        14499  fflush(m_File);
        +
        14500  }
        +
        14501 }
        +
        14502 
        +
        14503 #endif // #if VMA_RECORDING_ENABLED
        +
        14504 
        +
        14506 // VmaAllocationObjectAllocator
        +
        14507 
        +
        14508 VmaAllocationObjectAllocator::VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks) :
        +
        14509  m_Allocator(pAllocationCallbacks, 1024)
        +
        14510 {
        +
        14511 }
        +
        14512 
        +
        14513 VmaAllocation VmaAllocationObjectAllocator::Allocate()
        14514 {
        -
        14515  if(VMA_DEBUG_DETECT_CORRUPTION)
        -
        14516  {
        -
        14517  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
        -
        14518  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
        -
        14519  }
        -
        14520 
        -
        14521  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
        -
        14522 
        -
        14523 #if !(VMA_DEDICATED_ALLOCATION)
        -
        14524  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
        -
        14525  {
        -
        14526  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
        -
        14527  }
        -
        14528 #endif
        -
        14529 #if !(VMA_BIND_MEMORY2)
        -
        14530  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
        -
        14531  {
        -
        14532  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT set but required extension is disabled by preprocessor macros.");
        -
        14533  }
        -
        14534 #endif
        -
        14535 #if !(VMA_MEMORY_BUDGET)
        -
        14536  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
        -
        14537  {
        -
        14538  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT set but required extension is disabled by preprocessor macros.");
        -
        14539  }
        -
        14540 #endif
        -
        14541 
        -
        14542  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
        -
        14543  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
        -
        14544  memset(&m_MemProps, 0, sizeof(m_MemProps));
        -
        14545 
        -
        14546  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
        -
        14547  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
        -
        14548  memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));
        -
        14549 
        -
        14550  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
        -
        14551  {
        -
        14552  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
        -
        14553  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
        -
        14554  }
        -
        14555 
        -
        14556  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
        -
        14557 
        -
        14558  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
        -
        14559  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
        -
        14560 
        -
        14561  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_ALIGNMENT));
        -
        14562  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY));
        -
        14563  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.bufferImageGranularity));
        -
        14564  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.nonCoherentAtomSize));
        -
        14565 
        -
        14566  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
        -
        14567  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        -
        14568 
        -
        14569  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
        -
        14570  {
        -
        14571  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        -
        14572  {
        -
        14573  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
        -
        14574  if(limit != VK_WHOLE_SIZE)
        -
        14575  {
        -
        14576  m_HeapSizeLimitMask |= 1u << heapIndex;
        -
        14577  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
        -
        14578  {
        -
        14579  m_MemProps.memoryHeaps[heapIndex].size = limit;
        -
        14580  }
        -
        14581  }
        -
        14582  }
        -
        14583  }
        -
        14584 
        -
        14585  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        -
        14586  {
        -
        14587  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
        -
        14588 
        -
        14589  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
        -
        14590  this,
        -
        14591  VK_NULL_HANDLE, // hParentPool
        -
        14592  memTypeIndex,
        -
        14593  preferredBlockSize,
        -
        14594  0,
        -
        14595  SIZE_MAX,
        -
        14596  GetBufferImageGranularity(),
        -
        14597  pCreateInfo->frameInUseCount,
        -
        14598  false, // explicitBlockSize
        -
        14599  false); // linearAlgorithm
        -
        14600  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
        -
        14601  // becase minBlockCount is 0.
        -
        14602  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
        -
        14603 
        -
        14604  }
        -
        14605 }
        +
        14515  VmaMutexLock mutexLock(m_Mutex);
        +
        14516  return m_Allocator.Alloc();
        +
        14517 }
        +
        14518 
        +
        14519 void VmaAllocationObjectAllocator::Free(VmaAllocation hAlloc)
        +
        14520 {
        +
        14521  VmaMutexLock mutexLock(m_Mutex);
        +
        14522  m_Allocator.Free(hAlloc);
        +
        14523 }
        +
        14524 
        +
        14526 // VmaAllocator_T
        +
        14527 
        +
        14528 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
        +
        14529  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
        +
        14530  m_VulkanApiVersion(pCreateInfo->vulkanApiVersion != 0 ? pCreateInfo->vulkanApiVersion : VK_API_VERSION_1_0),
        +
        14531  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
        +
        14532  m_UseKhrBindMemory2((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0),
        +
        14533  m_UseExtMemoryBudget((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0),
        +
        14534  m_hDevice(pCreateInfo->device),
        +
        14535  m_hInstance(pCreateInfo->instance),
        +
        14536  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
        +
        14537  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
        +
        14538  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
        +
        14539  m_AllocationObjectAllocator(&m_AllocationCallbacks),
        +
        14540  m_HeapSizeLimitMask(0),
        +
        14541  m_PreferredLargeHeapBlockSize(0),
        +
        14542  m_PhysicalDevice(pCreateInfo->physicalDevice),
        +
        14543  m_CurrentFrameIndex(0),
        +
        14544  m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),
        +
        14545  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
        +
        14546  m_NextPoolId(0)
        +
        14547 #if VMA_RECORDING_ENABLED
        +
        14548  ,m_pRecorder(VMA_NULL)
        +
        14549 #endif
        +
        14550 {
        +
        14551  if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        +
        14552  {
        +
        14553  m_UseKhrDedicatedAllocation = false;
        +
        14554  m_UseKhrBindMemory2 = false;
        +
        14555  }
        +
        14556 
        +
        14557  if(VMA_DEBUG_DETECT_CORRUPTION)
        +
        14558  {
        +
        14559  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
        +
        14560  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
        +
        14561  }
        +
        14562 
        +
        14563  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
        +
        14564 
        +
        14565  if(m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0))
        +
        14566  {
        +
        14567 #if !(VMA_DEDICATED_ALLOCATION)
        +
        14568  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
        +
        14569  {
        +
        14570  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
        +
        14571  }
        +
        14572 #endif
        +
        14573 #if !(VMA_BIND_MEMORY2)
        +
        14574  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
        +
        14575  {
        +
        14576  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT set but required extension is disabled by preprocessor macros.");
        +
        14577  }
        +
        14578 #endif
        +
        14579  }
        +
        14580 #if !(VMA_MEMORY_BUDGET)
        +
        14581  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
        +
        14582  {
        +
        14583  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT set but required extension is disabled by preprocessor macros.");
        +
        14584  }
        +
        14585 #endif
        +
        14586 #if VMA_VULKAN_VERSION < 1001000
        +
        14587  if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        +
        14588  {
        +
        14589  VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_1 but required Vulkan version is disabled by preprocessor macros.");
        +
        14590  }
        +
        14591 #endif
        +
        14592 
        +
        14593  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
        +
        14594  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
        +
        14595  memset(&m_MemProps, 0, sizeof(m_MemProps));
        +
        14596 
        +
        14597  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
        +
        14598  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
        +
        14599  memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));
        +
        14600 
        +
        14601  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
        +
        14602  {
        +
        14603  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
        +
        14604  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
        +
        14605  }
        14606 
        -
        14607 VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
        -
        14608 {
        -
        14609  VkResult res = VK_SUCCESS;
        -
        14610 
        -
        14611  if(pCreateInfo->pRecordSettings != VMA_NULL &&
        -
        14612  !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
        -
        14613  {
        -
        14614 #if VMA_RECORDING_ENABLED
        -
        14615  m_pRecorder = vma_new(this, VmaRecorder)();
        -
        14616  res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
        -
        14617  if(res != VK_SUCCESS)
        -
        14618  {
        -
        14619  return res;
        -
        14620  }
        -
        14621  m_pRecorder->WriteConfiguration(
        -
        14622  m_PhysicalDeviceProperties,
        -
        14623  m_MemProps,
        -
        14624  m_UseKhrDedicatedAllocation,
        -
        14625  m_UseKhrBindMemory2,
        -
        14626  m_UseExtMemoryBudget);
        -
        14627  m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
        -
        14628 #else
        -
        14629  VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
        -
        14630  return VK_ERROR_FEATURE_NOT_PRESENT;
        -
        14631 #endif
        -
        14632  }
        -
        14633 
        -
        14634 #if VMA_MEMORY_BUDGET
        -
        14635  if(m_UseExtMemoryBudget)
        -
        14636  {
        -
        14637  UpdateVulkanBudget();
        -
        14638  }
        -
        14639 #endif // #if VMA_MEMORY_BUDGET
        -
        14640 
        -
        14641  return res;
        -
        14642 }
        -
        14643 
        -
        14644 VmaAllocator_T::~VmaAllocator_T()
        -
        14645 {
        -
        14646 #if VMA_RECORDING_ENABLED
        -
        14647  if(m_pRecorder != VMA_NULL)
        -
        14648  {
        -
        14649  m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
        -
        14650  vma_delete(this, m_pRecorder);
        -
        14651  }
        -
        14652 #endif
        -
        14653 
        -
        14654  VMA_ASSERT(m_Pools.empty());
        -
        14655 
        -
        14656  for(size_t i = GetMemoryTypeCount(); i--; )
        -
        14657  {
        -
        14658  if(m_pDedicatedAllocations[i] != VMA_NULL && !m_pDedicatedAllocations[i]->empty())
        -
        14659  {
        -
        14660  VMA_ASSERT(0 && "Unfreed dedicated allocations found.");
        -
        14661  }
        -
        14662 
        -
        14663  vma_delete(this, m_pDedicatedAllocations[i]);
        -
        14664  vma_delete(this, m_pBlockVectors[i]);
        -
        14665  }
        -
        14666 }
        -
        14667 
        -
        14668 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
        -
        14669 {
        -
        14670 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        -
        14671  m_VulkanFunctions.vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)vkGetPhysicalDeviceProperties;
        -
        14672  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vkGetPhysicalDeviceMemoryProperties;
        -
        14673  m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
        -
        14674  m_VulkanFunctions.vkFreeMemory = (PFN_vkFreeMemory)vkFreeMemory;
        -
        14675  m_VulkanFunctions.vkMapMemory = (PFN_vkMapMemory)vkMapMemory;
        -
        14676  m_VulkanFunctions.vkUnmapMemory = (PFN_vkUnmapMemory)vkUnmapMemory;
        -
        14677  m_VulkanFunctions.vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)vkFlushMappedMemoryRanges;
        -
        14678  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)vkInvalidateMappedMemoryRanges;
        -
        14679  m_VulkanFunctions.vkBindBufferMemory = (PFN_vkBindBufferMemory)vkBindBufferMemory;
        -
        14680  m_VulkanFunctions.vkBindImageMemory = (PFN_vkBindImageMemory)vkBindImageMemory;
        -
        14681  m_VulkanFunctions.vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)vkGetBufferMemoryRequirements;
        -
        14682  m_VulkanFunctions.vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vkGetImageMemoryRequirements;
        -
        14683  m_VulkanFunctions.vkCreateBuffer = (PFN_vkCreateBuffer)vkCreateBuffer;
        -
        14684  m_VulkanFunctions.vkDestroyBuffer = (PFN_vkDestroyBuffer)vkDestroyBuffer;
        -
        14685  m_VulkanFunctions.vkCreateImage = (PFN_vkCreateImage)vkCreateImage;
        -
        14686  m_VulkanFunctions.vkDestroyImage = (PFN_vkDestroyImage)vkDestroyImage;
        -
        14687  m_VulkanFunctions.vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)vkCmdCopyBuffer;
        -
        14688 #if VMA_DEDICATED_ALLOCATION
        -
        14689  if(m_UseKhrDedicatedAllocation)
        -
        14690  {
        -
        14691  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
        -
        14692  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
        -
        14693  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
        -
        14694  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
        -
        14695  }
        -
        14696 #endif // #if VMA_DEDICATED_ALLOCATION
        -
        14697 #if VMA_BIND_MEMORY2
        -
        14698  if(m_UseKhrBindMemory2)
        -
        14699  {
        -
        14700  m_VulkanFunctions.vkBindBufferMemory2KHR =
        -
        14701  (PFN_vkBindBufferMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindBufferMemory2KHR");
        -
        14702  m_VulkanFunctions.vkBindImageMemory2KHR =
        -
        14703  (PFN_vkBindImageMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindImageMemory2KHR");
        -
        14704  }
        -
        14705 #endif // #if VMA_BIND_MEMORY2
        -
        14706 #if VMA_MEMORY_BUDGET
        -
        14707  if(m_UseExtMemoryBudget)
        -
        14708  {
        -
        14709  VMA_ASSERT(m_hInstance != VK_NULL_HANDLE);
        -
        14710  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR =
        -
        14711  (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)vkGetInstanceProcAddr(m_hInstance, "vkGetPhysicalDeviceMemoryProperties2KHR");
        -
        14712  }
        -
        14713 #endif // #if VMA_MEMORY_BUDGET
        -
        14714 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        -
        14715 
        -
        14716 #define VMA_COPY_IF_NOT_NULL(funcName) \
        -
        14717  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
        -
        14718 
        -
        14719  if(pVulkanFunctions != VMA_NULL)
        -
        14720  {
        -
        14721  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
        -
        14722  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
        -
        14723  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
        -
        14724  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
        -
        14725  VMA_COPY_IF_NOT_NULL(vkMapMemory);
        -
        14726  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
        -
        14727  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
        -
        14728  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
        -
        14729  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
        -
        14730  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
        -
        14731  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
        -
        14732  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
        -
        14733  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
        -
        14734  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
        -
        14735  VMA_COPY_IF_NOT_NULL(vkCreateImage);
        -
        14736  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
        -
        14737  VMA_COPY_IF_NOT_NULL(vkCmdCopyBuffer);
        -
        14738 #if VMA_DEDICATED_ALLOCATION
        -
        14739  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
        -
        14740  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
        -
        14741 #endif
        -
        14742 #if VMA_BIND_MEMORY2
        -
        14743  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory2KHR);
        -
        14744  VMA_COPY_IF_NOT_NULL(vkBindImageMemory2KHR);
        -
        14745 #endif
        -
        14746 #if VMA_MEMORY_BUDGET
        -
        14747  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
        -
        14748 #endif
        -
        14749  }
        -
        14750 
        -
        14751 #undef VMA_COPY_IF_NOT_NULL
        -
        14752 
        -
        14753  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
        -
        14754  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
        -
        14755  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
        -
        14756  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
        -
        14757  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
        -
        14758  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
        -
        14759  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
        -
        14760  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
        -
        14761  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
        -
        14762  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
        -
        14763  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
        -
        14764  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
        -
        14765  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
        -
        14766  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
        -
        14767  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
        -
        14768  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
        -
        14769  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
        -
        14770  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
        -
        14771  VMA_ASSERT(m_VulkanFunctions.vkCmdCopyBuffer != VMA_NULL);
        -
        14772 #if VMA_DEDICATED_ALLOCATION
        -
        14773  if(m_UseKhrDedicatedAllocation)
        -
        14774  {
        -
        14775  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
        -
        14776  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
        -
        14777  }
        -
        14778 #endif
        -
        14779 #if VMA_BIND_MEMORY2
        -
        14780  if(m_UseKhrBindMemory2)
        -
        14781  {
        -
        14782  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL);
        -
        14783  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL);
        -
        14784  }
        -
        14785 #endif
        -
        14786 #if VMA_MEMORY_BUDGET
        -
        14787  if(m_UseExtMemoryBudget)
        +
        14607  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
        +
        14608 
        +
        14609  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
        +
        14610  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
        +
        14611 
        +
        14612  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_ALIGNMENT));
        +
        14613  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY));
        +
        14614  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.bufferImageGranularity));
        +
        14615  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.nonCoherentAtomSize));
        +
        14616 
        +
        14617  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
        +
        14618  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        +
        14619 
        +
        14620  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
        +
        14621  {
        +
        14622  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        +
        14623  {
        +
        14624  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
        +
        14625  if(limit != VK_WHOLE_SIZE)
        +
        14626  {
        +
        14627  m_HeapSizeLimitMask |= 1u << heapIndex;
        +
        14628  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
        +
        14629  {
        +
        14630  m_MemProps.memoryHeaps[heapIndex].size = limit;
        +
        14631  }
        +
        14632  }
        +
        14633  }
        +
        14634  }
        +
        14635 
        +
        14636  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        +
        14637  {
        +
        14638  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
        +
        14639 
        +
        14640  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
        +
        14641  this,
        +
        14642  VK_NULL_HANDLE, // hParentPool
        +
        14643  memTypeIndex,
        +
        14644  preferredBlockSize,
        +
        14645  0,
        +
        14646  SIZE_MAX,
        +
        14647  GetBufferImageGranularity(),
        +
        14648  pCreateInfo->frameInUseCount,
        +
        14649  false, // explicitBlockSize
        +
        14650  false); // linearAlgorithm
        +
        14651  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
        +
        14652  // becase minBlockCount is 0.
        +
        14653  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
        +
        14654 
        +
        14655  }
        +
        14656 }
        +
        14657 
        +
        14658 VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
        +
        14659 {
        +
        14660  VkResult res = VK_SUCCESS;
        +
        14661 
        +
        14662  if(pCreateInfo->pRecordSettings != VMA_NULL &&
        +
        14663  !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
        +
        14664  {
        +
        14665 #if VMA_RECORDING_ENABLED
        +
        14666  m_pRecorder = vma_new(this, VmaRecorder)();
        +
        14667  res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
        +
        14668  if(res != VK_SUCCESS)
        +
        14669  {
        +
        14670  return res;
        +
        14671  }
        +
        14672  m_pRecorder->WriteConfiguration(
        +
        14673  m_PhysicalDeviceProperties,
        +
        14674  m_MemProps,
        +
        14675  m_VulkanApiVersion,
        +
        14676  m_UseKhrDedicatedAllocation,
        +
        14677  m_UseKhrBindMemory2,
        +
        14678  m_UseExtMemoryBudget);
        +
        14679  m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
        +
        14680 #else
        +
        14681  VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
        +
        14682  return VK_ERROR_FEATURE_NOT_PRESENT;
        +
        14683 #endif
        +
        14684  }
        +
        14685 
        +
        14686 #if VMA_MEMORY_BUDGET
        +
        14687  if(m_UseExtMemoryBudget)
        +
        14688  {
        +
        14689  UpdateVulkanBudget();
        +
        14690  }
        +
        14691 #endif // #if VMA_MEMORY_BUDGET
        +
        14692 
        +
        14693  return res;
        +
        14694 }
        +
        14695 
        +
        14696 VmaAllocator_T::~VmaAllocator_T()
        +
        14697 {
        +
        14698 #if VMA_RECORDING_ENABLED
        +
        14699  if(m_pRecorder != VMA_NULL)
        +
        14700  {
        +
        14701  m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
        +
        14702  vma_delete(this, m_pRecorder);
        +
        14703  }
        +
        14704 #endif
        +
        14705 
        +
        14706  VMA_ASSERT(m_Pools.empty());
        +
        14707 
        +
        14708  for(size_t i = GetMemoryTypeCount(); i--; )
        +
        14709  {
        +
        14710  if(m_pDedicatedAllocations[i] != VMA_NULL && !m_pDedicatedAllocations[i]->empty())
        +
        14711  {
        +
        14712  VMA_ASSERT(0 && "Unfreed dedicated allocations found.");
        +
        14713  }
        +
        14714 
        +
        14715  vma_delete(this, m_pDedicatedAllocations[i]);
        +
        14716  vma_delete(this, m_pBlockVectors[i]);
        +
        14717  }
        +
        14718 }
        +
        14719 
        +
        14720 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
        +
        14721 {
        +
        14722 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        +
        14723  m_VulkanFunctions.vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)vkGetPhysicalDeviceProperties;
        +
        14724  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vkGetPhysicalDeviceMemoryProperties;
        +
        14725  m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
        +
        14726  m_VulkanFunctions.vkFreeMemory = (PFN_vkFreeMemory)vkFreeMemory;
        +
        14727  m_VulkanFunctions.vkMapMemory = (PFN_vkMapMemory)vkMapMemory;
        +
        14728  m_VulkanFunctions.vkUnmapMemory = (PFN_vkUnmapMemory)vkUnmapMemory;
        +
        14729  m_VulkanFunctions.vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)vkFlushMappedMemoryRanges;
        +
        14730  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)vkInvalidateMappedMemoryRanges;
        +
        14731  m_VulkanFunctions.vkBindBufferMemory = (PFN_vkBindBufferMemory)vkBindBufferMemory;
        +
        14732  m_VulkanFunctions.vkBindImageMemory = (PFN_vkBindImageMemory)vkBindImageMemory;
        +
        14733  m_VulkanFunctions.vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)vkGetBufferMemoryRequirements;
        +
        14734  m_VulkanFunctions.vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vkGetImageMemoryRequirements;
        +
        14735  m_VulkanFunctions.vkCreateBuffer = (PFN_vkCreateBuffer)vkCreateBuffer;
        +
        14736  m_VulkanFunctions.vkDestroyBuffer = (PFN_vkDestroyBuffer)vkDestroyBuffer;
        +
        14737  m_VulkanFunctions.vkCreateImage = (PFN_vkCreateImage)vkCreateImage;
        +
        14738  m_VulkanFunctions.vkDestroyImage = (PFN_vkDestroyImage)vkDestroyImage;
        +
        14739  m_VulkanFunctions.vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)vkCmdCopyBuffer;
        +
        14740 #if VMA_VULKAN_VERSION >= 1001000
        +
        14741  if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        +
        14742  {
        +
        14743  VMA_ASSERT(m_hInstance != VK_NULL_HANDLE);
        +
        14744  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
        +
        14745  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2");
        +
        14746  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
        +
        14747  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2");
        +
        14748  m_VulkanFunctions.vkBindBufferMemory2KHR =
        +
        14749  (PFN_vkBindBufferMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindBufferMemory2");
        +
        14750  m_VulkanFunctions.vkBindImageMemory2KHR =
        +
        14751  (PFN_vkBindImageMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindImageMemory2");
        +
        14752  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR =
        +
        14753  (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)vkGetInstanceProcAddr(m_hInstance, "vkGetPhysicalDeviceMemoryProperties2");
        +
        14754  }
        +
        14755 #endif
        +
        14756 #if VMA_DEDICATED_ALLOCATION
        +
        14757  if(m_UseKhrDedicatedAllocation)
        +
        14758  {
        +
        14759  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
        +
        14760  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
        +
        14761  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
        +
        14762  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
        +
        14763  }
        +
        14764 #endif
        +
        14765 #if VMA_BIND_MEMORY2
        +
        14766  if(m_UseKhrBindMemory2)
        +
        14767  {
        +
        14768  m_VulkanFunctions.vkBindBufferMemory2KHR =
        +
        14769  (PFN_vkBindBufferMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindBufferMemory2KHR");
        +
        14770  m_VulkanFunctions.vkBindImageMemory2KHR =
        +
        14771  (PFN_vkBindImageMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindImageMemory2KHR");
        +
        14772  }
        +
        14773 #endif // #if VMA_BIND_MEMORY2
        +
        14774 #if VMA_MEMORY_BUDGET
        +
        14775  if(m_UseExtMemoryBudget && m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0))
        +
        14776  {
        +
        14777  VMA_ASSERT(m_hInstance != VK_NULL_HANDLE);
        +
        14778  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR =
        +
        14779  (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)vkGetInstanceProcAddr(m_hInstance, "vkGetPhysicalDeviceMemoryProperties2KHR");
        +
        14780  }
        +
        14781 #endif // #if VMA_MEMORY_BUDGET
        +
        14782 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        +
        14783 
        +
        14784 #define VMA_COPY_IF_NOT_NULL(funcName) \
        +
        14785  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
        +
        14786 
        +
        14787  if(pVulkanFunctions != VMA_NULL)
        14788  {
        -
        14789  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
        -
        14790  }
        -
        14791 #endif
        -
        14792 }
        -
        14793 
        -
        14794 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
        -
        14795 {
        -
        14796  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        -
        14797  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        -
        14798  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
        -
        14799  return VmaAlignUp(isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize, (VkDeviceSize)32);
        -
        14800 }
        -
        14801 
        -
        14802 VkResult VmaAllocator_T::AllocateMemoryOfType(
        -
        14803  VkDeviceSize size,
        -
        14804  VkDeviceSize alignment,
        -
        14805  bool dedicatedAllocation,
        -
        14806  VkBuffer dedicatedBuffer,
        -
        14807  VkImage dedicatedImage,
        -
        14808  const VmaAllocationCreateInfo& createInfo,
        -
        14809  uint32_t memTypeIndex,
        -
        14810  VmaSuballocationType suballocType,
        -
        14811  size_t allocationCount,
        -
        14812  VmaAllocation* pAllocations)
        -
        14813 {
        -
        14814  VMA_ASSERT(pAllocations != VMA_NULL);
        -
        14815  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);
        -
        14816 
        -
        14817  VmaAllocationCreateInfo finalCreateInfo = createInfo;
        +
        14789  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
        +
        14790  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
        +
        14791  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
        +
        14792  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
        +
        14793  VMA_COPY_IF_NOT_NULL(vkMapMemory);
        +
        14794  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
        +
        14795  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
        +
        14796  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
        +
        14797  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
        +
        14798  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
        +
        14799  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
        +
        14800  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
        +
        14801  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
        +
        14802  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
        +
        14803  VMA_COPY_IF_NOT_NULL(vkCreateImage);
        +
        14804  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
        +
        14805  VMA_COPY_IF_NOT_NULL(vkCmdCopyBuffer);
        +
        14806 #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        14807  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
        +
        14808  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
        +
        14809 #endif
        +
        14810 #if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
        +
        14811  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory2KHR);
        +
        14812  VMA_COPY_IF_NOT_NULL(vkBindImageMemory2KHR);
        +
        14813 #endif
        +
        14814 #if VMA_MEMORY_BUDGET
        +
        14815  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
        +
        14816 #endif
        +
        14817  }
        14818 
        -
        14819  // If memory type is not HOST_VISIBLE, disable MAPPED.
        -
        14820  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        -
        14821  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        -
        14822  {
        -
        14823  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
        -
        14824  }
        -
        14825  // If memory is lazily allocated, it should be always dedicated.
        -
        14826  if(finalCreateInfo.usage == VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED)
        -
        14827  {
        -
        14828  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        -
        14829  }
        -
        14830 
        -
        14831  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
        -
        14832  VMA_ASSERT(blockVector);
        -
        14833 
        -
        14834  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
        -
        14835  bool preferDedicatedMemory =
        -
        14836  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
        -
        14837  dedicatedAllocation ||
        -
        14838  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
        -
        14839  size > preferredBlockSize / 2;
        -
        14840 
        -
        14841  if(preferDedicatedMemory &&
        -
        14842  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
        -
        14843  finalCreateInfo.pool == VK_NULL_HANDLE)
        -
        14844  {
        -
        14845  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        -
        14846  }
        -
        14847 
        -
        14848  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
        +
        14819 #undef VMA_COPY_IF_NOT_NULL
        +
        14820 
        +
        14821  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
        +
        14822  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
        +
        14823  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
        +
        14824  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
        +
        14825  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
        +
        14826  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
        +
        14827  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
        +
        14828  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
        +
        14829  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
        +
        14830  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
        +
        14831  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
        +
        14832  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
        +
        14833  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
        +
        14834  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
        +
        14835  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
        +
        14836  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
        +
        14837  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
        +
        14838  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
        +
        14839  VMA_ASSERT(m_VulkanFunctions.vkCmdCopyBuffer != VMA_NULL);
        +
        14840 #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        14841  if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrDedicatedAllocation)
        +
        14842  {
        +
        14843  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
        +
        14844  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
        +
        14845  }
        +
        14846 #endif
        +
        14847 #if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
        +
        14848  if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrBindMemory2)
        14849  {
        -
        14850  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        -
        14851  {
        -
        14852  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        14853  }
        -
        14854  else
        -
        14855  {
        -
        14856  return AllocateDedicatedMemory(
        -
        14857  size,
        -
        14858  suballocType,
        -
        14859  memTypeIndex,
        -
        14860  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
        -
        14861  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        -
        14862  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        -
        14863  finalCreateInfo.pUserData,
        -
        14864  dedicatedBuffer,
        -
        14865  dedicatedImage,
        -
        14866  allocationCount,
        -
        14867  pAllocations);
        -
        14868  }
        -
        14869  }
        -
        14870  else
        -
        14871  {
        -
        14872  VkResult res = blockVector->Allocate(
        -
        14873  m_CurrentFrameIndex.load(),
        -
        14874  size,
        -
        14875  alignment,
        -
        14876  finalCreateInfo,
        -
        14877  suballocType,
        -
        14878  allocationCount,
        -
        14879  pAllocations);
        -
        14880  if(res == VK_SUCCESS)
        -
        14881  {
        -
        14882  return res;
        -
        14883  }
        +
        14850  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL);
        +
        14851  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL);
        +
        14852  }
        +
        14853 #endif
        +
        14854 #if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
        +
        14855  if(m_UseExtMemoryBudget || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        +
        14856  {
        +
        14857  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
        +
        14858  }
        +
        14859 #endif
        +
        14860 }
        +
        14861 
        +
        14862 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
        +
        14863 {
        +
        14864  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        +
        14865  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        +
        14866  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
        +
        14867  return VmaAlignUp(isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize, (VkDeviceSize)32);
        +
        14868 }
        +
        14869 
        +
        14870 VkResult VmaAllocator_T::AllocateMemoryOfType(
        +
        14871  VkDeviceSize size,
        +
        14872  VkDeviceSize alignment,
        +
        14873  bool dedicatedAllocation,
        +
        14874  VkBuffer dedicatedBuffer,
        +
        14875  VkImage dedicatedImage,
        +
        14876  const VmaAllocationCreateInfo& createInfo,
        +
        14877  uint32_t memTypeIndex,
        +
        14878  VmaSuballocationType suballocType,
        +
        14879  size_t allocationCount,
        +
        14880  VmaAllocation* pAllocations)
        +
        14881 {
        +
        14882  VMA_ASSERT(pAllocations != VMA_NULL);
        +
        14883  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);
        14884 
        -
        14885  // 5. Try dedicated memory.
        -
        14886  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        -
        14887  {
        -
        14888  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        14889  }
        -
        14890  else
        -
        14891  {
        -
        14892  res = AllocateDedicatedMemory(
        -
        14893  size,
        -
        14894  suballocType,
        -
        14895  memTypeIndex,
        -
        14896  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
        -
        14897  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        -
        14898  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        -
        14899  finalCreateInfo.pUserData,
        -
        14900  dedicatedBuffer,
        -
        14901  dedicatedImage,
        -
        14902  allocationCount,
        -
        14903  pAllocations);
        -
        14904  if(res == VK_SUCCESS)
        -
        14905  {
        -
        14906  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
        -
        14907  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
        -
        14908  return VK_SUCCESS;
        -
        14909  }
        -
        14910  else
        -
        14911  {
        -
        14912  // Everything failed: Return error code.
        -
        14913  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        -
        14914  return res;
        -
        14915  }
        -
        14916  }
        -
        14917  }
        -
        14918 }
        -
        14919 
        -
        14920 VkResult VmaAllocator_T::AllocateDedicatedMemory(
        -
        14921  VkDeviceSize size,
        -
        14922  VmaSuballocationType suballocType,
        -
        14923  uint32_t memTypeIndex,
        -
        14924  bool withinBudget,
        -
        14925  bool map,
        -
        14926  bool isUserDataString,
        -
        14927  void* pUserData,
        -
        14928  VkBuffer dedicatedBuffer,
        -
        14929  VkImage dedicatedImage,
        -
        14930  size_t allocationCount,
        -
        14931  VmaAllocation* pAllocations)
        -
        14932 {
        -
        14933  VMA_ASSERT(allocationCount > 0 && pAllocations);
        -
        14934 
        -
        14935  if(withinBudget)
        -
        14936  {
        -
        14937  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        -
        14938  VmaBudget heapBudget = {};
        -
        14939  GetBudget(&heapBudget, heapIndex, 1);
        -
        14940  if(heapBudget.usage + size * allocationCount > heapBudget.budget)
        -
        14941  {
        -
        14942  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        14943  }
        -
        14944  }
        -
        14945 
        -
        14946  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        -
        14947  allocInfo.memoryTypeIndex = memTypeIndex;
        -
        14948  allocInfo.allocationSize = size;
        -
        14949 
        -
        14950 #if VMA_DEDICATED_ALLOCATION
        -
        14951  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
        -
        14952  if(m_UseKhrDedicatedAllocation)
        -
        14953  {
        -
        14954  if(dedicatedBuffer != VK_NULL_HANDLE)
        +
        14885  VmaAllocationCreateInfo finalCreateInfo = createInfo;
        +
        14886 
        +
        14887  // If memory type is not HOST_VISIBLE, disable MAPPED.
        +
        14888  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        +
        14889  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        +
        14890  {
        +
        14891  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
        +
        14892  }
        +
        14893  // If memory is lazily allocated, it should be always dedicated.
        +
        14894  if(finalCreateInfo.usage == VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED)
        +
        14895  {
        +
        14896  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        +
        14897  }
        +
        14898 
        +
        14899  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
        +
        14900  VMA_ASSERT(blockVector);
        +
        14901 
        +
        14902  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
        +
        14903  bool preferDedicatedMemory =
        +
        14904  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
        +
        14905  dedicatedAllocation ||
        +
        14906  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
        +
        14907  size > preferredBlockSize / 2;
        +
        14908 
        +
        14909  if(preferDedicatedMemory &&
        +
        14910  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
        +
        14911  finalCreateInfo.pool == VK_NULL_HANDLE)
        +
        14912  {
        +
        14913  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        +
        14914  }
        +
        14915 
        +
        14916  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
        +
        14917  {
        +
        14918  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        +
        14919  {
        +
        14920  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        14921  }
        +
        14922  else
        +
        14923  {
        +
        14924  return AllocateDedicatedMemory(
        +
        14925  size,
        +
        14926  suballocType,
        +
        14927  memTypeIndex,
        +
        14928  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
        +
        14929  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        +
        14930  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        +
        14931  finalCreateInfo.pUserData,
        +
        14932  dedicatedBuffer,
        +
        14933  dedicatedImage,
        +
        14934  allocationCount,
        +
        14935  pAllocations);
        +
        14936  }
        +
        14937  }
        +
        14938  else
        +
        14939  {
        +
        14940  VkResult res = blockVector->Allocate(
        +
        14941  m_CurrentFrameIndex.load(),
        +
        14942  size,
        +
        14943  alignment,
        +
        14944  finalCreateInfo,
        +
        14945  suballocType,
        +
        14946  allocationCount,
        +
        14947  pAllocations);
        +
        14948  if(res == VK_SUCCESS)
        +
        14949  {
        +
        14950  return res;
        +
        14951  }
        +
        14952 
        +
        14953  // 5. Try dedicated memory.
        +
        14954  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        14955  {
        -
        14956  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
        -
        14957  dedicatedAllocInfo.buffer = dedicatedBuffer;
        -
        14958  allocInfo.pNext = &dedicatedAllocInfo;
        -
        14959  }
        -
        14960  else if(dedicatedImage != VK_NULL_HANDLE)
        -
        14961  {
        -
        14962  dedicatedAllocInfo.image = dedicatedImage;
        -
        14963  allocInfo.pNext = &dedicatedAllocInfo;
        -
        14964  }
        -
        14965  }
        -
        14966 #endif // #if VMA_DEDICATED_ALLOCATION
        -
        14967 
        -
        14968  size_t allocIndex;
        -
        14969  VkResult res = VK_SUCCESS;
        -
        14970  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        -
        14971  {
        -
        14972  res = AllocateDedicatedMemoryPage(
        -
        14973  size,
        -
        14974  suballocType,
        -
        14975  memTypeIndex,
        -
        14976  allocInfo,
        -
        14977  map,
        -
        14978  isUserDataString,
        -
        14979  pUserData,
        -
        14980  pAllocations + allocIndex);
        -
        14981  if(res != VK_SUCCESS)
        -
        14982  {
        -
        14983  break;
        +
        14956  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        14957  }
        +
        14958  else
        +
        14959  {
        +
        14960  res = AllocateDedicatedMemory(
        +
        14961  size,
        +
        14962  suballocType,
        +
        14963  memTypeIndex,
        +
        14964  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
        +
        14965  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        +
        14966  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        +
        14967  finalCreateInfo.pUserData,
        +
        14968  dedicatedBuffer,
        +
        14969  dedicatedImage,
        +
        14970  allocationCount,
        +
        14971  pAllocations);
        +
        14972  if(res == VK_SUCCESS)
        +
        14973  {
        +
        14974  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
        +
        14975  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
        +
        14976  return VK_SUCCESS;
        +
        14977  }
        +
        14978  else
        +
        14979  {
        +
        14980  // Everything failed: Return error code.
        +
        14981  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        +
        14982  return res;
        +
        14983  }
        14984  }
        14985  }
        -
        14986 
        -
        14987  if(res == VK_SUCCESS)
        -
        14988  {
        -
        14989  // Register them in m_pDedicatedAllocations.
        -
        14990  {
        -
        14991  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        -
        14992  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        -
        14993  VMA_ASSERT(pDedicatedAllocations);
        -
        14994  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        -
        14995  {
        -
        14996  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, pAllocations[allocIndex]);
        -
        14997  }
        -
        14998  }
        -
        14999 
        -
        15000  VMA_DEBUG_LOG(" Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
        -
        15001  }
        -
        15002  else
        -
        15003  {
        -
        15004  // Free all already created allocations.
        -
        15005  while(allocIndex--)
        -
        15006  {
        -
        15007  VmaAllocation currAlloc = pAllocations[allocIndex];
        -
        15008  VkDeviceMemory hMemory = currAlloc->GetMemory();
        -
        15009 
        -
        15010  /*
        -
        15011  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
        -
        15012  before vkFreeMemory.
        -
        15013 
        -
        15014  if(currAlloc->GetMappedData() != VMA_NULL)
        -
        15015  {
        -
        15016  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
        -
        15017  }
        -
        15018  */
        -
        15019 
        -
        15020  FreeVulkanMemory(memTypeIndex, currAlloc->GetSize(), hMemory);
        -
        15021  m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), currAlloc->GetSize());
        -
        15022  currAlloc->SetUserData(this, VMA_NULL);
        -
        15023  currAlloc->Dtor();
        -
        15024  m_AllocationObjectAllocator.Free(currAlloc);
        -
        15025  }
        -
        15026 
        -
        15027  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
        -
        15028  }
        -
        15029 
        -
        15030  return res;
        -
        15031 }
        -
        15032 
        -
        15033 VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(
        -
        15034  VkDeviceSize size,
        -
        15035  VmaSuballocationType suballocType,
        -
        15036  uint32_t memTypeIndex,
        -
        15037  const VkMemoryAllocateInfo& allocInfo,
        -
        15038  bool map,
        -
        15039  bool isUserDataString,
        -
        15040  void* pUserData,
        -
        15041  VmaAllocation* pAllocation)
        -
        15042 {
        -
        15043  VkDeviceMemory hMemory = VK_NULL_HANDLE;
        -
        15044  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
        -
        15045  if(res < 0)
        -
        15046  {
        -
        15047  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        -
        15048  return res;
        -
        15049  }
        -
        15050 
        -
        15051  void* pMappedData = VMA_NULL;
        -
        15052  if(map)
        -
        15053  {
        -
        15054  res = (*m_VulkanFunctions.vkMapMemory)(
        -
        15055  m_hDevice,
        -
        15056  hMemory,
        -
        15057  0,
        -
        15058  VK_WHOLE_SIZE,
        -
        15059  0,
        -
        15060  &pMappedData);
        -
        15061  if(res < 0)
        -
        15062  {
        -
        15063  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        -
        15064  FreeVulkanMemory(memTypeIndex, size, hMemory);
        -
        15065  return res;
        +
        14986 }
        +
        14987 
        +
        14988 VkResult VmaAllocator_T::AllocateDedicatedMemory(
        +
        14989  VkDeviceSize size,
        +
        14990  VmaSuballocationType suballocType,
        +
        14991  uint32_t memTypeIndex,
        +
        14992  bool withinBudget,
        +
        14993  bool map,
        +
        14994  bool isUserDataString,
        +
        14995  void* pUserData,
        +
        14996  VkBuffer dedicatedBuffer,
        +
        14997  VkImage dedicatedImage,
        +
        14998  size_t allocationCount,
        +
        14999  VmaAllocation* pAllocations)
        +
        15000 {
        +
        15001  VMA_ASSERT(allocationCount > 0 && pAllocations);
        +
        15002 
        +
        15003  if(withinBudget)
        +
        15004  {
        +
        15005  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        +
        15006  VmaBudget heapBudget = {};
        +
        15007  GetBudget(&heapBudget, heapIndex, 1);
        +
        15008  if(heapBudget.usage + size * allocationCount > heapBudget.budget)
        +
        15009  {
        +
        15010  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15011  }
        +
        15012  }
        +
        15013 
        +
        15014  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        +
        15015  allocInfo.memoryTypeIndex = memTypeIndex;
        +
        15016  allocInfo.allocationSize = size;
        +
        15017 
        +
        15018 #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        15019  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
        +
        15020  if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        +
        15021  {
        +
        15022  if(dedicatedBuffer != VK_NULL_HANDLE)
        +
        15023  {
        +
        15024  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
        +
        15025  dedicatedAllocInfo.buffer = dedicatedBuffer;
        +
        15026  allocInfo.pNext = &dedicatedAllocInfo;
        +
        15027  }
        +
        15028  else if(dedicatedImage != VK_NULL_HANDLE)
        +
        15029  {
        +
        15030  dedicatedAllocInfo.image = dedicatedImage;
        +
        15031  allocInfo.pNext = &dedicatedAllocInfo;
        +
        15032  }
        +
        15033  }
        +
        15034 #endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        15035 
        +
        15036  size_t allocIndex;
        +
        15037  VkResult res = VK_SUCCESS;
        +
        15038  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        +
        15039  {
        +
        15040  res = AllocateDedicatedMemoryPage(
        +
        15041  size,
        +
        15042  suballocType,
        +
        15043  memTypeIndex,
        +
        15044  allocInfo,
        +
        15045  map,
        +
        15046  isUserDataString,
        +
        15047  pUserData,
        +
        15048  pAllocations + allocIndex);
        +
        15049  if(res != VK_SUCCESS)
        +
        15050  {
        +
        15051  break;
        +
        15052  }
        +
        15053  }
        +
        15054 
        +
        15055  if(res == VK_SUCCESS)
        +
        15056  {
        +
        15057  // Register them in m_pDedicatedAllocations.
        +
        15058  {
        +
        15059  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        +
        15060  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        +
        15061  VMA_ASSERT(pDedicatedAllocations);
        +
        15062  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        +
        15063  {
        +
        15064  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, pAllocations[allocIndex]);
        +
        15065  }
        15066  }
        -
        15067  }
        -
        15068 
        -
        15069  *pAllocation = m_AllocationObjectAllocator.Allocate();
        -
        15070  (*pAllocation)->Ctor(m_CurrentFrameIndex.load(), isUserDataString);
        -
        15071  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
        -
        15072  (*pAllocation)->SetUserData(this, pUserData);
        -
        15073  m_Budget.AddAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), size);
        -
        15074  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        -
        15075  {
        -
        15076  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        -
        15077  }
        -
        15078 
        -
        15079  return VK_SUCCESS;
        -
        15080 }
        -
        15081 
        -
        15082 void VmaAllocator_T::GetBufferMemoryRequirements(
        -
        15083  VkBuffer hBuffer,
        -
        15084  VkMemoryRequirements& memReq,
        -
        15085  bool& requiresDedicatedAllocation,
        -
        15086  bool& prefersDedicatedAllocation) const
        -
        15087 {
        -
        15088 #if VMA_DEDICATED_ALLOCATION
        -
        15089  if(m_UseKhrDedicatedAllocation)
        -
        15090  {
        -
        15091  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
        -
        15092  memReqInfo.buffer = hBuffer;
        -
        15093 
        -
        15094  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        -
        15095 
        -
        15096  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        -
        15097  memReq2.pNext = &memDedicatedReq;
        -
        15098 
        -
        15099  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        +
        15067 
        +
        15068  VMA_DEBUG_LOG(" Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
        +
        15069  }
        +
        15070  else
        +
        15071  {
        +
        15072  // Free all already created allocations.
        +
        15073  while(allocIndex--)
        +
        15074  {
        +
        15075  VmaAllocation currAlloc = pAllocations[allocIndex];
        +
        15076  VkDeviceMemory hMemory = currAlloc->GetMemory();
        +
        15077 
        +
        15078  /*
        +
        15079  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
        +
        15080  before vkFreeMemory.
        +
        15081 
        +
        15082  if(currAlloc->GetMappedData() != VMA_NULL)
        +
        15083  {
        +
        15084  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
        +
        15085  }
        +
        15086  */
        +
        15087 
        +
        15088  FreeVulkanMemory(memTypeIndex, currAlloc->GetSize(), hMemory);
        +
        15089  m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), currAlloc->GetSize());
        +
        15090  currAlloc->SetUserData(this, VMA_NULL);
        +
        15091  currAlloc->Dtor();
        +
        15092  m_AllocationObjectAllocator.Free(currAlloc);
        +
        15093  }
        +
        15094 
        +
        15095  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
        +
        15096  }
        +
        15097 
        +
        15098  return res;
        +
        15099 }
        15100 
        -
        15101  memReq = memReq2.memoryRequirements;
        -
        15102  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        -
        15103  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        -
        15104  }
        -
        15105  else
        -
        15106 #endif // #if VMA_DEDICATED_ALLOCATION
        -
        15107  {
        -
        15108  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
        -
        15109  requiresDedicatedAllocation = false;
        -
        15110  prefersDedicatedAllocation = false;
        -
        15111  }
        -
        15112 }
        -
        15113 
        -
        15114 void VmaAllocator_T::GetImageMemoryRequirements(
        -
        15115  VkImage hImage,
        -
        15116  VkMemoryRequirements& memReq,
        -
        15117  bool& requiresDedicatedAllocation,
        -
        15118  bool& prefersDedicatedAllocation) const
        -
        15119 {
        -
        15120 #if VMA_DEDICATED_ALLOCATION
        -
        15121  if(m_UseKhrDedicatedAllocation)
        -
        15122  {
        -
        15123  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
        -
        15124  memReqInfo.image = hImage;
        -
        15125 
        -
        15126  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        -
        15127 
        -
        15128  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        -
        15129  memReq2.pNext = &memDedicatedReq;
        -
        15130 
        -
        15131  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        -
        15132 
        -
        15133  memReq = memReq2.memoryRequirements;
        -
        15134  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        -
        15135  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        -
        15136  }
        -
        15137  else
        -
        15138 #endif // #if VMA_DEDICATED_ALLOCATION
        -
        15139  {
        -
        15140  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
        -
        15141  requiresDedicatedAllocation = false;
        -
        15142  prefersDedicatedAllocation = false;
        -
        15143  }
        -
        15144 }
        -
        15145 
        -
        15146 VkResult VmaAllocator_T::AllocateMemory(
        -
        15147  const VkMemoryRequirements& vkMemReq,
        -
        15148  bool requiresDedicatedAllocation,
        -
        15149  bool prefersDedicatedAllocation,
        -
        15150  VkBuffer dedicatedBuffer,
        -
        15151  VkImage dedicatedImage,
        -
        15152  const VmaAllocationCreateInfo& createInfo,
        -
        15153  VmaSuballocationType suballocType,
        -
        15154  size_t allocationCount,
        -
        15155  VmaAllocation* pAllocations)
        -
        15156 {
        -
        15157  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
        -
        15158 
        -
        15159  VMA_ASSERT(VmaIsPow2(vkMemReq.alignment));
        -
        15160 
        -
        15161  if(vkMemReq.size == 0)
        -
        15162  {
        -
        15163  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        15164  }
        -
        15165  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
        -
        15166  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        -
        15167  {
        -
        15168  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
        -
        15169  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        15170  }
        -
        15171  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        -
        15172  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
        -
        15173  {
        -
        15174  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
        -
        15175  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        15176  }
        -
        15177  if(requiresDedicatedAllocation)
        -
        15178  {
        -
        15179  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        -
        15180  {
        -
        15181  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
        -
        15182  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        15183  }
        -
        15184  if(createInfo.pool != VK_NULL_HANDLE)
        -
        15185  {
        -
        15186  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
        -
        15187  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        15188  }
        -
        15189  }
        -
        15190  if((createInfo.pool != VK_NULL_HANDLE) &&
        -
        15191  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
        -
        15192  {
        -
        15193  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
        -
        15194  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        15195  }
        -
        15196 
        -
        15197  if(createInfo.pool != VK_NULL_HANDLE)
        -
        15198  {
        -
        15199  const VkDeviceSize alignmentForPool = VMA_MAX(
        -
        15200  vkMemReq.alignment,
        -
        15201  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
        -
        15202 
        -
        15203  VmaAllocationCreateInfo createInfoForPool = createInfo;
        -
        15204  // If memory type is not HOST_VISIBLE, disable MAPPED.
        -
        15205  if((createInfoForPool.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        -
        15206  (m_MemProps.memoryTypes[createInfo.pool->m_BlockVector.GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        -
        15207  {
        -
        15208  createInfoForPool.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
        -
        15209  }
        -
        15210 
        -
        15211  return createInfo.pool->m_BlockVector.Allocate(
        -
        15212  m_CurrentFrameIndex.load(),
        -
        15213  vkMemReq.size,
        -
        15214  alignmentForPool,
        -
        15215  createInfoForPool,
        -
        15216  suballocType,
        -
        15217  allocationCount,
        -
        15218  pAllocations);
        -
        15219  }
        -
        15220  else
        -
        15221  {
        -
        15222  // Bit mask of memory Vulkan types acceptable for this allocation.
        -
        15223  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
        -
        15224  uint32_t memTypeIndex = UINT32_MAX;
        -
        15225  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        -
        15226  if(res == VK_SUCCESS)
        -
        15227  {
        -
        15228  VkDeviceSize alignmentForMemType = VMA_MAX(
        -
        15229  vkMemReq.alignment,
        -
        15230  GetMemoryTypeMinAlignment(memTypeIndex));
        -
        15231 
        -
        15232  res = AllocateMemoryOfType(
        -
        15233  vkMemReq.size,
        -
        15234  alignmentForMemType,
        -
        15235  requiresDedicatedAllocation || prefersDedicatedAllocation,
        -
        15236  dedicatedBuffer,
        -
        15237  dedicatedImage,
        -
        15238  createInfo,
        -
        15239  memTypeIndex,
        -
        15240  suballocType,
        -
        15241  allocationCount,
        -
        15242  pAllocations);
        -
        15243  // Succeeded on first try.
        -
        15244  if(res == VK_SUCCESS)
        -
        15245  {
        -
        15246  return res;
        -
        15247  }
        -
        15248  // Allocation from this memory type failed. Try other compatible memory types.
        -
        15249  else
        -
        15250  {
        -
        15251  for(;;)
        -
        15252  {
        -
        15253  // Remove old memTypeIndex from list of possibilities.
        -
        15254  memoryTypeBits &= ~(1u << memTypeIndex);
        -
        15255  // Find alternative memTypeIndex.
        -
        15256  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        -
        15257  if(res == VK_SUCCESS)
        -
        15258  {
        -
        15259  alignmentForMemType = VMA_MAX(
        -
        15260  vkMemReq.alignment,
        -
        15261  GetMemoryTypeMinAlignment(memTypeIndex));
        -
        15262 
        -
        15263  res = AllocateMemoryOfType(
        -
        15264  vkMemReq.size,
        -
        15265  alignmentForMemType,
        -
        15266  requiresDedicatedAllocation || prefersDedicatedAllocation,
        -
        15267  dedicatedBuffer,
        -
        15268  dedicatedImage,
        -
        15269  createInfo,
        -
        15270  memTypeIndex,
        -
        15271  suballocType,
        -
        15272  allocationCount,
        -
        15273  pAllocations);
        -
        15274  // Allocation from this alternative memory type succeeded.
        -
        15275  if(res == VK_SUCCESS)
        -
        15276  {
        -
        15277  return res;
        -
        15278  }
        -
        15279  // else: Allocation from this memory type failed. Try next one - next loop iteration.
        -
        15280  }
        -
        15281  // No other matching memory type index could be found.
        -
        15282  else
        -
        15283  {
        -
        15284  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
        -
        15285  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        15286  }
        -
        15287  }
        -
        15288  }
        -
        15289  }
        -
        15290  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
        -
        15291  else
        -
        15292  return res;
        -
        15293  }
        -
        15294 }
        -
        15295 
        -
        15296 void VmaAllocator_T::FreeMemory(
        -
        15297  size_t allocationCount,
        -
        15298  const VmaAllocation* pAllocations)
        -
        15299 {
        -
        15300  VMA_ASSERT(pAllocations);
        -
        15301 
        -
        15302  for(size_t allocIndex = allocationCount; allocIndex--; )
        -
        15303  {
        -
        15304  VmaAllocation allocation = pAllocations[allocIndex];
        -
        15305 
        -
        15306  if(allocation != VK_NULL_HANDLE)
        -
        15307  {
        -
        15308  if(TouchAllocation(allocation))
        -
        15309  {
        -
        15310  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        -
        15311  {
        -
        15312  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
        -
        15313  }
        -
        15314 
        -
        15315  switch(allocation->GetType())
        -
        15316  {
        -
        15317  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        -
        15318  {
        -
        15319  VmaBlockVector* pBlockVector = VMA_NULL;
        -
        15320  VmaPool hPool = allocation->GetBlock()->GetParentPool();
        -
        15321  if(hPool != VK_NULL_HANDLE)
        -
        15322  {
        -
        15323  pBlockVector = &hPool->m_BlockVector;
        -
        15324  }
        -
        15325  else
        -
        15326  {
        -
        15327  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        -
        15328  pBlockVector = m_pBlockVectors[memTypeIndex];
        -
        15329  }
        -
        15330  pBlockVector->Free(allocation);
        -
        15331  }
        -
        15332  break;
        -
        15333  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        -
        15334  FreeDedicatedMemory(allocation);
        -
        15335  break;
        -
        15336  default:
        -
        15337  VMA_ASSERT(0);
        -
        15338  }
        -
        15339  }
        -
        15340 
        -
        15341  // Do this regardless of whether the allocation is lost. Lost allocations still account to Budget.AllocationBytes.
        -
        15342  m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
        -
        15343  allocation->SetUserData(this, VMA_NULL);
        -
        15344  allocation->Dtor();
        -
        15345  m_AllocationObjectAllocator.Free(allocation);
        -
        15346  }
        -
        15347  }
        -
        15348 }
        -
        15349 
        -
        15350 VkResult VmaAllocator_T::ResizeAllocation(
        -
        15351  const VmaAllocation alloc,
        -
        15352  VkDeviceSize newSize)
        -
        15353 {
        -
        15354  // This function is deprecated and so it does nothing. It's left for backward compatibility.
        -
        15355  if(newSize == 0 || alloc->GetLastUseFrameIndex() == VMA_FRAME_INDEX_LOST)
        -
        15356  {
        -
        15357  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        15358  }
        -
        15359  if(newSize == alloc->GetSize())
        -
        15360  {
        -
        15361  return VK_SUCCESS;
        -
        15362  }
        -
        15363  return VK_ERROR_OUT_OF_POOL_MEMORY;
        -
        15364 }
        -
        15365 
        -
        15366 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
        +
        15101 VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(
        +
        15102  VkDeviceSize size,
        +
        15103  VmaSuballocationType suballocType,
        +
        15104  uint32_t memTypeIndex,
        +
        15105  const VkMemoryAllocateInfo& allocInfo,
        +
        15106  bool map,
        +
        15107  bool isUserDataString,
        +
        15108  void* pUserData,
        +
        15109  VmaAllocation* pAllocation)
        +
        15110 {
        +
        15111  VkDeviceMemory hMemory = VK_NULL_HANDLE;
        +
        15112  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
        +
        15113  if(res < 0)
        +
        15114  {
        +
        15115  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        +
        15116  return res;
        +
        15117  }
        +
        15118 
        +
        15119  void* pMappedData = VMA_NULL;
        +
        15120  if(map)
        +
        15121  {
        +
        15122  res = (*m_VulkanFunctions.vkMapMemory)(
        +
        15123  m_hDevice,
        +
        15124  hMemory,
        +
        15125  0,
        +
        15126  VK_WHOLE_SIZE,
        +
        15127  0,
        +
        15128  &pMappedData);
        +
        15129  if(res < 0)
        +
        15130  {
        +
        15131  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        +
        15132  FreeVulkanMemory(memTypeIndex, size, hMemory);
        +
        15133  return res;
        +
        15134  }
        +
        15135  }
        +
        15136 
        +
        15137  *pAllocation = m_AllocationObjectAllocator.Allocate();
        +
        15138  (*pAllocation)->Ctor(m_CurrentFrameIndex.load(), isUserDataString);
        +
        15139  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
        +
        15140  (*pAllocation)->SetUserData(this, pUserData);
        +
        15141  m_Budget.AddAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), size);
        +
        15142  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        +
        15143  {
        +
        15144  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        +
        15145  }
        +
        15146 
        +
        15147  return VK_SUCCESS;
        +
        15148 }
        +
        15149 
        +
        15150 void VmaAllocator_T::GetBufferMemoryRequirements(
        +
        15151  VkBuffer hBuffer,
        +
        15152  VkMemoryRequirements& memReq,
        +
        15153  bool& requiresDedicatedAllocation,
        +
        15154  bool& prefersDedicatedAllocation) const
        +
        15155 {
        +
        15156 #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        15157  if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        +
        15158  {
        +
        15159  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
        +
        15160  memReqInfo.buffer = hBuffer;
        +
        15161 
        +
        15162  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        +
        15163 
        +
        15164  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        +
        15165  memReq2.pNext = &memDedicatedReq;
        +
        15166 
        +
        15167  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        +
        15168 
        +
        15169  memReq = memReq2.memoryRequirements;
        +
        15170  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        +
        15171  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        +
        15172  }
        +
        15173  else
        +
        15174 #endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        15175  {
        +
        15176  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
        +
        15177  requiresDedicatedAllocation = false;
        +
        15178  prefersDedicatedAllocation = false;
        +
        15179  }
        +
        15180 }
        +
        15181 
        +
        15182 void VmaAllocator_T::GetImageMemoryRequirements(
        +
        15183  VkImage hImage,
        +
        15184  VkMemoryRequirements& memReq,
        +
        15185  bool& requiresDedicatedAllocation,
        +
        15186  bool& prefersDedicatedAllocation) const
        +
        15187 {
        +
        15188 #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        15189  if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
        +
        15190  {
        +
        15191  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
        +
        15192  memReqInfo.image = hImage;
        +
        15193 
        +
        15194  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        +
        15195 
        +
        15196  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        +
        15197  memReq2.pNext = &memDedicatedReq;
        +
        15198 
        +
        15199  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        +
        15200 
        +
        15201  memReq = memReq2.memoryRequirements;
        +
        15202  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        +
        15203  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        +
        15204  }
        +
        15205  else
        +
        15206 #endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
        +
        15207  {
        +
        15208  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
        +
        15209  requiresDedicatedAllocation = false;
        +
        15210  prefersDedicatedAllocation = false;
        +
        15211  }
        +
        15212 }
        +
        15213 
        +
        15214 VkResult VmaAllocator_T::AllocateMemory(
        +
        15215  const VkMemoryRequirements& vkMemReq,
        +
        15216  bool requiresDedicatedAllocation,
        +
        15217  bool prefersDedicatedAllocation,
        +
        15218  VkBuffer dedicatedBuffer,
        +
        15219  VkImage dedicatedImage,
        +
        15220  const VmaAllocationCreateInfo& createInfo,
        +
        15221  VmaSuballocationType suballocType,
        +
        15222  size_t allocationCount,
        +
        15223  VmaAllocation* pAllocations)
        +
        15224 {
        +
        15225  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
        +
        15226 
        +
        15227  VMA_ASSERT(VmaIsPow2(vkMemReq.alignment));
        +
        15228 
        +
        15229  if(vkMemReq.size == 0)
        +
        15230  {
        +
        15231  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        15232  }
        +
        15233  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
        +
        15234  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        +
        15235  {
        +
        15236  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
        +
        15237  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15238  }
        +
        15239  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        +
        15240  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
        +
        15241  {
        +
        15242  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
        +
        15243  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15244  }
        +
        15245  if(requiresDedicatedAllocation)
        +
        15246  {
        +
        15247  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        +
        15248  {
        +
        15249  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
        +
        15250  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15251  }
        +
        15252  if(createInfo.pool != VK_NULL_HANDLE)
        +
        15253  {
        +
        15254  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
        +
        15255  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15256  }
        +
        15257  }
        +
        15258  if((createInfo.pool != VK_NULL_HANDLE) &&
        +
        15259  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
        +
        15260  {
        +
        15261  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
        +
        15262  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15263  }
        +
        15264 
        +
        15265  if(createInfo.pool != VK_NULL_HANDLE)
        +
        15266  {
        +
        15267  const VkDeviceSize alignmentForPool = VMA_MAX(
        +
        15268  vkMemReq.alignment,
        +
        15269  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
        +
        15270 
        +
        15271  VmaAllocationCreateInfo createInfoForPool = createInfo;
        +
        15272  // If memory type is not HOST_VISIBLE, disable MAPPED.
        +
        15273  if((createInfoForPool.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        +
        15274  (m_MemProps.memoryTypes[createInfo.pool->m_BlockVector.GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        +
        15275  {
        +
        15276  createInfoForPool.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
        +
        15277  }
        +
        15278 
        +
        15279  return createInfo.pool->m_BlockVector.Allocate(
        +
        15280  m_CurrentFrameIndex.load(),
        +
        15281  vkMemReq.size,
        +
        15282  alignmentForPool,
        +
        15283  createInfoForPool,
        +
        15284  suballocType,
        +
        15285  allocationCount,
        +
        15286  pAllocations);
        +
        15287  }
        +
        15288  else
        +
        15289  {
        +
        15290  // Bit mask of memory Vulkan types acceptable for this allocation.
        +
        15291  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
        +
        15292  uint32_t memTypeIndex = UINT32_MAX;
        +
        15293  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        +
        15294  if(res == VK_SUCCESS)
        +
        15295  {
        +
        15296  VkDeviceSize alignmentForMemType = VMA_MAX(
        +
        15297  vkMemReq.alignment,
        +
        15298  GetMemoryTypeMinAlignment(memTypeIndex));
        +
        15299 
        +
        15300  res = AllocateMemoryOfType(
        +
        15301  vkMemReq.size,
        +
        15302  alignmentForMemType,
        +
        15303  requiresDedicatedAllocation || prefersDedicatedAllocation,
        +
        15304  dedicatedBuffer,
        +
        15305  dedicatedImage,
        +
        15306  createInfo,
        +
        15307  memTypeIndex,
        +
        15308  suballocType,
        +
        15309  allocationCount,
        +
        15310  pAllocations);
        +
        15311  // Succeeded on first try.
        +
        15312  if(res == VK_SUCCESS)
        +
        15313  {
        +
        15314  return res;
        +
        15315  }
        +
        15316  // Allocation from this memory type failed. Try other compatible memory types.
        +
        15317  else
        +
        15318  {
        +
        15319  for(;;)
        +
        15320  {
        +
        15321  // Remove old memTypeIndex from list of possibilities.
        +
        15322  memoryTypeBits &= ~(1u << memTypeIndex);
        +
        15323  // Find alternative memTypeIndex.
        +
        15324  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        +
        15325  if(res == VK_SUCCESS)
        +
        15326  {
        +
        15327  alignmentForMemType = VMA_MAX(
        +
        15328  vkMemReq.alignment,
        +
        15329  GetMemoryTypeMinAlignment(memTypeIndex));
        +
        15330 
        +
        15331  res = AllocateMemoryOfType(
        +
        15332  vkMemReq.size,
        +
        15333  alignmentForMemType,
        +
        15334  requiresDedicatedAllocation || prefersDedicatedAllocation,
        +
        15335  dedicatedBuffer,
        +
        15336  dedicatedImage,
        +
        15337  createInfo,
        +
        15338  memTypeIndex,
        +
        15339  suballocType,
        +
        15340  allocationCount,
        +
        15341  pAllocations);
        +
        15342  // Allocation from this alternative memory type succeeded.
        +
        15343  if(res == VK_SUCCESS)
        +
        15344  {
        +
        15345  return res;
        +
        15346  }
        +
        15347  // else: Allocation from this memory type failed. Try next one - next loop iteration.
        +
        15348  }
        +
        15349  // No other matching memory type index could be found.
        +
        15350  else
        +
        15351  {
        +
        15352  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
        +
        15353  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15354  }
        +
        15355  }
        +
        15356  }
        +
        15357  }
        +
        15358  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
        +
        15359  else
        +
        15360  return res;
        +
        15361  }
        +
        15362 }
        +
        15363 
        +
        15364 void VmaAllocator_T::FreeMemory(
        +
        15365  size_t allocationCount,
        +
        15366  const VmaAllocation* pAllocations)
        15367 {
        -
        15368  // Initialize.
        -
        15369  InitStatInfo(pStats->total);
        -
        15370  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
        -
        15371  InitStatInfo(pStats->memoryType[i]);
        -
        15372  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        -
        15373  InitStatInfo(pStats->memoryHeap[i]);
        -
        15374 
        -
        15375  // Process default pools.
        -
        15376  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        -
        15377  {
        -
        15378  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        -
        15379  VMA_ASSERT(pBlockVector);
        -
        15380  pBlockVector->AddStats(pStats);
        -
        15381  }
        +
        15368  VMA_ASSERT(pAllocations);
        +
        15369 
        +
        15370  for(size_t allocIndex = allocationCount; allocIndex--; )
        +
        15371  {
        +
        15372  VmaAllocation allocation = pAllocations[allocIndex];
        +
        15373 
        +
        15374  if(allocation != VK_NULL_HANDLE)
        +
        15375  {
        +
        15376  if(TouchAllocation(allocation))
        +
        15377  {
        +
        15378  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        +
        15379  {
        +
        15380  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
        +
        15381  }
        15382 
        -
        15383  // Process custom pools.
        -
        15384  {
        -
        15385  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        -
        15386  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        -
        15387  {
        -
        15388  m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);
        -
        15389  }
        -
        15390  }
        -
        15391 
        -
        15392  // Process dedicated allocations.
        -
        15393  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        -
        15394  {
        -
        15395  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        -
        15396  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        -
        15397  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        -
        15398  VMA_ASSERT(pDedicatedAllocVector);
        -
        15399  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
        -
        15400  {
        -
        15401  VmaStatInfo allocationStatInfo;
        -
        15402  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
        -
        15403  VmaAddStatInfo(pStats->total, allocationStatInfo);
        -
        15404  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        -
        15405  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        -
        15406  }
        -
        15407  }
        +
        15383  switch(allocation->GetType())
        +
        15384  {
        +
        15385  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        +
        15386  {
        +
        15387  VmaBlockVector* pBlockVector = VMA_NULL;
        +
        15388  VmaPool hPool = allocation->GetBlock()->GetParentPool();
        +
        15389  if(hPool != VK_NULL_HANDLE)
        +
        15390  {
        +
        15391  pBlockVector = &hPool->m_BlockVector;
        +
        15392  }
        +
        15393  else
        +
        15394  {
        +
        15395  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        +
        15396  pBlockVector = m_pBlockVectors[memTypeIndex];
        +
        15397  }
        +
        15398  pBlockVector->Free(allocation);
        +
        15399  }
        +
        15400  break;
        +
        15401  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        +
        15402  FreeDedicatedMemory(allocation);
        +
        15403  break;
        +
        15404  default:
        +
        15405  VMA_ASSERT(0);
        +
        15406  }
        +
        15407  }
        15408 
        -
        15409  // Postprocess.
        -
        15410  VmaPostprocessCalcStatInfo(pStats->total);
        -
        15411  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
        -
        15412  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
        -
        15413  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
        -
        15414  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
        -
        15415 }
        -
        15416 
        -
        15417 void VmaAllocator_T::GetBudget(VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount)
        -
        15418 {
        -
        15419 #if VMA_MEMORY_BUDGET
        -
        15420  if(m_UseExtMemoryBudget)
        -
        15421  {
        -
        15422  if(m_Budget.m_OperationsSinceBudgetFetch < 30)
        -
        15423  {
        -
        15424  VmaMutexLockRead lockRead(m_Budget.m_BudgetMutex, m_UseMutex);
        -
        15425  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
        -
        15426  {
        -
        15427  const uint32_t heapIndex = firstHeap + i;
        -
        15428 
        -
        15429  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
        -
        15430  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
        -
        15431 
        -
        15432  if(m_Budget.m_VulkanUsage[heapIndex] + outBudget->blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])
        -
        15433  {
        -
        15434  outBudget->usage = m_Budget.m_VulkanUsage[heapIndex] +
        -
        15435  outBudget->blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
        -
        15436  }
        -
        15437  else
        -
        15438  {
        -
        15439  outBudget->usage = 0;
        -
        15440  }
        -
        15441 
        -
        15442  // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.
        -
        15443  outBudget->budget = VMA_MIN(
        -
        15444  m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);
        -
        15445  }
        -
        15446  }
        -
        15447  else
        -
        15448  {
        -
        15449  UpdateVulkanBudget(); // Outside of mutex lock
        -
        15450  GetBudget(outBudget, firstHeap, heapCount); // Recursion
        -
        15451  }
        -
        15452  }
        -
        15453  else
        -
        15454 #endif
        -
        15455  {
        -
        15456  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
        -
        15457  {
        -
        15458  const uint32_t heapIndex = firstHeap + i;
        +
        15409  // Do this regardless of whether the allocation is lost. Lost allocations still account to Budget.AllocationBytes.
        +
        15410  m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
        +
        15411  allocation->SetUserData(this, VMA_NULL);
        +
        15412  allocation->Dtor();
        +
        15413  m_AllocationObjectAllocator.Free(allocation);
        +
        15414  }
        +
        15415  }
        +
        15416 }
        +
        15417 
        +
        15418 VkResult VmaAllocator_T::ResizeAllocation(
        +
        15419  const VmaAllocation alloc,
        +
        15420  VkDeviceSize newSize)
        +
        15421 {
        +
        15422  // This function is deprecated and so it does nothing. It's left for backward compatibility.
        +
        15423  if(newSize == 0 || alloc->GetLastUseFrameIndex() == VMA_FRAME_INDEX_LOST)
        +
        15424  {
        +
        15425  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        15426  }
        +
        15427  if(newSize == alloc->GetSize())
        +
        15428  {
        +
        15429  return VK_SUCCESS;
        +
        15430  }
        +
        15431  return VK_ERROR_OUT_OF_POOL_MEMORY;
        +
        15432 }
        +
        15433 
        +
        15434 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
        +
        15435 {
        +
        15436  // Initialize.
        +
        15437  InitStatInfo(pStats->total);
        +
        15438  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
        +
        15439  InitStatInfo(pStats->memoryType[i]);
        +
        15440  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        +
        15441  InitStatInfo(pStats->memoryHeap[i]);
        +
        15442 
        +
        15443  // Process default pools.
        +
        15444  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        +
        15445  {
        +
        15446  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        +
        15447  VMA_ASSERT(pBlockVector);
        +
        15448  pBlockVector->AddStats(pStats);
        +
        15449  }
        +
        15450 
        +
        15451  // Process custom pools.
        +
        15452  {
        +
        15453  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        +
        15454  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        +
        15455  {
        +
        15456  m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);
        +
        15457  }
        +
        15458  }
        15459 
        -
        15460  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
        -
        15461  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
        -
        15462 
        -
        15463  outBudget->usage = outBudget->blockBytes;
        -
        15464  outBudget->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
        -
        15465  }
        -
        15466  }
        -
        15467 }
        -
        15468 
        -
        15469 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
        -
        15470 
        -
        15471 VkResult VmaAllocator_T::DefragmentationBegin(
        -
        15472  const VmaDefragmentationInfo2& info,
        -
        15473  VmaDefragmentationStats* pStats,
        -
        15474  VmaDefragmentationContext* pContext)
        -
        15475 {
        -
        15476  if(info.pAllocationsChanged != VMA_NULL)
        -
        15477  {
        -
        15478  memset(info.pAllocationsChanged, 0, info.allocationCount * sizeof(VkBool32));
        -
        15479  }
        -
        15480 
        -
        15481  *pContext = vma_new(this, VmaDefragmentationContext_T)(
        -
        15482  this, m_CurrentFrameIndex.load(), info.flags, pStats);
        -
        15483 
        -
        15484  (*pContext)->AddPools(info.poolCount, info.pPools);
        -
        15485  (*pContext)->AddAllocations(
        -
        15486  info.allocationCount, info.pAllocations, info.pAllocationsChanged);
        -
        15487 
        -
        15488  VkResult res = (*pContext)->Defragment(
        -
        15489  info.maxCpuBytesToMove, info.maxCpuAllocationsToMove,
        -
        15490  info.maxGpuBytesToMove, info.maxGpuAllocationsToMove,
        -
        15491  info.commandBuffer, pStats);
        -
        15492 
        -
        15493  if(res != VK_NOT_READY)
        -
        15494  {
        -
        15495  vma_delete(this, *pContext);
        -
        15496  *pContext = VMA_NULL;
        -
        15497  }
        -
        15498 
        -
        15499  return res;
        -
        15500 }
        -
        15501 
        -
        15502 VkResult VmaAllocator_T::DefragmentationEnd(
        -
        15503  VmaDefragmentationContext context)
        -
        15504 {
        -
        15505  vma_delete(this, context);
        -
        15506  return VK_SUCCESS;
        -
        15507 }
        -
        15508 
        -
        15509 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
        -
        15510 {
        -
        15511  if(hAllocation->CanBecomeLost())
        -
        15512  {
        -
        15513  /*
        -
        15514  Warning: This is a carefully designed algorithm.
        -
        15515  Do not modify unless you really know what you're doing :)
        -
        15516  */
        -
        15517  const uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        -
        15518  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        -
        15519  for(;;)
        -
        15520  {
        -
        15521  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        -
        15522  {
        -
        15523  pAllocationInfo->memoryType = UINT32_MAX;
        -
        15524  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
        -
        15525  pAllocationInfo->offset = 0;
        -
        15526  pAllocationInfo->size = hAllocation->GetSize();
        -
        15527  pAllocationInfo->pMappedData = VMA_NULL;
        -
        15528  pAllocationInfo->pUserData = hAllocation->GetUserData();
        -
        15529  return;
        -
        15530  }
        -
        15531  else if(localLastUseFrameIndex == localCurrFrameIndex)
        -
        15532  {
        -
        15533  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        -
        15534  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        -
        15535  pAllocationInfo->offset = hAllocation->GetOffset();
        -
        15536  pAllocationInfo->size = hAllocation->GetSize();
        -
        15537  pAllocationInfo->pMappedData = VMA_NULL;
        -
        15538  pAllocationInfo->pUserData = hAllocation->GetUserData();
        -
        15539  return;
        -
        15540  }
        -
        15541  else // Last use time earlier than current time.
        -
        15542  {
        -
        15543  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        -
        15544  {
        -
        15545  localLastUseFrameIndex = localCurrFrameIndex;
        -
        15546  }
        -
        15547  }
        -
        15548  }
        -
        15549  }
        -
        15550  else
        -
        15551  {
        -
        15552 #if VMA_STATS_STRING_ENABLED
        -
        15553  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        -
        15554  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        -
        15555  for(;;)
        -
        15556  {
        -
        15557  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        -
        15558  if(localLastUseFrameIndex == localCurrFrameIndex)
        -
        15559  {
        -
        15560  break;
        -
        15561  }
        -
        15562  else // Last use time earlier than current time.
        -
        15563  {
        -
        15564  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        -
        15565  {
        -
        15566  localLastUseFrameIndex = localCurrFrameIndex;
        -
        15567  }
        -
        15568  }
        -
        15569  }
        -
        15570 #endif
        -
        15571 
        -
        15572  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        -
        15573  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        -
        15574  pAllocationInfo->offset = hAllocation->GetOffset();
        -
        15575  pAllocationInfo->size = hAllocation->GetSize();
        -
        15576  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        -
        15577  pAllocationInfo->pUserData = hAllocation->GetUserData();
        -
        15578  }
        -
        15579 }
        -
        15580 
        -
        15581 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
        -
        15582 {
        -
        15583  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
        -
        15584  if(hAllocation->CanBecomeLost())
        -
        15585  {
        -
        15586  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        -
        15587  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        -
        15588  for(;;)
        -
        15589  {
        -
        15590  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        -
        15591  {
        -
        15592  return false;
        -
        15593  }
        -
        15594  else if(localLastUseFrameIndex == localCurrFrameIndex)
        -
        15595  {
        -
        15596  return true;
        -
        15597  }
        -
        15598  else // Last use time earlier than current time.
        -
        15599  {
        -
        15600  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        -
        15601  {
        -
        15602  localLastUseFrameIndex = localCurrFrameIndex;
        -
        15603  }
        -
        15604  }
        -
        15605  }
        -
        15606  }
        -
        15607  else
        -
        15608  {
        -
        15609 #if VMA_STATS_STRING_ENABLED
        -
        15610  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        -
        15611  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        -
        15612  for(;;)
        -
        15613  {
        -
        15614  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        -
        15615  if(localLastUseFrameIndex == localCurrFrameIndex)
        -
        15616  {
        -
        15617  break;
        -
        15618  }
        -
        15619  else // Last use time earlier than current time.
        -
        15620  {
        -
        15621  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        -
        15622  {
        -
        15623  localLastUseFrameIndex = localCurrFrameIndex;
        -
        15624  }
        -
        15625  }
        -
        15626  }
        -
        15627 #endif
        -
        15628 
        -
        15629  return true;
        -
        15630  }
        -
        15631 }
        -
        15632 
        -
        15633 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
        -
        15634 {
        -
        15635  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
        -
        15636 
        -
        15637  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
        -
        15638 
        -
        15639  if(newCreateInfo.maxBlockCount == 0)
        -
        15640  {
        -
        15641  newCreateInfo.maxBlockCount = SIZE_MAX;
        -
        15642  }
        -
        15643  if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
        -
        15644  {
        -
        15645  return VK_ERROR_INITIALIZATION_FAILED;
        +
        15460  // Process dedicated allocations.
        +
        15461  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        +
        15462  {
        +
        15463  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        +
        15464  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        +
        15465  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        +
        15466  VMA_ASSERT(pDedicatedAllocVector);
        +
        15467  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
        +
        15468  {
        +
        15469  VmaStatInfo allocationStatInfo;
        +
        15470  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
        +
        15471  VmaAddStatInfo(pStats->total, allocationStatInfo);
        +
        15472  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        +
        15473  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        +
        15474  }
        +
        15475  }
        +
        15476 
        +
        15477  // Postprocess.
        +
        15478  VmaPostprocessCalcStatInfo(pStats->total);
        +
        15479  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
        +
        15480  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
        +
        15481  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
        +
        15482  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
        +
        15483 }
        +
        15484 
        +
        15485 void VmaAllocator_T::GetBudget(VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount)
        +
        15486 {
        +
        15487 #if VMA_MEMORY_BUDGET
        +
        15488  if(m_UseExtMemoryBudget)
        +
        15489  {
        +
        15490  if(m_Budget.m_OperationsSinceBudgetFetch < 30)
        +
        15491  {
        +
        15492  VmaMutexLockRead lockRead(m_Budget.m_BudgetMutex, m_UseMutex);
        +
        15493  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
        +
        15494  {
        +
        15495  const uint32_t heapIndex = firstHeap + i;
        +
        15496 
        +
        15497  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
        +
        15498  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
        +
        15499 
        +
        15500  if(m_Budget.m_VulkanUsage[heapIndex] + outBudget->blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])
        +
        15501  {
        +
        15502  outBudget->usage = m_Budget.m_VulkanUsage[heapIndex] +
        +
        15503  outBudget->blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
        +
        15504  }
        +
        15505  else
        +
        15506  {
        +
        15507  outBudget->usage = 0;
        +
        15508  }
        +
        15509 
        +
        15510  // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.
        +
        15511  outBudget->budget = VMA_MIN(
        +
        15512  m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);
        +
        15513  }
        +
        15514  }
        +
        15515  else
        +
        15516  {
        +
        15517  UpdateVulkanBudget(); // Outside of mutex lock
        +
        15518  GetBudget(outBudget, firstHeap, heapCount); // Recursion
        +
        15519  }
        +
        15520  }
        +
        15521  else
        +
        15522 #endif
        +
        15523  {
        +
        15524  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
        +
        15525  {
        +
        15526  const uint32_t heapIndex = firstHeap + i;
        +
        15527 
        +
        15528  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
        +
        15529  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
        +
        15530 
        +
        15531  outBudget->usage = outBudget->blockBytes;
        +
        15532  outBudget->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
        +
        15533  }
        +
        15534  }
        +
        15535 }
        +
        15536 
        +
        15537 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
        +
        15538 
        +
        15539 VkResult VmaAllocator_T::DefragmentationBegin(
        +
        15540  const VmaDefragmentationInfo2& info,
        +
        15541  VmaDefragmentationStats* pStats,
        +
        15542  VmaDefragmentationContext* pContext)
        +
        15543 {
        +
        15544  if(info.pAllocationsChanged != VMA_NULL)
        +
        15545  {
        +
        15546  memset(info.pAllocationsChanged, 0, info.allocationCount * sizeof(VkBool32));
        +
        15547  }
        +
        15548 
        +
        15549  *pContext = vma_new(this, VmaDefragmentationContext_T)(
        +
        15550  this, m_CurrentFrameIndex.load(), info.flags, pStats);
        +
        15551 
        +
        15552  (*pContext)->AddPools(info.poolCount, info.pPools);
        +
        15553  (*pContext)->AddAllocations(
        +
        15554  info.allocationCount, info.pAllocations, info.pAllocationsChanged);
        +
        15555 
        +
        15556  VkResult res = (*pContext)->Defragment(
        +
        15557  info.maxCpuBytesToMove, info.maxCpuAllocationsToMove,
        +
        15558  info.maxGpuBytesToMove, info.maxGpuAllocationsToMove,
        +
        15559  info.commandBuffer, pStats);
        +
        15560 
        +
        15561  if(res != VK_NOT_READY)
        +
        15562  {
        +
        15563  vma_delete(this, *pContext);
        +
        15564  *pContext = VMA_NULL;
        +
        15565  }
        +
        15566 
        +
        15567  return res;
        +
        15568 }
        +
        15569 
        +
        15570 VkResult VmaAllocator_T::DefragmentationEnd(
        +
        15571  VmaDefragmentationContext context)
        +
        15572 {
        +
        15573  vma_delete(this, context);
        +
        15574  return VK_SUCCESS;
        +
        15575 }
        +
        15576 
        +
        15577 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
        +
        15578 {
        +
        15579  if(hAllocation->CanBecomeLost())
        +
        15580  {
        +
        15581  /*
        +
        15582  Warning: This is a carefully designed algorithm.
        +
        15583  Do not modify unless you really know what you're doing :)
        +
        15584  */
        +
        15585  const uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        +
        15586  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        +
        15587  for(;;)
        +
        15588  {
        +
        15589  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        +
        15590  {
        +
        15591  pAllocationInfo->memoryType = UINT32_MAX;
        +
        15592  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
        +
        15593  pAllocationInfo->offset = 0;
        +
        15594  pAllocationInfo->size = hAllocation->GetSize();
        +
        15595  pAllocationInfo->pMappedData = VMA_NULL;
        +
        15596  pAllocationInfo->pUserData = hAllocation->GetUserData();
        +
        15597  return;
        +
        15598  }
        +
        15599  else if(localLastUseFrameIndex == localCurrFrameIndex)
        +
        15600  {
        +
        15601  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        +
        15602  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        +
        15603  pAllocationInfo->offset = hAllocation->GetOffset();
        +
        15604  pAllocationInfo->size = hAllocation->GetSize();
        +
        15605  pAllocationInfo->pMappedData = VMA_NULL;
        +
        15606  pAllocationInfo->pUserData = hAllocation->GetUserData();
        +
        15607  return;
        +
        15608  }
        +
        15609  else // Last use time earlier than current time.
        +
        15610  {
        +
        15611  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        +
        15612  {
        +
        15613  localLastUseFrameIndex = localCurrFrameIndex;
        +
        15614  }
        +
        15615  }
        +
        15616  }
        +
        15617  }
        +
        15618  else
        +
        15619  {
        +
        15620 #if VMA_STATS_STRING_ENABLED
        +
        15621  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        +
        15622  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        +
        15623  for(;;)
        +
        15624  {
        +
        15625  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        +
        15626  if(localLastUseFrameIndex == localCurrFrameIndex)
        +
        15627  {
        +
        15628  break;
        +
        15629  }
        +
        15630  else // Last use time earlier than current time.
        +
        15631  {
        +
        15632  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        +
        15633  {
        +
        15634  localLastUseFrameIndex = localCurrFrameIndex;
        +
        15635  }
        +
        15636  }
        +
        15637  }
        +
        15638 #endif
        +
        15639 
        +
        15640  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        +
        15641  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        +
        15642  pAllocationInfo->offset = hAllocation->GetOffset();
        +
        15643  pAllocationInfo->size = hAllocation->GetSize();
        +
        15644  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        +
        15645  pAllocationInfo->pUserData = hAllocation->GetUserData();
        15646  }
        -
        15647 
        -
        15648  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
        -
        15649 
        -
        15650  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);
        -
        15651 
        -
        15652  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
        -
        15653  if(res != VK_SUCCESS)
        -
        15654  {
        -
        15655  vma_delete(this, *pPool);
        -
        15656  *pPool = VMA_NULL;
        -
        15657  return res;
        -
        15658  }
        -
        15659 
        -
        15660  // Add to m_Pools.
        -
        15661  {
        -
        15662  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
        -
        15663  (*pPool)->SetId(m_NextPoolId++);
        -
        15664  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
        -
        15665  }
        -
        15666 
        -
        15667  return VK_SUCCESS;
        -
        15668 }
        -
        15669 
        -
        15670 void VmaAllocator_T::DestroyPool(VmaPool pool)
        -
        15671 {
        -
        15672  // Remove from m_Pools.
        -
        15673  {
        -
        15674  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
        -
        15675  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
        -
        15676  VMA_ASSERT(success && "Pool not found in Allocator.");
        -
        15677  }
        -
        15678 
        -
        15679  vma_delete(this, pool);
        -
        15680 }
        -
        15681 
        -
        15682 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
        -
        15683 {
        -
        15684  pool->m_BlockVector.GetPoolStats(pPoolStats);
        -
        15685 }
        -
        15686 
        -
        15687 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
        -
        15688 {
        -
        15689  m_CurrentFrameIndex.store(frameIndex);
        -
        15690 
        -
        15691 #if VMA_MEMORY_BUDGET
        -
        15692  if(m_UseExtMemoryBudget)
        -
        15693  {
        -
        15694  UpdateVulkanBudget();
        -
        15695  }
        -
        15696 #endif // #if VMA_MEMORY_BUDGET
        -
        15697 }
        -
        15698 
        -
        15699 void VmaAllocator_T::MakePoolAllocationsLost(
        -
        15700  VmaPool hPool,
        -
        15701  size_t* pLostAllocationCount)
        +
        15647 }
        +
        15648 
        +
        15649 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
        +
        15650 {
        +
        15651  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
        +
        15652  if(hAllocation->CanBecomeLost())
        +
        15653  {
        +
        15654  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        +
        15655  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        +
        15656  for(;;)
        +
        15657  {
        +
        15658  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        +
        15659  {
        +
        15660  return false;
        +
        15661  }
        +
        15662  else if(localLastUseFrameIndex == localCurrFrameIndex)
        +
        15663  {
        +
        15664  return true;
        +
        15665  }
        +
        15666  else // Last use time earlier than current time.
        +
        15667  {
        +
        15668  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        +
        15669  {
        +
        15670  localLastUseFrameIndex = localCurrFrameIndex;
        +
        15671  }
        +
        15672  }
        +
        15673  }
        +
        15674  }
        +
        15675  else
        +
        15676  {
        +
        15677 #if VMA_STATS_STRING_ENABLED
        +
        15678  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        +
        15679  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        +
        15680  for(;;)
        +
        15681  {
        +
        15682  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        +
        15683  if(localLastUseFrameIndex == localCurrFrameIndex)
        +
        15684  {
        +
        15685  break;
        +
        15686  }
        +
        15687  else // Last use time earlier than current time.
        +
        15688  {
        +
        15689  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        +
        15690  {
        +
        15691  localLastUseFrameIndex = localCurrFrameIndex;
        +
        15692  }
        +
        15693  }
        +
        15694  }
        +
        15695 #endif
        +
        15696 
        +
        15697  return true;
        +
        15698  }
        +
        15699 }
        +
        15700 
        +
        15701 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
        15702 {
        -
        15703  hPool->m_BlockVector.MakePoolAllocationsLost(
        -
        15704  m_CurrentFrameIndex.load(),
        -
        15705  pLostAllocationCount);
        -
        15706 }
        -
        15707 
        -
        15708 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
        -
        15709 {
        -
        15710  return hPool->m_BlockVector.CheckCorruption();
        -
        15711 }
        -
        15712 
        -
        15713 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
        -
        15714 {
        -
        15715  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
        -
        15716 
        -
        15717  // Process default pools.
        -
        15718  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        -
        15719  {
        -
        15720  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
        -
        15721  {
        -
        15722  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        -
        15723  VMA_ASSERT(pBlockVector);
        -
        15724  VkResult localRes = pBlockVector->CheckCorruption();
        -
        15725  switch(localRes)
        -
        15726  {
        -
        15727  case VK_ERROR_FEATURE_NOT_PRESENT:
        -
        15728  break;
        -
        15729  case VK_SUCCESS:
        -
        15730  finalRes = VK_SUCCESS;
        -
        15731  break;
        -
        15732  default:
        -
        15733  return localRes;
        -
        15734  }
        -
        15735  }
        -
        15736  }
        +
        15703  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
        +
        15704 
        +
        15705  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
        +
        15706 
        +
        15707  if(newCreateInfo.maxBlockCount == 0)
        +
        15708  {
        +
        15709  newCreateInfo.maxBlockCount = SIZE_MAX;
        +
        15710  }
        +
        15711  if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
        +
        15712  {
        +
        15713  return VK_ERROR_INITIALIZATION_FAILED;
        +
        15714  }
        +
        15715 
        +
        15716  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
        +
        15717 
        +
        15718  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);
        +
        15719 
        +
        15720  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
        +
        15721  if(res != VK_SUCCESS)
        +
        15722  {
        +
        15723  vma_delete(this, *pPool);
        +
        15724  *pPool = VMA_NULL;
        +
        15725  return res;
        +
        15726  }
        +
        15727 
        +
        15728  // Add to m_Pools.
        +
        15729  {
        +
        15730  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
        +
        15731  (*pPool)->SetId(m_NextPoolId++);
        +
        15732  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
        +
        15733  }
        +
        15734 
        +
        15735  return VK_SUCCESS;
        +
        15736 }
        15737 
        -
        15738  // Process custom pools.
        -
        15739  {
        -
        15740  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        -
        15741  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        -
        15742  {
        -
        15743  if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
        -
        15744  {
        -
        15745  VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();
        -
        15746  switch(localRes)
        -
        15747  {
        -
        15748  case VK_ERROR_FEATURE_NOT_PRESENT:
        -
        15749  break;
        -
        15750  case VK_SUCCESS:
        -
        15751  finalRes = VK_SUCCESS;
        -
        15752  break;
        -
        15753  default:
        -
        15754  return localRes;
        -
        15755  }
        -
        15756  }
        -
        15757  }
        -
        15758  }
        -
        15759 
        -
        15760  return finalRes;
        -
        15761 }
        -
        15762 
        -
        15763 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
        -
        15764 {
        -
        15765  *pAllocation = m_AllocationObjectAllocator.Allocate();
        -
        15766  (*pAllocation)->Ctor(VMA_FRAME_INDEX_LOST, false);
        -
        15767  (*pAllocation)->InitLost();
        -
        15768 }
        -
        15769 
        -
        15770 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
        -
        15771 {
        -
        15772  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
        -
        15773 
        -
        15774  // HeapSizeLimit is in effect for this heap.
        -
        15775  if((m_HeapSizeLimitMask & (1u << heapIndex)) != 0)
        -
        15776  {
        -
        15777  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        -
        15778  VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
        -
        15779  for(;;)
        -
        15780  {
        -
        15781  const VkDeviceSize blockBytesAfterAllocation = blockBytes + pAllocateInfo->allocationSize;
        -
        15782  if(blockBytesAfterAllocation > heapSize)
        -
        15783  {
        -
        15784  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        -
        15785  }
        -
        15786  if(m_Budget.m_BlockBytes->compare_exchange_strong(blockBytes, blockBytesAfterAllocation))
        -
        15787  {
        -
        15788  break;
        -
        15789  }
        -
        15790  }
        -
        15791  }
        -
        15792  else
        -
        15793  {
        -
        15794  m_Budget.m_BlockBytes[heapIndex] += pAllocateInfo->allocationSize;
        -
        15795  }
        -
        15796 
        -
        15797  // VULKAN CALL vkAllocateMemory.
        -
        15798  VkResult res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        -
        15799 
        -
        15800  if(res == VK_SUCCESS)
        -
        15801  {
        -
        15802 #if VMA_MEMORY_BUDGET
        -
        15803  ++m_Budget.m_OperationsSinceBudgetFetch;
        -
        15804 #endif
        +
        15738 void VmaAllocator_T::DestroyPool(VmaPool pool)
        +
        15739 {
        +
        15740  // Remove from m_Pools.
        +
        15741  {
        +
        15742  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
        +
        15743  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
        +
        15744  VMA_ASSERT(success && "Pool not found in Allocator.");
        +
        15745  }
        +
        15746 
        +
        15747  vma_delete(this, pool);
        +
        15748 }
        +
        15749 
        +
        15750 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
        +
        15751 {
        +
        15752  pool->m_BlockVector.GetPoolStats(pPoolStats);
        +
        15753 }
        +
        15754 
        +
        15755 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
        +
        15756 {
        +
        15757  m_CurrentFrameIndex.store(frameIndex);
        +
        15758 
        +
        15759 #if VMA_MEMORY_BUDGET
        +
        15760  if(m_UseExtMemoryBudget)
        +
        15761  {
        +
        15762  UpdateVulkanBudget();
        +
        15763  }
        +
        15764 #endif // #if VMA_MEMORY_BUDGET
        +
        15765 }
        +
        15766 
        +
        15767 void VmaAllocator_T::MakePoolAllocationsLost(
        +
        15768  VmaPool hPool,
        +
        15769  size_t* pLostAllocationCount)
        +
        15770 {
        +
        15771  hPool->m_BlockVector.MakePoolAllocationsLost(
        +
        15772  m_CurrentFrameIndex.load(),
        +
        15773  pLostAllocationCount);
        +
        15774 }
        +
        15775 
        +
        15776 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
        +
        15777 {
        +
        15778  return hPool->m_BlockVector.CheckCorruption();
        +
        15779 }
        +
        15780 
        +
        15781 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
        +
        15782 {
        +
        15783  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
        +
        15784 
        +
        15785  // Process default pools.
        +
        15786  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        +
        15787  {
        +
        15788  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
        +
        15789  {
        +
        15790  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        +
        15791  VMA_ASSERT(pBlockVector);
        +
        15792  VkResult localRes = pBlockVector->CheckCorruption();
        +
        15793  switch(localRes)
        +
        15794  {
        +
        15795  case VK_ERROR_FEATURE_NOT_PRESENT:
        +
        15796  break;
        +
        15797  case VK_SUCCESS:
        +
        15798  finalRes = VK_SUCCESS;
        +
        15799  break;
        +
        15800  default:
        +
        15801  return localRes;
        +
        15802  }
        +
        15803  }
        +
        15804  }
        15805 
        -
        15806  // Informative callback.
        -
        15807  if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        -
        15808  {
        -
        15809  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
        -
        15810  }
        -
        15811  }
        -
        15812  else
        -
        15813  {
        -
        15814  m_Budget.m_BlockBytes[heapIndex] -= pAllocateInfo->allocationSize;
        -
        15815  }
        -
        15816 
        -
        15817  return res;
        -
        15818 }
        -
        15819 
        -
        15820 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
        -
        15821 {
        -
        15822  // Informative callback.
        -
        15823  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
        -
        15824  {
        -
        15825  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
        +
        15806  // Process custom pools.
        +
        15807  {
        +
        15808  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        +
        15809  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        +
        15810  {
        +
        15811  if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
        +
        15812  {
        +
        15813  VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();
        +
        15814  switch(localRes)
        +
        15815  {
        +
        15816  case VK_ERROR_FEATURE_NOT_PRESENT:
        +
        15817  break;
        +
        15818  case VK_SUCCESS:
        +
        15819  finalRes = VK_SUCCESS;
        +
        15820  break;
        +
        15821  default:
        +
        15822  return localRes;
        +
        15823  }
        +
        15824  }
        +
        15825  }
        15826  }
        15827 
        -
        15828  // VULKAN CALL vkFreeMemory.
        -
        15829  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
        +
        15828  return finalRes;
        +
        15829 }
        15830 
        -
        15831  m_Budget.m_BlockBytes[MemoryTypeIndexToHeapIndex(memoryType)] -= size;
        -
        15832 }
        -
        15833 
        -
        15834 VkResult VmaAllocator_T::BindVulkanBuffer(
        -
        15835  VkDeviceMemory memory,
        -
        15836  VkDeviceSize memoryOffset,
        -
        15837  VkBuffer buffer,
        -
        15838  const void* pNext)
        +
        15831 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
        +
        15832 {
        +
        15833  *pAllocation = m_AllocationObjectAllocator.Allocate();
        +
        15834  (*pAllocation)->Ctor(VMA_FRAME_INDEX_LOST, false);
        +
        15835  (*pAllocation)->InitLost();
        +
        15836 }
        +
        15837 
        +
        15838 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
        15839 {
        -
        15840  if(pNext != VMA_NULL)
        -
        15841  {
        -
        15842 #if VMA_BIND_MEMORY2
        -
        15843  if(m_UseKhrBindMemory2 && m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL)
        -
        15844  {
        -
        15845  VkBindBufferMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR };
        -
        15846  bindBufferMemoryInfo.pNext = pNext;
        -
        15847  bindBufferMemoryInfo.buffer = buffer;
        -
        15848  bindBufferMemoryInfo.memory = memory;
        -
        15849  bindBufferMemoryInfo.memoryOffset = memoryOffset;
        -
        15850  return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
        -
        15851  }
        -
        15852  else
        -
        15853 #endif // #if VMA_BIND_MEMORY2
        -
        15854  {
        -
        15855  return VK_ERROR_EXTENSION_NOT_PRESENT;
        -
        15856  }
        -
        15857  }
        -
        15858  else
        -
        15859  {
        -
        15860  return (*m_VulkanFunctions.vkBindBufferMemory)(m_hDevice, buffer, memory, memoryOffset);
        -
        15861  }
        -
        15862 }
        -
        15863 
        -
        15864 VkResult VmaAllocator_T::BindVulkanImage(
        -
        15865  VkDeviceMemory memory,
        -
        15866  VkDeviceSize memoryOffset,
        -
        15867  VkImage image,
        -
        15868  const void* pNext)
        -
        15869 {
        -
        15870  if(pNext != VMA_NULL)
        -
        15871  {
        -
        15872 #if VMA_BIND_MEMORY2
        -
        15873  if(m_UseKhrBindMemory2 && m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL)
        -
        15874  {
        -
        15875  VkBindImageMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR };
        -
        15876  bindBufferMemoryInfo.pNext = pNext;
        -
        15877  bindBufferMemoryInfo.image = image;
        -
        15878  bindBufferMemoryInfo.memory = memory;
        -
        15879  bindBufferMemoryInfo.memoryOffset = memoryOffset;
        -
        15880  return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
        -
        15881  }
        -
        15882  else
        -
        15883 #endif // #if VMA_BIND_MEMORY2
        -
        15884  {
        -
        15885  return VK_ERROR_EXTENSION_NOT_PRESENT;
        -
        15886  }
        -
        15887  }
        -
        15888  else
        -
        15889  {
        -
        15890  return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
        -
        15891  }
        -
        15892 }
        -
        15893 
        -
        15894 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
        -
        15895 {
        -
        15896  if(hAllocation->CanBecomeLost())
        -
        15897  {
        -
        15898  return VK_ERROR_MEMORY_MAP_FAILED;
        -
        15899  }
        -
        15900 
        -
        15901  switch(hAllocation->GetType())
        -
        15902  {
        -
        15903  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        -
        15904  {
        -
        15905  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        -
        15906  char *pBytes = VMA_NULL;
        -
        15907  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
        -
        15908  if(res == VK_SUCCESS)
        -
        15909  {
        -
        15910  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
        -
        15911  hAllocation->BlockAllocMap();
        -
        15912  }
        -
        15913  return res;
        -
        15914  }
        -
        15915  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        -
        15916  return hAllocation->DedicatedAllocMap(this, ppData);
        -
        15917  default:
        -
        15918  VMA_ASSERT(0);
        -
        15919  return VK_ERROR_MEMORY_MAP_FAILED;
        -
        15920  }
        -
        15921 }
        -
        15922 
        -
        15923 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
        -
        15924 {
        -
        15925  switch(hAllocation->GetType())
        -
        15926  {
        -
        15927  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        -
        15928  {
        -
        15929  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        -
        15930  hAllocation->BlockAllocUnmap();
        -
        15931  pBlock->Unmap(this, 1);
        -
        15932  }
        -
        15933  break;
        -
        15934  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        -
        15935  hAllocation->DedicatedAllocUnmap(this);
        -
        15936  break;
        -
        15937  default:
        -
        15938  VMA_ASSERT(0);
        -
        15939  }
        -
        15940 }
        -
        15941 
        -
        15942 VkResult VmaAllocator_T::BindBufferMemory(
        -
        15943  VmaAllocation hAllocation,
        -
        15944  VkDeviceSize allocationLocalOffset,
        -
        15945  VkBuffer hBuffer,
        -
        15946  const void* pNext)
        -
        15947 {
        -
        15948  VkResult res = VK_SUCCESS;
        -
        15949  switch(hAllocation->GetType())
        -
        15950  {
        -
        15951  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        -
        15952  res = BindVulkanBuffer(hAllocation->GetMemory(), allocationLocalOffset, hBuffer, pNext);
        -
        15953  break;
        -
        15954  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        -
        15955  {
        -
        15956  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        -
        15957  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
        -
        15958  res = pBlock->BindBufferMemory(this, hAllocation, allocationLocalOffset, hBuffer, pNext);
        -
        15959  break;
        -
        15960  }
        -
        15961  default:
        -
        15962  VMA_ASSERT(0);
        -
        15963  }
        -
        15964  return res;
        -
        15965 }
        -
        15966 
        -
        15967 VkResult VmaAllocator_T::BindImageMemory(
        -
        15968  VmaAllocation hAllocation,
        -
        15969  VkDeviceSize allocationLocalOffset,
        -
        15970  VkImage hImage,
        -
        15971  const void* pNext)
        -
        15972 {
        -
        15973  VkResult res = VK_SUCCESS;
        -
        15974  switch(hAllocation->GetType())
        -
        15975  {
        -
        15976  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        -
        15977  res = BindVulkanImage(hAllocation->GetMemory(), allocationLocalOffset, hImage, pNext);
        -
        15978  break;
        -
        15979  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        -
        15980  {
        -
        15981  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        -
        15982  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
        -
        15983  res = pBlock->BindImageMemory(this, hAllocation, allocationLocalOffset, hImage, pNext);
        -
        15984  break;
        -
        15985  }
        -
        15986  default:
        -
        15987  VMA_ASSERT(0);
        -
        15988  }
        -
        15989  return res;
        -
        15990 }
        -
        15991 
        -
        15992 void VmaAllocator_T::FlushOrInvalidateAllocation(
        -
        15993  VmaAllocation hAllocation,
        -
        15994  VkDeviceSize offset, VkDeviceSize size,
        -
        15995  VMA_CACHE_OPERATION op)
        -
        15996 {
        -
        15997  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
        -
        15998  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
        -
        15999  {
        -
        16000  const VkDeviceSize allocationSize = hAllocation->GetSize();
        -
        16001  VMA_ASSERT(offset <= allocationSize);
        -
        16002 
        -
        16003  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
        -
        16004 
        -
        16005  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
        -
        16006  memRange.memory = hAllocation->GetMemory();
        -
        16007 
        -
        16008  switch(hAllocation->GetType())
        -
        16009  {
        -
        16010  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        -
        16011  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        -
        16012  if(size == VK_WHOLE_SIZE)
        -
        16013  {
        -
        16014  memRange.size = allocationSize - memRange.offset;
        -
        16015  }
        -
        16016  else
        -
        16017  {
        -
        16018  VMA_ASSERT(offset + size <= allocationSize);
        -
        16019  memRange.size = VMA_MIN(
        -
        16020  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
        -
        16021  allocationSize - memRange.offset);
        -
        16022  }
        -
        16023  break;
        -
        16024 
        -
        16025  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        -
        16026  {
        -
        16027  // 1. Still within this allocation.
        -
        16028  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        -
        16029  if(size == VK_WHOLE_SIZE)
        -
        16030  {
        -
        16031  size = allocationSize - offset;
        -
        16032  }
        -
        16033  else
        -
        16034  {
        -
        16035  VMA_ASSERT(offset + size <= allocationSize);
        -
        16036  }
        -
        16037  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
        -
        16038 
        -
        16039  // 2. Adjust to whole block.
        -
        16040  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
        -
        16041  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
        -
        16042  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_pMetadata->GetSize();
        -
        16043  memRange.offset += allocationOffset;
        -
        16044  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
        -
        16045 
        -
        16046  break;
        -
        16047  }
        -
        16048 
        -
        16049  default:
        -
        16050  VMA_ASSERT(0);
        -
        16051  }
        -
        16052 
        -
        16053  switch(op)
        -
        16054  {
        -
        16055  case VMA_CACHE_FLUSH:
        -
        16056  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
        -
        16057  break;
        -
        16058  case VMA_CACHE_INVALIDATE:
        -
        16059  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
        -
        16060  break;
        -
        16061  default:
        -
        16062  VMA_ASSERT(0);
        -
        16063  }
        -
        16064  }
        -
        16065  // else: Just ignore this call.
        -
        16066 }
        -
        16067 
        -
        16068 void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
        -
        16069 {
        -
        16070  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        -
        16071 
        -
        16072  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        -
        16073  {
        -
        16074  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        -
        16075  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        -
        16076  VMA_ASSERT(pDedicatedAllocations);
        -
        16077  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
        -
        16078  VMA_ASSERT(success);
        -
        16079  }
        -
        16080 
        -
        16081  VkDeviceMemory hMemory = allocation->GetMemory();
        -
        16082 
        -
        16083  /*
        -
        16084  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
        -
        16085  before vkFreeMemory.
        -
        16086 
        -
        16087  if(allocation->GetMappedData() != VMA_NULL)
        -
        16088  {
        -
        16089  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
        -
        16090  }
        -
        16091  */
        -
        16092 
        -
        16093  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
        +
        15840  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
        +
        15841 
        +
        15842  // HeapSizeLimit is in effect for this heap.
        +
        15843  if((m_HeapSizeLimitMask & (1u << heapIndex)) != 0)
        +
        15844  {
        +
        15845  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        +
        15846  VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
        +
        15847  for(;;)
        +
        15848  {
        +
        15849  const VkDeviceSize blockBytesAfterAllocation = blockBytes + pAllocateInfo->allocationSize;
        +
        15850  if(blockBytesAfterAllocation > heapSize)
        +
        15851  {
        +
        15852  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        +
        15853  }
        +
        15854  if(m_Budget.m_BlockBytes->compare_exchange_strong(blockBytes, blockBytesAfterAllocation))
        +
        15855  {
        +
        15856  break;
        +
        15857  }
        +
        15858  }
        +
        15859  }
        +
        15860  else
        +
        15861  {
        +
        15862  m_Budget.m_BlockBytes[heapIndex] += pAllocateInfo->allocationSize;
        +
        15863  }
        +
        15864 
        +
        15865  // VULKAN CALL vkAllocateMemory.
        +
        15866  VkResult res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        +
        15867 
        +
        15868  if(res == VK_SUCCESS)
        +
        15869  {
        +
        15870 #if VMA_MEMORY_BUDGET
        +
        15871  ++m_Budget.m_OperationsSinceBudgetFetch;
        +
        15872 #endif
        +
        15873 
        +
        15874  // Informative callback.
        +
        15875  if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        +
        15876  {
        +
        15877  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
        +
        15878  }
        +
        15879  }
        +
        15880  else
        +
        15881  {
        +
        15882  m_Budget.m_BlockBytes[heapIndex] -= pAllocateInfo->allocationSize;
        +
        15883  }
        +
        15884 
        +
        15885  return res;
        +
        15886 }
        +
        15887 
        +
        15888 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
        +
        15889 {
        +
        15890  // Informative callback.
        +
        15891  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
        +
        15892  {
        +
        15893  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
        +
        15894  }
        +
        15895 
        +
        15896  // VULKAN CALL vkFreeMemory.
        +
        15897  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
        +
        15898 
        +
        15899  m_Budget.m_BlockBytes[MemoryTypeIndexToHeapIndex(memoryType)] -= size;
        +
        15900 }
        +
        15901 
        +
        15902 VkResult VmaAllocator_T::BindVulkanBuffer(
        +
        15903  VkDeviceMemory memory,
        +
        15904  VkDeviceSize memoryOffset,
        +
        15905  VkBuffer buffer,
        +
        15906  const void* pNext)
        +
        15907 {
        +
        15908  if(pNext != VMA_NULL)
        +
        15909  {
        +
        15910 #if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
        +
        15911  if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
        +
        15912  m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL)
        +
        15913  {
        +
        15914  VkBindBufferMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR };
        +
        15915  bindBufferMemoryInfo.pNext = pNext;
        +
        15916  bindBufferMemoryInfo.buffer = buffer;
        +
        15917  bindBufferMemoryInfo.memory = memory;
        +
        15918  bindBufferMemoryInfo.memoryOffset = memoryOffset;
        +
        15919  return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
        +
        15920  }
        +
        15921  else
        +
        15922 #endif // #if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
        +
        15923  {
        +
        15924  return VK_ERROR_EXTENSION_NOT_PRESENT;
        +
        15925  }
        +
        15926  }
        +
        15927  else
        +
        15928  {
        +
        15929  return (*m_VulkanFunctions.vkBindBufferMemory)(m_hDevice, buffer, memory, memoryOffset);
        +
        15930  }
        +
        15931 }
        +
        15932 
        +
        15933 VkResult VmaAllocator_T::BindVulkanImage(
        +
        15934  VkDeviceMemory memory,
        +
        15935  VkDeviceSize memoryOffset,
        +
        15936  VkImage image,
        +
        15937  const void* pNext)
        +
        15938 {
        +
        15939  if(pNext != VMA_NULL)
        +
        15940  {
        +
        15941 #if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
        +
        15942  if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
        +
        15943  m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL)
        +
        15944  {
        +
        15945  VkBindImageMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR };
        +
        15946  bindBufferMemoryInfo.pNext = pNext;
        +
        15947  bindBufferMemoryInfo.image = image;
        +
        15948  bindBufferMemoryInfo.memory = memory;
        +
        15949  bindBufferMemoryInfo.memoryOffset = memoryOffset;
        +
        15950  return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
        +
        15951  }
        +
        15952  else
        +
        15953 #endif // #if VMA_BIND_MEMORY2
        +
        15954  {
        +
        15955  return VK_ERROR_EXTENSION_NOT_PRESENT;
        +
        15956  }
        +
        15957  }
        +
        15958  else
        +
        15959  {
        +
        15960  return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
        +
        15961  }
        +
        15962 }
        +
        15963 
        +
        15964 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
        +
        15965 {
        +
        15966  if(hAllocation->CanBecomeLost())
        +
        15967  {
        +
        15968  return VK_ERROR_MEMORY_MAP_FAILED;
        +
        15969  }
        +
        15970 
        +
        15971  switch(hAllocation->GetType())
        +
        15972  {
        +
        15973  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        +
        15974  {
        +
        15975  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        +
        15976  char *pBytes = VMA_NULL;
        +
        15977  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
        +
        15978  if(res == VK_SUCCESS)
        +
        15979  {
        +
        15980  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
        +
        15981  hAllocation->BlockAllocMap();
        +
        15982  }
        +
        15983  return res;
        +
        15984  }
        +
        15985  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        +
        15986  return hAllocation->DedicatedAllocMap(this, ppData);
        +
        15987  default:
        +
        15988  VMA_ASSERT(0);
        +
        15989  return VK_ERROR_MEMORY_MAP_FAILED;
        +
        15990  }
        +
        15991 }
        +
        15992 
        +
        15993 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
        +
        15994 {
        +
        15995  switch(hAllocation->GetType())
        +
        15996  {
        +
        15997  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        +
        15998  {
        +
        15999  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        +
        16000  hAllocation->BlockAllocUnmap();
        +
        16001  pBlock->Unmap(this, 1);
        +
        16002  }
        +
        16003  break;
        +
        16004  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        +
        16005  hAllocation->DedicatedAllocUnmap(this);
        +
        16006  break;
        +
        16007  default:
        +
        16008  VMA_ASSERT(0);
        +
        16009  }
        +
        16010 }
        +
        16011 
        +
        16012 VkResult VmaAllocator_T::BindBufferMemory(
        +
        16013  VmaAllocation hAllocation,
        +
        16014  VkDeviceSize allocationLocalOffset,
        +
        16015  VkBuffer hBuffer,
        +
        16016  const void* pNext)
        +
        16017 {
        +
        16018  VkResult res = VK_SUCCESS;
        +
        16019  switch(hAllocation->GetType())
        +
        16020  {
        +
        16021  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        +
        16022  res = BindVulkanBuffer(hAllocation->GetMemory(), allocationLocalOffset, hBuffer, pNext);
        +
        16023  break;
        +
        16024  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        +
        16025  {
        +
        16026  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        +
        16027  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
        +
        16028  res = pBlock->BindBufferMemory(this, hAllocation, allocationLocalOffset, hBuffer, pNext);
        +
        16029  break;
        +
        16030  }
        +
        16031  default:
        +
        16032  VMA_ASSERT(0);
        +
        16033  }
        +
        16034  return res;
        +
        16035 }
        +
        16036 
        +
        16037 VkResult VmaAllocator_T::BindImageMemory(
        +
        16038  VmaAllocation hAllocation,
        +
        16039  VkDeviceSize allocationLocalOffset,
        +
        16040  VkImage hImage,
        +
        16041  const void* pNext)
        +
        16042 {
        +
        16043  VkResult res = VK_SUCCESS;
        +
        16044  switch(hAllocation->GetType())
        +
        16045  {
        +
        16046  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        +
        16047  res = BindVulkanImage(hAllocation->GetMemory(), allocationLocalOffset, hImage, pNext);
        +
        16048  break;
        +
        16049  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        +
        16050  {
        +
        16051  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        +
        16052  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
        +
        16053  res = pBlock->BindImageMemory(this, hAllocation, allocationLocalOffset, hImage, pNext);
        +
        16054  break;
        +
        16055  }
        +
        16056  default:
        +
        16057  VMA_ASSERT(0);
        +
        16058  }
        +
        16059  return res;
        +
        16060 }
        +
        16061 
        +
        16062 void VmaAllocator_T::FlushOrInvalidateAllocation(
        +
        16063  VmaAllocation hAllocation,
        +
        16064  VkDeviceSize offset, VkDeviceSize size,
        +
        16065  VMA_CACHE_OPERATION op)
        +
        16066 {
        +
        16067  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
        +
        16068  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
        +
        16069  {
        +
        16070  const VkDeviceSize allocationSize = hAllocation->GetSize();
        +
        16071  VMA_ASSERT(offset <= allocationSize);
        +
        16072 
        +
        16073  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
        +
        16074 
        +
        16075  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
        +
        16076  memRange.memory = hAllocation->GetMemory();
        +
        16077 
        +
        16078  switch(hAllocation->GetType())
        +
        16079  {
        +
        16080  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        +
        16081  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        +
        16082  if(size == VK_WHOLE_SIZE)
        +
        16083  {
        +
        16084  memRange.size = allocationSize - memRange.offset;
        +
        16085  }
        +
        16086  else
        +
        16087  {
        +
        16088  VMA_ASSERT(offset + size <= allocationSize);
        +
        16089  memRange.size = VMA_MIN(
        +
        16090  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
        +
        16091  allocationSize - memRange.offset);
        +
        16092  }
        +
        16093  break;
        16094 
        -
        16095  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
        -
        16096 }
        -
        16097 
        -
        16098 uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
        -
        16099 {
        -
        16100  VkBufferCreateInfo dummyBufCreateInfo;
        -
        16101  VmaFillGpuDefragmentationBufferCreateInfo(dummyBufCreateInfo);
        -
        16102 
        -
        16103  uint32_t memoryTypeBits = 0;
        -
        16104 
        -
        16105  // Create buffer.
        -
        16106  VkBuffer buf = VK_NULL_HANDLE;
        -
        16107  VkResult res = (*GetVulkanFunctions().vkCreateBuffer)(
        -
        16108  m_hDevice, &dummyBufCreateInfo, GetAllocationCallbacks(), &buf);
        -
        16109  if(res == VK_SUCCESS)
        -
        16110  {
        -
        16111  // Query for supported memory types.
        -
        16112  VkMemoryRequirements memReq;
        -
        16113  (*GetVulkanFunctions().vkGetBufferMemoryRequirements)(m_hDevice, buf, &memReq);
        -
        16114  memoryTypeBits = memReq.memoryTypeBits;
        -
        16115 
        -
        16116  // Destroy buffer.
        -
        16117  (*GetVulkanFunctions().vkDestroyBuffer)(m_hDevice, buf, GetAllocationCallbacks());
        -
        16118  }
        -
        16119 
        -
        16120  return memoryTypeBits;
        -
        16121 }
        +
        16095  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        +
        16096  {
        +
        16097  // 1. Still within this allocation.
        +
        16098  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        +
        16099  if(size == VK_WHOLE_SIZE)
        +
        16100  {
        +
        16101  size = allocationSize - offset;
        +
        16102  }
        +
        16103  else
        +
        16104  {
        +
        16105  VMA_ASSERT(offset + size <= allocationSize);
        +
        16106  }
        +
        16107  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
        +
        16108 
        +
        16109  // 2. Adjust to whole block.
        +
        16110  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
        +
        16111  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
        +
        16112  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_pMetadata->GetSize();
        +
        16113  memRange.offset += allocationOffset;
        +
        16114  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
        +
        16115 
        +
        16116  break;
        +
        16117  }
        +
        16118 
        +
        16119  default:
        +
        16120  VMA_ASSERT(0);
        +
        16121  }
        16122 
        -
        16123 #if VMA_MEMORY_BUDGET
        -
        16124 
        -
        16125 void VmaAllocator_T::UpdateVulkanBudget()
        -
        16126 {
        -
        16127  VMA_ASSERT(m_UseExtMemoryBudget);
        -
        16128 
        -
        16129  VkPhysicalDeviceMemoryProperties2KHR memProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR };
        -
        16130 
        -
        16131  VkPhysicalDeviceMemoryBudgetPropertiesEXT budgetProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT };
        -
        16132  memProps.pNext = &budgetProps;
        -
        16133 
        -
        16134  GetVulkanFunctions().vkGetPhysicalDeviceMemoryProperties2KHR(m_PhysicalDevice, &memProps);
        -
        16135 
        -
        16136  {
        -
        16137  VmaMutexLockWrite lockWrite(m_Budget.m_BudgetMutex, m_UseMutex);
        -
        16138 
        -
        16139  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        -
        16140  {
        -
        16141  m_Budget.m_VulkanUsage[heapIndex] = budgetProps.heapUsage[heapIndex];
        -
        16142  m_Budget.m_VulkanBudget[heapIndex] = budgetProps.heapBudget[heapIndex];
        -
        16143  m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] = m_Budget.m_BlockBytes[heapIndex].load();
        -
        16144  }
        -
        16145  m_Budget.m_OperationsSinceBudgetFetch = 0;
        -
        16146  }
        -
        16147 }
        -
        16148 
        -
        16149 #endif // #if VMA_MEMORY_BUDGET
        +
        16123  switch(op)
        +
        16124  {
        +
        16125  case VMA_CACHE_FLUSH:
        +
        16126  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
        +
        16127  break;
        +
        16128  case VMA_CACHE_INVALIDATE:
        +
        16129  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
        +
        16130  break;
        +
        16131  default:
        +
        16132  VMA_ASSERT(0);
        +
        16133  }
        +
        16134  }
        +
        16135  // else: Just ignore this call.
        +
        16136 }
        +
        16137 
        +
        16138 void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
        +
        16139 {
        +
        16140  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        +
        16141 
        +
        16142  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        +
        16143  {
        +
        16144  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        +
        16145  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        +
        16146  VMA_ASSERT(pDedicatedAllocations);
        +
        16147  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
        +
        16148  VMA_ASSERT(success);
        +
        16149  }
        16150 
        -
        16151 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
        -
        16152 {
        -
        16153  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
        -
        16154  !hAllocation->CanBecomeLost() &&
        -
        16155  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        -
        16156  {
        -
        16157  void* pData = VMA_NULL;
        -
        16158  VkResult res = Map(hAllocation, &pData);
        -
        16159  if(res == VK_SUCCESS)
        -
        16160  {
        -
        16161  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
        -
        16162  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
        -
        16163  Unmap(hAllocation);
        -
        16164  }
        -
        16165  else
        -
        16166  {
        -
        16167  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
        -
        16168  }
        -
        16169  }
        -
        16170 }
        -
        16171 
        -
        16172 uint32_t VmaAllocator_T::GetGpuDefragmentationMemoryTypeBits()
        -
        16173 {
        -
        16174  uint32_t memoryTypeBits = m_GpuDefragmentationMemoryTypeBits.load();
        -
        16175  if(memoryTypeBits == UINT32_MAX)
        -
        16176  {
        -
        16177  memoryTypeBits = CalculateGpuDefragmentationMemoryTypeBits();
        -
        16178  m_GpuDefragmentationMemoryTypeBits.store(memoryTypeBits);
        -
        16179  }
        -
        16180  return memoryTypeBits;
        -
        16181 }
        -
        16182 
        -
        16183 #if VMA_STATS_STRING_ENABLED
        -
        16184 
        -
        16185 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
        -
        16186 {
        -
        16187  bool dedicatedAllocationsStarted = false;
        -
        16188  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        -
        16189  {
        -
        16190  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        -
        16191  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        -
        16192  VMA_ASSERT(pDedicatedAllocVector);
        -
        16193  if(pDedicatedAllocVector->empty() == false)
        -
        16194  {
        -
        16195  if(dedicatedAllocationsStarted == false)
        -
        16196  {
        -
        16197  dedicatedAllocationsStarted = true;
        -
        16198  json.WriteString("DedicatedAllocations");
        -
        16199  json.BeginObject();
        -
        16200  }
        -
        16201 
        -
        16202  json.BeginString("Type ");
        -
        16203  json.ContinueString(memTypeIndex);
        -
        16204  json.EndString();
        -
        16205 
        -
        16206  json.BeginArray();
        -
        16207 
        -
        16208  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
        -
        16209  {
        -
        16210  json.BeginObject(true);
        -
        16211  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
        -
        16212  hAlloc->PrintParameters(json);
        -
        16213  json.EndObject();
        -
        16214  }
        -
        16215 
        -
        16216  json.EndArray();
        -
        16217  }
        -
        16218  }
        -
        16219  if(dedicatedAllocationsStarted)
        -
        16220  {
        -
        16221  json.EndObject();
        -
        16222  }
        -
        16223 
        -
        16224  {
        -
        16225  bool allocationsStarted = false;
        -
        16226  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        -
        16227  {
        -
        16228  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
        -
        16229  {
        -
        16230  if(allocationsStarted == false)
        -
        16231  {
        -
        16232  allocationsStarted = true;
        -
        16233  json.WriteString("DefaultPools");
        -
        16234  json.BeginObject();
        -
        16235  }
        -
        16236 
        -
        16237  json.BeginString("Type ");
        -
        16238  json.ContinueString(memTypeIndex);
        -
        16239  json.EndString();
        -
        16240 
        -
        16241  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
        -
        16242  }
        -
        16243  }
        -
        16244  if(allocationsStarted)
        -
        16245  {
        -
        16246  json.EndObject();
        -
        16247  }
        -
        16248  }
        -
        16249 
        -
        16250  // Custom pools
        -
        16251  {
        -
        16252  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        -
        16253  const size_t poolCount = m_Pools.size();
        -
        16254  if(poolCount > 0)
        -
        16255  {
        -
        16256  json.WriteString("Pools");
        -
        16257  json.BeginObject();
        -
        16258  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        -
        16259  {
        -
        16260  json.BeginString();
        -
        16261  json.ContinueString(m_Pools[poolIndex]->GetId());
        -
        16262  json.EndString();
        -
        16263 
        -
        16264  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
        -
        16265  }
        -
        16266  json.EndObject();
        -
        16267  }
        -
        16268  }
        -
        16269 }
        -
        16270 
        -
        16271 #endif // #if VMA_STATS_STRING_ENABLED
        -
        16272 
        -
        16274 // Public interface
        -
        16275 
        -
        16276 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
        -
        16277  const VmaAllocatorCreateInfo* pCreateInfo,
        -
        16278  VmaAllocator* pAllocator)
        -
        16279 {
        -
        16280  VMA_ASSERT(pCreateInfo && pAllocator);
        -
        16281  VMA_DEBUG_LOG("vmaCreateAllocator");
        -
        16282  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
        -
        16283  return (*pAllocator)->Init(pCreateInfo);
        -
        16284 }
        +
        16151  VkDeviceMemory hMemory = allocation->GetMemory();
        +
        16152 
        +
        16153  /*
        +
        16154  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
        +
        16155  before vkFreeMemory.
        +
        16156 
        +
        16157  if(allocation->GetMappedData() != VMA_NULL)
        +
        16158  {
        +
        16159  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
        +
        16160  }
        +
        16161  */
        +
        16162 
        +
        16163  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
        +
        16164 
        +
        16165  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
        +
        16166 }
        +
        16167 
        +
        16168 uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
        +
        16169 {
        +
        16170  VkBufferCreateInfo dummyBufCreateInfo;
        +
        16171  VmaFillGpuDefragmentationBufferCreateInfo(dummyBufCreateInfo);
        +
        16172 
        +
        16173  uint32_t memoryTypeBits = 0;
        +
        16174 
        +
        16175  // Create buffer.
        +
        16176  VkBuffer buf = VK_NULL_HANDLE;
        +
        16177  VkResult res = (*GetVulkanFunctions().vkCreateBuffer)(
        +
        16178  m_hDevice, &dummyBufCreateInfo, GetAllocationCallbacks(), &buf);
        +
        16179  if(res == VK_SUCCESS)
        +
        16180  {
        +
        16181  // Query for supported memory types.
        +
        16182  VkMemoryRequirements memReq;
        +
        16183  (*GetVulkanFunctions().vkGetBufferMemoryRequirements)(m_hDevice, buf, &memReq);
        +
        16184  memoryTypeBits = memReq.memoryTypeBits;
        +
        16185 
        +
        16186  // Destroy buffer.
        +
        16187  (*GetVulkanFunctions().vkDestroyBuffer)(m_hDevice, buf, GetAllocationCallbacks());
        +
        16188  }
        +
        16189 
        +
        16190  return memoryTypeBits;
        +
        16191 }
        +
        16192 
        +
        16193 #if VMA_MEMORY_BUDGET
        +
        16194 
        +
        16195 void VmaAllocator_T::UpdateVulkanBudget()
        +
        16196 {
        +
        16197  VMA_ASSERT(m_UseExtMemoryBudget);
        +
        16198 
        +
        16199  VkPhysicalDeviceMemoryProperties2KHR memProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR };
        +
        16200 
        +
        16201  VkPhysicalDeviceMemoryBudgetPropertiesEXT budgetProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT };
        +
        16202  memProps.pNext = &budgetProps;
        +
        16203 
        +
        16204  GetVulkanFunctions().vkGetPhysicalDeviceMemoryProperties2KHR(m_PhysicalDevice, &memProps);
        +
        16205 
        +
        16206  {
        +
        16207  VmaMutexLockWrite lockWrite(m_Budget.m_BudgetMutex, m_UseMutex);
        +
        16208 
        +
        16209  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        +
        16210  {
        +
        16211  m_Budget.m_VulkanUsage[heapIndex] = budgetProps.heapUsage[heapIndex];
        +
        16212  m_Budget.m_VulkanBudget[heapIndex] = budgetProps.heapBudget[heapIndex];
        +
        16213  m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] = m_Budget.m_BlockBytes[heapIndex].load();
        +
        16214  }
        +
        16215  m_Budget.m_OperationsSinceBudgetFetch = 0;
        +
        16216  }
        +
        16217 }
        +
        16218 
        +
        16219 #endif // #if VMA_MEMORY_BUDGET
        +
        16220 
        +
        16221 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
        +
        16222 {
        +
        16223  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
        +
        16224  !hAllocation->CanBecomeLost() &&
        +
        16225  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        +
        16226  {
        +
        16227  void* pData = VMA_NULL;
        +
        16228  VkResult res = Map(hAllocation, &pData);
        +
        16229  if(res == VK_SUCCESS)
        +
        16230  {
        +
        16231  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
        +
        16232  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
        +
        16233  Unmap(hAllocation);
        +
        16234  }
        +
        16235  else
        +
        16236  {
        +
        16237  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
        +
        16238  }
        +
        16239  }
        +
        16240 }
        +
        16241 
        +
        16242 uint32_t VmaAllocator_T::GetGpuDefragmentationMemoryTypeBits()
        +
        16243 {
        +
        16244  uint32_t memoryTypeBits = m_GpuDefragmentationMemoryTypeBits.load();
        +
        16245  if(memoryTypeBits == UINT32_MAX)
        +
        16246  {
        +
        16247  memoryTypeBits = CalculateGpuDefragmentationMemoryTypeBits();
        +
        16248  m_GpuDefragmentationMemoryTypeBits.store(memoryTypeBits);
        +
        16249  }
        +
        16250  return memoryTypeBits;
        +
        16251 }
        +
        16252 
        +
        16253 #if VMA_STATS_STRING_ENABLED
        +
        16254 
        +
        16255 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
        +
        16256 {
        +
        16257  bool dedicatedAllocationsStarted = false;
        +
        16258  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        +
        16259  {
        +
        16260  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        +
        16261  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        +
        16262  VMA_ASSERT(pDedicatedAllocVector);
        +
        16263  if(pDedicatedAllocVector->empty() == false)
        +
        16264  {
        +
        16265  if(dedicatedAllocationsStarted == false)
        +
        16266  {
        +
        16267  dedicatedAllocationsStarted = true;
        +
        16268  json.WriteString("DedicatedAllocations");
        +
        16269  json.BeginObject();
        +
        16270  }
        +
        16271 
        +
        16272  json.BeginString("Type ");
        +
        16273  json.ContinueString(memTypeIndex);
        +
        16274  json.EndString();
        +
        16275 
        +
        16276  json.BeginArray();
        +
        16277 
        +
        16278  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
        +
        16279  {
        +
        16280  json.BeginObject(true);
        +
        16281  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
        +
        16282  hAlloc->PrintParameters(json);
        +
        16283  json.EndObject();
        +
        16284  }
        16285 
        -
        16286 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
        -
        16287  VmaAllocator allocator)
        -
        16288 {
        -
        16289  if(allocator != VK_NULL_HANDLE)
        +
        16286  json.EndArray();
        +
        16287  }
        +
        16288  }
        +
        16289  if(dedicatedAllocationsStarted)
        16290  {
        -
        16291  VMA_DEBUG_LOG("vmaDestroyAllocator");
        -
        16292  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
        -
        16293  vma_delete(&allocationCallbacks, allocator);
        -
        16294  }
        -
        16295 }
        -
        16296 
        -
        16297 VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
        -
        16298  VmaAllocator allocator,
        -
        16299  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        -
        16300 {
        -
        16301  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
        -
        16302  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
        -
        16303 }
        -
        16304 
        -
        16305 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
        -
        16306  VmaAllocator allocator,
        -
        16307  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
        -
        16308 {
        -
        16309  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
        -
        16310  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
        -
        16311 }
        -
        16312 
        -
        16313 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
        -
        16314  VmaAllocator allocator,
        -
        16315  uint32_t memoryTypeIndex,
        -
        16316  VkMemoryPropertyFlags* pFlags)
        -
        16317 {
        -
        16318  VMA_ASSERT(allocator && pFlags);
        -
        16319  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
        -
        16320  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
        -
        16321 }
        -
        16322 
        -
        16323 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
        -
        16324  VmaAllocator allocator,
        -
        16325  uint32_t frameIndex)
        -
        16326 {
        -
        16327  VMA_ASSERT(allocator);
        -
        16328  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
        -
        16329 
        -
        16330  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16331 
        -
        16332  allocator->SetCurrentFrameIndex(frameIndex);
        -
        16333 }
        -
        16334 
        -
        16335 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
        -
        16336  VmaAllocator allocator,
        -
        16337  VmaStats* pStats)
        -
        16338 {
        -
        16339  VMA_ASSERT(allocator && pStats);
        -
        16340  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16341  allocator->CalculateStats(pStats);
        -
        16342 }
        -
        16343 
        -
        16344 VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
        -
        16345  VmaAllocator allocator,
        -
        16346  VmaBudget* pBudget)
        -
        16347 {
        -
        16348  VMA_ASSERT(allocator && pBudget);
        -
        16349  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16350  allocator->GetBudget(pBudget, 0, allocator->GetMemoryHeapCount());
        -
        16351 }
        -
        16352 
        -
        16353 #if VMA_STATS_STRING_ENABLED
        -
        16354 
        -
        16355 VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
        -
        16356  VmaAllocator allocator,
        -
        16357  char** ppStatsString,
        -
        16358  VkBool32 detailedMap)
        -
        16359 {
        -
        16360  VMA_ASSERT(allocator && ppStatsString);
        -
        16361  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16362 
        -
        16363  VmaStringBuilder sb(allocator);
        -
        16364  {
        -
        16365  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
        -
        16366  json.BeginObject();
        -
        16367 
        -
        16368  VmaBudget budget[VK_MAX_MEMORY_HEAPS];
        -
        16369  allocator->GetBudget(budget, 0, allocator->GetMemoryHeapCount());
        -
        16370 
        -
        16371  VmaStats stats;
        -
        16372  allocator->CalculateStats(&stats);
        -
        16373 
        -
        16374  json.WriteString("Total");
        -
        16375  VmaPrintStatInfo(json, stats.total);
        -
        16376 
        -
        16377  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
        -
        16378  {
        -
        16379  json.BeginString("Heap ");
        -
        16380  json.ContinueString(heapIndex);
        -
        16381  json.EndString();
        -
        16382  json.BeginObject();
        -
        16383 
        -
        16384  json.WriteString("Size");
        -
        16385  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
        -
        16386 
        -
        16387  json.WriteString("Flags");
        -
        16388  json.BeginArray(true);
        -
        16389  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
        -
        16390  {
        -
        16391  json.WriteString("DEVICE_LOCAL");
        -
        16392  }
        -
        16393  json.EndArray();
        +
        16291  json.EndObject();
        +
        16292  }
        +
        16293 
        +
        16294  {
        +
        16295  bool allocationsStarted = false;
        +
        16296  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        +
        16297  {
        +
        16298  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
        +
        16299  {
        +
        16300  if(allocationsStarted == false)
        +
        16301  {
        +
        16302  allocationsStarted = true;
        +
        16303  json.WriteString("DefaultPools");
        +
        16304  json.BeginObject();
        +
        16305  }
        +
        16306 
        +
        16307  json.BeginString("Type ");
        +
        16308  json.ContinueString(memTypeIndex);
        +
        16309  json.EndString();
        +
        16310 
        +
        16311  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
        +
        16312  }
        +
        16313  }
        +
        16314  if(allocationsStarted)
        +
        16315  {
        +
        16316  json.EndObject();
        +
        16317  }
        +
        16318  }
        +
        16319 
        +
        16320  // Custom pools
        +
        16321  {
        +
        16322  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
        +
        16323  const size_t poolCount = m_Pools.size();
        +
        16324  if(poolCount > 0)
        +
        16325  {
        +
        16326  json.WriteString("Pools");
        +
        16327  json.BeginObject();
        +
        16328  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        +
        16329  {
        +
        16330  json.BeginString();
        +
        16331  json.ContinueString(m_Pools[poolIndex]->GetId());
        +
        16332  json.EndString();
        +
        16333 
        +
        16334  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
        +
        16335  }
        +
        16336  json.EndObject();
        +
        16337  }
        +
        16338  }
        +
        16339 }
        +
        16340 
        +
        16341 #endif // #if VMA_STATS_STRING_ENABLED
        +
        16342 
        +
        16344 // Public interface
        +
        16345 
        +
        16346 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
        +
        16347  const VmaAllocatorCreateInfo* pCreateInfo,
        +
        16348  VmaAllocator* pAllocator)
        +
        16349 {
        +
        16350  VMA_ASSERT(pCreateInfo && pAllocator);
        +
        16351  VMA_ASSERT(pCreateInfo->vulkanApiVersion == 0 ||
        +
        16352  (VK_VERSION_MAJOR(pCreateInfo->vulkanApiVersion) == 1 && VK_VERSION_MINOR(pCreateInfo->vulkanApiVersion) <= 1));
        +
        16353  VMA_DEBUG_LOG("vmaCreateAllocator");
        +
        16354  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
        +
        16355  return (*pAllocator)->Init(pCreateInfo);
        +
        16356 }
        +
        16357 
        +
        16358 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
        +
        16359  VmaAllocator allocator)
        +
        16360 {
        +
        16361  if(allocator != VK_NULL_HANDLE)
        +
        16362  {
        +
        16363  VMA_DEBUG_LOG("vmaDestroyAllocator");
        +
        16364  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
        +
        16365  vma_delete(&allocationCallbacks, allocator);
        +
        16366  }
        +
        16367 }
        +
        16368 
        +
        16369 VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
        +
        16370  VmaAllocator allocator,
        +
        16371  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        +
        16372 {
        +
        16373  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
        +
        16374  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
        +
        16375 }
        +
        16376 
        +
        16377 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
        +
        16378  VmaAllocator allocator,
        +
        16379  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
        +
        16380 {
        +
        16381  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
        +
        16382  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
        +
        16383 }
        +
        16384 
        +
        16385 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
        +
        16386  VmaAllocator allocator,
        +
        16387  uint32_t memoryTypeIndex,
        +
        16388  VkMemoryPropertyFlags* pFlags)
        +
        16389 {
        +
        16390  VMA_ASSERT(allocator && pFlags);
        +
        16391  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
        +
        16392  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
        +
        16393 }
        16394 
        -
        16395  json.WriteString("Budget");
        -
        16396  json.BeginObject();
        -
        16397  {
        -
        16398  json.WriteString("BlockBytes");
        -
        16399  json.WriteNumber(budget[heapIndex].blockBytes);
        -
        16400  json.WriteString("AllocationBytes");
        -
        16401  json.WriteNumber(budget[heapIndex].allocationBytes);
        -
        16402  json.WriteString("Usage");
        -
        16403  json.WriteNumber(budget[heapIndex].usage);
        -
        16404  json.WriteString("Budget");
        -
        16405  json.WriteNumber(budget[heapIndex].budget);
        -
        16406  }
        -
        16407  json.EndObject();
        -
        16408 
        -
        16409  if(stats.memoryHeap[heapIndex].blockCount > 0)
        -
        16410  {
        -
        16411  json.WriteString("Stats");
        -
        16412  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
        -
        16413  }
        -
        16414 
        -
        16415  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
        -
        16416  {
        -
        16417  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
        -
        16418  {
        -
        16419  json.BeginString("Type ");
        -
        16420  json.ContinueString(typeIndex);
        -
        16421  json.EndString();
        -
        16422 
        -
        16423  json.BeginObject();
        +
        16395 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
        +
        16396  VmaAllocator allocator,
        +
        16397  uint32_t frameIndex)
        +
        16398 {
        +
        16399  VMA_ASSERT(allocator);
        +
        16400  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
        +
        16401 
        +
        16402  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16403 
        +
        16404  allocator->SetCurrentFrameIndex(frameIndex);
        +
        16405 }
        +
        16406 
        +
        16407 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
        +
        16408  VmaAllocator allocator,
        +
        16409  VmaStats* pStats)
        +
        16410 {
        +
        16411  VMA_ASSERT(allocator && pStats);
        +
        16412  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16413  allocator->CalculateStats(pStats);
        +
        16414 }
        +
        16415 
        +
        16416 VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
        +
        16417  VmaAllocator allocator,
        +
        16418  VmaBudget* pBudget)
        +
        16419 {
        +
        16420  VMA_ASSERT(allocator && pBudget);
        +
        16421  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16422  allocator->GetBudget(pBudget, 0, allocator->GetMemoryHeapCount());
        +
        16423 }
        16424 
        -
        16425  json.WriteString("Flags");
        -
        16426  json.BeginArray(true);
        -
        16427  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
        -
        16428  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        -
        16429  {
        -
        16430  json.WriteString("DEVICE_LOCAL");
        -
        16431  }
        -
        16432  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        -
        16433  {
        -
        16434  json.WriteString("HOST_VISIBLE");
        -
        16435  }
        -
        16436  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
        -
        16437  {
        -
        16438  json.WriteString("HOST_COHERENT");
        -
        16439  }
        -
        16440  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
        -
        16441  {
        -
        16442  json.WriteString("HOST_CACHED");
        -
        16443  }
        -
        16444  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
        -
        16445  {
        -
        16446  json.WriteString("LAZILY_ALLOCATED");
        -
        16447  }
        -
        16448  json.EndArray();
        -
        16449 
        -
        16450  if(stats.memoryType[typeIndex].blockCount > 0)
        -
        16451  {
        -
        16452  json.WriteString("Stats");
        -
        16453  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
        -
        16454  }
        +
        16425 #if VMA_STATS_STRING_ENABLED
        +
        16426 
        +
        16427 VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
        +
        16428  VmaAllocator allocator,
        +
        16429  char** ppStatsString,
        +
        16430  VkBool32 detailedMap)
        +
        16431 {
        +
        16432  VMA_ASSERT(allocator && ppStatsString);
        +
        16433  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16434 
        +
        16435  VmaStringBuilder sb(allocator);
        +
        16436  {
        +
        16437  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
        +
        16438  json.BeginObject();
        +
        16439 
        +
        16440  VmaBudget budget[VK_MAX_MEMORY_HEAPS];
        +
        16441  allocator->GetBudget(budget, 0, allocator->GetMemoryHeapCount());
        +
        16442 
        +
        16443  VmaStats stats;
        +
        16444  allocator->CalculateStats(&stats);
        +
        16445 
        +
        16446  json.WriteString("Total");
        +
        16447  VmaPrintStatInfo(json, stats.total);
        +
        16448 
        +
        16449  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
        +
        16450  {
        +
        16451  json.BeginString("Heap ");
        +
        16452  json.ContinueString(heapIndex);
        +
        16453  json.EndString();
        +
        16454  json.BeginObject();
        16455 
        -
        16456  json.EndObject();
        -
        16457  }
        -
        16458  }
        -
        16459 
        -
        16460  json.EndObject();
        -
        16461  }
        -
        16462  if(detailedMap == VK_TRUE)
        -
        16463  {
        -
        16464  allocator->PrintDetailedMap(json);
        -
        16465  }
        +
        16456  json.WriteString("Size");
        +
        16457  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
        +
        16458 
        +
        16459  json.WriteString("Flags");
        +
        16460  json.BeginArray(true);
        +
        16461  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
        +
        16462  {
        +
        16463  json.WriteString("DEVICE_LOCAL");
        +
        16464  }
        +
        16465  json.EndArray();
        16466 
        -
        16467  json.EndObject();
        -
        16468  }
        -
        16469 
        -
        16470  const size_t len = sb.GetLength();
        -
        16471  char* const pChars = vma_new_array(allocator, char, len + 1);
        -
        16472  if(len > 0)
        -
        16473  {
        -
        16474  memcpy(pChars, sb.GetData(), len);
        -
        16475  }
        -
        16476  pChars[len] = '\0';
        -
        16477  *ppStatsString = pChars;
        -
        16478 }
        -
        16479 
        -
        16480 VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
        -
        16481  VmaAllocator allocator,
        -
        16482  char* pStatsString)
        -
        16483 {
        -
        16484  if(pStatsString != VMA_NULL)
        -
        16485  {
        -
        16486  VMA_ASSERT(allocator);
        -
        16487  size_t len = strlen(pStatsString);
        -
        16488  vma_delete_array(allocator, pStatsString, len + 1);
        -
        16489  }
        -
        16490 }
        -
        16491 
        -
        16492 #endif // #if VMA_STATS_STRING_ENABLED
        -
        16493 
        -
        16494 /*
        -
        16495 This function is not protected by any mutex because it just reads immutable data.
        -
        16496 */
        -
        16497 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
        -
        16498  VmaAllocator allocator,
        -
        16499  uint32_t memoryTypeBits,
        -
        16500  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        16501  uint32_t* pMemoryTypeIndex)
        -
        16502 {
        -
        16503  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        -
        16504  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        -
        16505  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        -
        16506 
        -
        16507  if(pAllocationCreateInfo->memoryTypeBits != 0)
        -
        16508  {
        -
        16509  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
        -
        16510  }
        -
        16511 
        -
        16512  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
        -
        16513  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
        -
        16514  uint32_t notPreferredFlags = 0;
        -
        16515 
        -
        16516  // Convert usage to requiredFlags and preferredFlags.
        -
        16517  switch(pAllocationCreateInfo->usage)
        -
        16518  {
        -
        16519  case VMA_MEMORY_USAGE_UNKNOWN:
        -
        16520  break;
        -
        16521  case VMA_MEMORY_USAGE_GPU_ONLY:
        -
        16522  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        -
        16523  {
        -
        16524  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        -
        16525  }
        -
        16526  break;
        -
        16527  case VMA_MEMORY_USAGE_CPU_ONLY:
        -
        16528  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        -
        16529  break;
        -
        16530  case VMA_MEMORY_USAGE_CPU_TO_GPU:
        -
        16531  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        -
        16532  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        -
        16533  {
        -
        16534  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        -
        16535  }
        -
        16536  break;
        -
        16537  case VMA_MEMORY_USAGE_GPU_TO_CPU:
        -
        16538  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        -
        16539  preferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        -
        16540  break;
        -
        16541  case VMA_MEMORY_USAGE_CPU_COPY:
        -
        16542  notPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        -
        16543  break;
        -
        16544  case VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED:
        -
        16545  requiredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
        -
        16546  break;
        -
        16547  default:
        -
        16548  VMA_ASSERT(0);
        -
        16549  break;
        -
        16550  }
        +
        16467  json.WriteString("Budget");
        +
        16468  json.BeginObject();
        +
        16469  {
        +
        16470  json.WriteString("BlockBytes");
        +
        16471  json.WriteNumber(budget[heapIndex].blockBytes);
        +
        16472  json.WriteString("AllocationBytes");
        +
        16473  json.WriteNumber(budget[heapIndex].allocationBytes);
        +
        16474  json.WriteString("Usage");
        +
        16475  json.WriteNumber(budget[heapIndex].usage);
        +
        16476  json.WriteString("Budget");
        +
        16477  json.WriteNumber(budget[heapIndex].budget);
        +
        16478  }
        +
        16479  json.EndObject();
        +
        16480 
        +
        16481  if(stats.memoryHeap[heapIndex].blockCount > 0)
        +
        16482  {
        +
        16483  json.WriteString("Stats");
        +
        16484  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
        +
        16485  }
        +
        16486 
        +
        16487  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
        +
        16488  {
        +
        16489  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
        +
        16490  {
        +
        16491  json.BeginString("Type ");
        +
        16492  json.ContinueString(typeIndex);
        +
        16493  json.EndString();
        +
        16494 
        +
        16495  json.BeginObject();
        +
        16496 
        +
        16497  json.WriteString("Flags");
        +
        16498  json.BeginArray(true);
        +
        16499  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
        +
        16500  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        +
        16501  {
        +
        16502  json.WriteString("DEVICE_LOCAL");
        +
        16503  }
        +
        16504  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        +
        16505  {
        +
        16506  json.WriteString("HOST_VISIBLE");
        +
        16507  }
        +
        16508  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
        +
        16509  {
        +
        16510  json.WriteString("HOST_COHERENT");
        +
        16511  }
        +
        16512  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
        +
        16513  {
        +
        16514  json.WriteString("HOST_CACHED");
        +
        16515  }
        +
        16516  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
        +
        16517  {
        +
        16518  json.WriteString("LAZILY_ALLOCATED");
        +
        16519  }
        +
        16520  json.EndArray();
        +
        16521 
        +
        16522  if(stats.memoryType[typeIndex].blockCount > 0)
        +
        16523  {
        +
        16524  json.WriteString("Stats");
        +
        16525  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
        +
        16526  }
        +
        16527 
        +
        16528  json.EndObject();
        +
        16529  }
        +
        16530  }
        +
        16531 
        +
        16532  json.EndObject();
        +
        16533  }
        +
        16534  if(detailedMap == VK_TRUE)
        +
        16535  {
        +
        16536  allocator->PrintDetailedMap(json);
        +
        16537  }
        +
        16538 
        +
        16539  json.EndObject();
        +
        16540  }
        +
        16541 
        +
        16542  const size_t len = sb.GetLength();
        +
        16543  char* const pChars = vma_new_array(allocator, char, len + 1);
        +
        16544  if(len > 0)
        +
        16545  {
        +
        16546  memcpy(pChars, sb.GetData(), len);
        +
        16547  }
        +
        16548  pChars[len] = '\0';
        +
        16549  *ppStatsString = pChars;
        +
        16550 }
        16551 
        -
        16552  *pMemoryTypeIndex = UINT32_MAX;
        -
        16553  uint32_t minCost = UINT32_MAX;
        -
        16554  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
        -
        16555  memTypeIndex < allocator->GetMemoryTypeCount();
        -
        16556  ++memTypeIndex, memTypeBit <<= 1)
        +
        16552 VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
        +
        16553  VmaAllocator allocator,
        +
        16554  char* pStatsString)
        +
        16555 {
        +
        16556  if(pStatsString != VMA_NULL)
        16557  {
        -
        16558  // This memory type is acceptable according to memoryTypeBits bitmask.
        -
        16559  if((memTypeBit & memoryTypeBits) != 0)
        -
        16560  {
        -
        16561  const VkMemoryPropertyFlags currFlags =
        -
        16562  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        -
        16563  // This memory type contains requiredFlags.
        -
        16564  if((requiredFlags & ~currFlags) == 0)
        -
        16565  {
        -
        16566  // Calculate cost as number of bits from preferredFlags not present in this memory type.
        -
        16567  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags) +
        -
        16568  VmaCountBitsSet(currFlags & notPreferredFlags);
        -
        16569  // Remember memory type with lowest cost.
        -
        16570  if(currCost < minCost)
        -
        16571  {
        -
        16572  *pMemoryTypeIndex = memTypeIndex;
        -
        16573  if(currCost == 0)
        -
        16574  {
        -
        16575  return VK_SUCCESS;
        -
        16576  }
        -
        16577  minCost = currCost;
        -
        16578  }
        -
        16579  }
        -
        16580  }
        -
        16581  }
        -
        16582  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
        -
        16583 }
        -
        16584 
        -
        16585 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
        -
        16586  VmaAllocator allocator,
        -
        16587  const VkBufferCreateInfo* pBufferCreateInfo,
        -
        16588  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        16589  uint32_t* pMemoryTypeIndex)
        -
        16590 {
        -
        16591  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        -
        16592  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
        -
        16593  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        -
        16594  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        -
        16595 
        -
        16596  const VkDevice hDev = allocator->m_hDevice;
        -
        16597  VkBuffer hBuffer = VK_NULL_HANDLE;
        -
        16598  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
        -
        16599  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
        -
        16600  if(res == VK_SUCCESS)
        -
        16601  {
        -
        16602  VkMemoryRequirements memReq = {};
        -
        16603  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
        -
        16604  hDev, hBuffer, &memReq);
        -
        16605 
        -
        16606  res = vmaFindMemoryTypeIndex(
        -
        16607  allocator,
        -
        16608  memReq.memoryTypeBits,
        -
        16609  pAllocationCreateInfo,
        -
        16610  pMemoryTypeIndex);
        -
        16611 
        -
        16612  allocator->GetVulkanFunctions().vkDestroyBuffer(
        -
        16613  hDev, hBuffer, allocator->GetAllocationCallbacks());
        -
        16614  }
        -
        16615  return res;
        -
        16616 }
        -
        16617 
        -
        16618 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
        -
        16619  VmaAllocator allocator,
        -
        16620  const VkImageCreateInfo* pImageCreateInfo,
        -
        16621  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        16622  uint32_t* pMemoryTypeIndex)
        -
        16623 {
        -
        16624  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        -
        16625  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
        -
        16626  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        -
        16627  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        -
        16628 
        -
        16629  const VkDevice hDev = allocator->m_hDevice;
        -
        16630  VkImage hImage = VK_NULL_HANDLE;
        -
        16631  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
        -
        16632  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
        -
        16633  if(res == VK_SUCCESS)
        -
        16634  {
        -
        16635  VkMemoryRequirements memReq = {};
        -
        16636  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
        -
        16637  hDev, hImage, &memReq);
        -
        16638 
        -
        16639  res = vmaFindMemoryTypeIndex(
        -
        16640  allocator,
        -
        16641  memReq.memoryTypeBits,
        -
        16642  pAllocationCreateInfo,
        -
        16643  pMemoryTypeIndex);
        -
        16644 
        -
        16645  allocator->GetVulkanFunctions().vkDestroyImage(
        -
        16646  hDev, hImage, allocator->GetAllocationCallbacks());
        -
        16647  }
        -
        16648  return res;
        -
        16649 }
        -
        16650 
        -
        16651 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
        -
        16652  VmaAllocator allocator,
        -
        16653  const VmaPoolCreateInfo* pCreateInfo,
        -
        16654  VmaPool* pPool)
        -
        16655 {
        -
        16656  VMA_ASSERT(allocator && pCreateInfo && pPool);
        -
        16657 
        -
        16658  VMA_DEBUG_LOG("vmaCreatePool");
        -
        16659 
        -
        16660  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16661 
        -
        16662  VkResult res = allocator->CreatePool(pCreateInfo, pPool);
        -
        16663 
        -
        16664 #if VMA_RECORDING_ENABLED
        -
        16665  if(allocator->GetRecorder() != VMA_NULL)
        -
        16666  {
        -
        16667  allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
        -
        16668  }
        -
        16669 #endif
        -
        16670 
        -
        16671  return res;
        -
        16672 }
        -
        16673 
        -
        16674 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
        -
        16675  VmaAllocator allocator,
        -
        16676  VmaPool pool)
        -
        16677 {
        -
        16678  VMA_ASSERT(allocator);
        -
        16679 
        -
        16680  if(pool == VK_NULL_HANDLE)
        -
        16681  {
        -
        16682  return;
        -
        16683  }
        -
        16684 
        -
        16685  VMA_DEBUG_LOG("vmaDestroyPool");
        -
        16686 
        -
        16687  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16688 
        -
        16689 #if VMA_RECORDING_ENABLED
        -
        16690  if(allocator->GetRecorder() != VMA_NULL)
        -
        16691  {
        -
        16692  allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
        -
        16693  }
        -
        16694 #endif
        -
        16695 
        -
        16696  allocator->DestroyPool(pool);
        -
        16697 }
        -
        16698 
        -
        16699 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
        -
        16700  VmaAllocator allocator,
        -
        16701  VmaPool pool,
        -
        16702  VmaPoolStats* pPoolStats)
        -
        16703 {
        -
        16704  VMA_ASSERT(allocator && pool && pPoolStats);
        -
        16705 
        -
        16706  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16707 
        -
        16708  allocator->GetPoolStats(pool, pPoolStats);
        -
        16709 }
        +
        16558  VMA_ASSERT(allocator);
        +
        16559  size_t len = strlen(pStatsString);
        +
        16560  vma_delete_array(allocator, pStatsString, len + 1);
        +
        16561  }
        +
        16562 }
        +
        16563 
        +
        16564 #endif // #if VMA_STATS_STRING_ENABLED
        +
        16565 
        +
        16566 /*
        +
        16567 This function is not protected by any mutex because it just reads immutable data.
        +
        16568 */
        +
        16569 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
        +
        16570  VmaAllocator allocator,
        +
        16571  uint32_t memoryTypeBits,
        +
        16572  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        16573  uint32_t* pMemoryTypeIndex)
        +
        16574 {
        +
        16575  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        +
        16576  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        +
        16577  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        +
        16578 
        +
        16579  if(pAllocationCreateInfo->memoryTypeBits != 0)
        +
        16580  {
        +
        16581  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
        +
        16582  }
        +
        16583 
        +
        16584  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
        +
        16585  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
        +
        16586  uint32_t notPreferredFlags = 0;
        +
        16587 
        +
        16588  // Convert usage to requiredFlags and preferredFlags.
        +
        16589  switch(pAllocationCreateInfo->usage)
        +
        16590  {
        +
        16591  case VMA_MEMORY_USAGE_UNKNOWN:
        +
        16592  break;
        +
        16593  case VMA_MEMORY_USAGE_GPU_ONLY:
        +
        16594  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        +
        16595  {
        +
        16596  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        +
        16597  }
        +
        16598  break;
        +
        16599  case VMA_MEMORY_USAGE_CPU_ONLY:
        +
        16600  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        +
        16601  break;
        +
        16602  case VMA_MEMORY_USAGE_CPU_TO_GPU:
        +
        16603  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        +
        16604  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        +
        16605  {
        +
        16606  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        +
        16607  }
        +
        16608  break;
        +
        16609  case VMA_MEMORY_USAGE_GPU_TO_CPU:
        +
        16610  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        +
        16611  preferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        +
        16612  break;
        +
        16613  case VMA_MEMORY_USAGE_CPU_COPY:
        +
        16614  notPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        +
        16615  break;
        +
        16616  case VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED:
        +
        16617  requiredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
        +
        16618  break;
        +
        16619  default:
        +
        16620  VMA_ASSERT(0);
        +
        16621  break;
        +
        16622  }
        +
        16623 
        +
        16624  *pMemoryTypeIndex = UINT32_MAX;
        +
        16625  uint32_t minCost = UINT32_MAX;
        +
        16626  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
        +
        16627  memTypeIndex < allocator->GetMemoryTypeCount();
        +
        16628  ++memTypeIndex, memTypeBit <<= 1)
        +
        16629  {
        +
        16630  // This memory type is acceptable according to memoryTypeBits bitmask.
        +
        16631  if((memTypeBit & memoryTypeBits) != 0)
        +
        16632  {
        +
        16633  const VkMemoryPropertyFlags currFlags =
        +
        16634  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        +
        16635  // This memory type contains requiredFlags.
        +
        16636  if((requiredFlags & ~currFlags) == 0)
        +
        16637  {
        +
        16638  // Calculate cost as number of bits from preferredFlags not present in this memory type.
        +
        16639  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags) +
        +
        16640  VmaCountBitsSet(currFlags & notPreferredFlags);
        +
        16641  // Remember memory type with lowest cost.
        +
        16642  if(currCost < minCost)
        +
        16643  {
        +
        16644  *pMemoryTypeIndex = memTypeIndex;
        +
        16645  if(currCost == 0)
        +
        16646  {
        +
        16647  return VK_SUCCESS;
        +
        16648  }
        +
        16649  minCost = currCost;
        +
        16650  }
        +
        16651  }
        +
        16652  }
        +
        16653  }
        +
        16654  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
        +
        16655 }
        +
        16656 
        +
        16657 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
        +
        16658  VmaAllocator allocator,
        +
        16659  const VkBufferCreateInfo* pBufferCreateInfo,
        +
        16660  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        16661  uint32_t* pMemoryTypeIndex)
        +
        16662 {
        +
        16663  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        +
        16664  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
        +
        16665  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        +
        16666  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        +
        16667 
        +
        16668  const VkDevice hDev = allocator->m_hDevice;
        +
        16669  VkBuffer hBuffer = VK_NULL_HANDLE;
        +
        16670  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
        +
        16671  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
        +
        16672  if(res == VK_SUCCESS)
        +
        16673  {
        +
        16674  VkMemoryRequirements memReq = {};
        +
        16675  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
        +
        16676  hDev, hBuffer, &memReq);
        +
        16677 
        +
        16678  res = vmaFindMemoryTypeIndex(
        +
        16679  allocator,
        +
        16680  memReq.memoryTypeBits,
        +
        16681  pAllocationCreateInfo,
        +
        16682  pMemoryTypeIndex);
        +
        16683 
        +
        16684  allocator->GetVulkanFunctions().vkDestroyBuffer(
        +
        16685  hDev, hBuffer, allocator->GetAllocationCallbacks());
        +
        16686  }
        +
        16687  return res;
        +
        16688 }
        +
        16689 
        +
        16690 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
        +
        16691  VmaAllocator allocator,
        +
        16692  const VkImageCreateInfo* pImageCreateInfo,
        +
        16693  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        16694  uint32_t* pMemoryTypeIndex)
        +
        16695 {
        +
        16696  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        +
        16697  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
        +
        16698  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        +
        16699  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        +
        16700 
        +
        16701  const VkDevice hDev = allocator->m_hDevice;
        +
        16702  VkImage hImage = VK_NULL_HANDLE;
        +
        16703  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
        +
        16704  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
        +
        16705  if(res == VK_SUCCESS)
        +
        16706  {
        +
        16707  VkMemoryRequirements memReq = {};
        +
        16708  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
        +
        16709  hDev, hImage, &memReq);
        16710 
        -
        16711 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
        -
        16712  VmaAllocator allocator,
        -
        16713  VmaPool pool,
        -
        16714  size_t* pLostAllocationCount)
        -
        16715 {
        -
        16716  VMA_ASSERT(allocator && pool);
        -
        16717 
        -
        16718  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16719 
        -
        16720 #if VMA_RECORDING_ENABLED
        -
        16721  if(allocator->GetRecorder() != VMA_NULL)
        -
        16722  {
        -
        16723  allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
        -
        16724  }
        -
        16725 #endif
        -
        16726 
        -
        16727  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
        -
        16728 }
        -
        16729 
        -
        16730 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
        -
        16731 {
        -
        16732  VMA_ASSERT(allocator && pool);
        -
        16733 
        -
        16734  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16735 
        -
        16736  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
        -
        16737 
        -
        16738  return allocator->CheckPoolCorruption(pool);
        -
        16739 }
        -
        16740 
        -
        16741 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
        -
        16742  VmaAllocator allocator,
        -
        16743  VmaPool pool,
        -
        16744  const char** ppName)
        -
        16745 {
        -
        16746  VMA_ASSERT(allocator && pool);
        -
        16747 
        -
        16748  VMA_DEBUG_LOG("vmaGetPoolName");
        -
        16749 
        -
        16750  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16751 
        -
        16752  *ppName = pool->GetName();
        -
        16753 }
        -
        16754 
        -
        16755 VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
        -
        16756  VmaAllocator allocator,
        -
        16757  VmaPool pool,
        -
        16758  const char* pName)
        -
        16759 {
        -
        16760  VMA_ASSERT(allocator && pool);
        -
        16761 
        -
        16762  VMA_DEBUG_LOG("vmaSetPoolName");
        -
        16763 
        -
        16764  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16765 
        -
        16766  pool->SetName(pName);
        +
        16711  res = vmaFindMemoryTypeIndex(
        +
        16712  allocator,
        +
        16713  memReq.memoryTypeBits,
        +
        16714  pAllocationCreateInfo,
        +
        16715  pMemoryTypeIndex);
        +
        16716 
        +
        16717  allocator->GetVulkanFunctions().vkDestroyImage(
        +
        16718  hDev, hImage, allocator->GetAllocationCallbacks());
        +
        16719  }
        +
        16720  return res;
        +
        16721 }
        +
        16722 
        +
        16723 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
        +
        16724  VmaAllocator allocator,
        +
        16725  const VmaPoolCreateInfo* pCreateInfo,
        +
        16726  VmaPool* pPool)
        +
        16727 {
        +
        16728  VMA_ASSERT(allocator && pCreateInfo && pPool);
        +
        16729 
        +
        16730  VMA_DEBUG_LOG("vmaCreatePool");
        +
        16731 
        +
        16732  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16733 
        +
        16734  VkResult res = allocator->CreatePool(pCreateInfo, pPool);
        +
        16735 
        +
        16736 #if VMA_RECORDING_ENABLED
        +
        16737  if(allocator->GetRecorder() != VMA_NULL)
        +
        16738  {
        +
        16739  allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
        +
        16740  }
        +
        16741 #endif
        +
        16742 
        +
        16743  return res;
        +
        16744 }
        +
        16745 
        +
        16746 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
        +
        16747  VmaAllocator allocator,
        +
        16748  VmaPool pool)
        +
        16749 {
        +
        16750  VMA_ASSERT(allocator);
        +
        16751 
        +
        16752  if(pool == VK_NULL_HANDLE)
        +
        16753  {
        +
        16754  return;
        +
        16755  }
        +
        16756 
        +
        16757  VMA_DEBUG_LOG("vmaDestroyPool");
        +
        16758 
        +
        16759  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16760 
        +
        16761 #if VMA_RECORDING_ENABLED
        +
        16762  if(allocator->GetRecorder() != VMA_NULL)
        +
        16763  {
        +
        16764  allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
        +
        16765  }
        +
        16766 #endif
        16767 
        -
        16768 #if VMA_RECORDING_ENABLED
        -
        16769  if(allocator->GetRecorder() != VMA_NULL)
        -
        16770  {
        -
        16771  allocator->GetRecorder()->RecordSetPoolName(allocator->GetCurrentFrameIndex(), pool, pName);
        -
        16772  }
        -
        16773 #endif
        -
        16774 }
        -
        16775 
        -
        16776 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
        -
        16777  VmaAllocator allocator,
        -
        16778  const VkMemoryRequirements* pVkMemoryRequirements,
        -
        16779  const VmaAllocationCreateInfo* pCreateInfo,
        -
        16780  VmaAllocation* pAllocation,
        -
        16781  VmaAllocationInfo* pAllocationInfo)
        -
        16782 {
        -
        16783  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
        -
        16784 
        -
        16785  VMA_DEBUG_LOG("vmaAllocateMemory");
        -
        16786 
        -
        16787  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16788 
        -
        16789  VkResult result = allocator->AllocateMemory(
        -
        16790  *pVkMemoryRequirements,
        -
        16791  false, // requiresDedicatedAllocation
        -
        16792  false, // prefersDedicatedAllocation
        -
        16793  VK_NULL_HANDLE, // dedicatedBuffer
        -
        16794  VK_NULL_HANDLE, // dedicatedImage
        -
        16795  *pCreateInfo,
        -
        16796  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        -
        16797  1, // allocationCount
        -
        16798  pAllocation);
        -
        16799 
        -
        16800 #if VMA_RECORDING_ENABLED
        -
        16801  if(allocator->GetRecorder() != VMA_NULL)
        -
        16802  {
        -
        16803  allocator->GetRecorder()->RecordAllocateMemory(
        -
        16804  allocator->GetCurrentFrameIndex(),
        -
        16805  *pVkMemoryRequirements,
        -
        16806  *pCreateInfo,
        -
        16807  *pAllocation);
        -
        16808  }
        -
        16809 #endif
        -
        16810 
        -
        16811  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
        -
        16812  {
        -
        16813  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        -
        16814  }
        -
        16815 
        -
        16816  return result;
        -
        16817 }
        -
        16818 
        -
        16819 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
        -
        16820  VmaAllocator allocator,
        -
        16821  const VkMemoryRequirements* pVkMemoryRequirements,
        -
        16822  const VmaAllocationCreateInfo* pCreateInfo,
        -
        16823  size_t allocationCount,
        -
        16824  VmaAllocation* pAllocations,
        -
        16825  VmaAllocationInfo* pAllocationInfo)
        -
        16826 {
        -
        16827  if(allocationCount == 0)
        -
        16828  {
        -
        16829  return VK_SUCCESS;
        -
        16830  }
        -
        16831 
        -
        16832  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocations);
        +
        16768  allocator->DestroyPool(pool);
        +
        16769 }
        +
        16770 
        +
        16771 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
        +
        16772  VmaAllocator allocator,
        +
        16773  VmaPool pool,
        +
        16774  VmaPoolStats* pPoolStats)
        +
        16775 {
        +
        16776  VMA_ASSERT(allocator && pool && pPoolStats);
        +
        16777 
        +
        16778  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16779 
        +
        16780  allocator->GetPoolStats(pool, pPoolStats);
        +
        16781 }
        +
        16782 
        +
        16783 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
        +
        16784  VmaAllocator allocator,
        +
        16785  VmaPool pool,
        +
        16786  size_t* pLostAllocationCount)
        +
        16787 {
        +
        16788  VMA_ASSERT(allocator && pool);
        +
        16789 
        +
        16790  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16791 
        +
        16792 #if VMA_RECORDING_ENABLED
        +
        16793  if(allocator->GetRecorder() != VMA_NULL)
        +
        16794  {
        +
        16795  allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
        +
        16796  }
        +
        16797 #endif
        +
        16798 
        +
        16799  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
        +
        16800 }
        +
        16801 
        +
        16802 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
        +
        16803 {
        +
        16804  VMA_ASSERT(allocator && pool);
        +
        16805 
        +
        16806  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16807 
        +
        16808  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
        +
        16809 
        +
        16810  return allocator->CheckPoolCorruption(pool);
        +
        16811 }
        +
        16812 
        +
        16813 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
        +
        16814  VmaAllocator allocator,
        +
        16815  VmaPool pool,
        +
        16816  const char** ppName)
        +
        16817 {
        +
        16818  VMA_ASSERT(allocator && pool);
        +
        16819 
        +
        16820  VMA_DEBUG_LOG("vmaGetPoolName");
        +
        16821 
        +
        16822  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16823 
        +
        16824  *ppName = pool->GetName();
        +
        16825 }
        +
        16826 
        +
        16827 VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
        +
        16828  VmaAllocator allocator,
        +
        16829  VmaPool pool,
        +
        16830  const char* pName)
        +
        16831 {
        +
        16832  VMA_ASSERT(allocator && pool);
        16833 
        -
        16834  VMA_DEBUG_LOG("vmaAllocateMemoryPages");
        +
        16834  VMA_DEBUG_LOG("vmaSetPoolName");
        16835 
        16836  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        16837 
        -
        16838  VkResult result = allocator->AllocateMemory(
        -
        16839  *pVkMemoryRequirements,
        -
        16840  false, // requiresDedicatedAllocation
        -
        16841  false, // prefersDedicatedAllocation
        -
        16842  VK_NULL_HANDLE, // dedicatedBuffer
        -
        16843  VK_NULL_HANDLE, // dedicatedImage
        -
        16844  *pCreateInfo,
        -
        16845  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        -
        16846  allocationCount,
        -
        16847  pAllocations);
        -
        16848 
        -
        16849 #if VMA_RECORDING_ENABLED
        -
        16850  if(allocator->GetRecorder() != VMA_NULL)
        -
        16851  {
        -
        16852  allocator->GetRecorder()->RecordAllocateMemoryPages(
        -
        16853  allocator->GetCurrentFrameIndex(),
        -
        16854  *pVkMemoryRequirements,
        -
        16855  *pCreateInfo,
        -
        16856  (uint64_t)allocationCount,
        -
        16857  pAllocations);
        -
        16858  }
        -
        16859 #endif
        -
        16860 
        -
        16861  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
        -
        16862  {
        -
        16863  for(size_t i = 0; i < allocationCount; ++i)
        -
        16864  {
        -
        16865  allocator->GetAllocationInfo(pAllocations[i], pAllocationInfo + i);
        -
        16866  }
        -
        16867  }
        -
        16868 
        -
        16869  return result;
        -
        16870 }
        +
        16838  pool->SetName(pName);
        +
        16839 
        +
        16840 #if VMA_RECORDING_ENABLED
        +
        16841  if(allocator->GetRecorder() != VMA_NULL)
        +
        16842  {
        +
        16843  allocator->GetRecorder()->RecordSetPoolName(allocator->GetCurrentFrameIndex(), pool, pName);
        +
        16844  }
        +
        16845 #endif
        +
        16846 }
        +
        16847 
        +
        16848 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
        +
        16849  VmaAllocator allocator,
        +
        16850  const VkMemoryRequirements* pVkMemoryRequirements,
        +
        16851  const VmaAllocationCreateInfo* pCreateInfo,
        +
        16852  VmaAllocation* pAllocation,
        +
        16853  VmaAllocationInfo* pAllocationInfo)
        +
        16854 {
        +
        16855  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
        +
        16856 
        +
        16857  VMA_DEBUG_LOG("vmaAllocateMemory");
        +
        16858 
        +
        16859  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16860 
        +
        16861  VkResult result = allocator->AllocateMemory(
        +
        16862  *pVkMemoryRequirements,
        +
        16863  false, // requiresDedicatedAllocation
        +
        16864  false, // prefersDedicatedAllocation
        +
        16865  VK_NULL_HANDLE, // dedicatedBuffer
        +
        16866  VK_NULL_HANDLE, // dedicatedImage
        +
        16867  *pCreateInfo,
        +
        16868  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        +
        16869  1, // allocationCount
        +
        16870  pAllocation);
        16871 
        -
        16872 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
        -
        16873  VmaAllocator allocator,
        -
        16874  VkBuffer buffer,
        -
        16875  const VmaAllocationCreateInfo* pCreateInfo,
        -
        16876  VmaAllocation* pAllocation,
        -
        16877  VmaAllocationInfo* pAllocationInfo)
        -
        16878 {
        -
        16879  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        -
        16880 
        -
        16881  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
        -
        16882 
        -
        16883  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16884 
        -
        16885  VkMemoryRequirements vkMemReq = {};
        -
        16886  bool requiresDedicatedAllocation = false;
        -
        16887  bool prefersDedicatedAllocation = false;
        -
        16888  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
        -
        16889  requiresDedicatedAllocation,
        -
        16890  prefersDedicatedAllocation);
        -
        16891 
        -
        16892  VkResult result = allocator->AllocateMemory(
        -
        16893  vkMemReq,
        -
        16894  requiresDedicatedAllocation,
        -
        16895  prefersDedicatedAllocation,
        -
        16896  buffer, // dedicatedBuffer
        -
        16897  VK_NULL_HANDLE, // dedicatedImage
        -
        16898  *pCreateInfo,
        -
        16899  VMA_SUBALLOCATION_TYPE_BUFFER,
        -
        16900  1, // allocationCount
        -
        16901  pAllocation);
        -
        16902 
        -
        16903 #if VMA_RECORDING_ENABLED
        -
        16904  if(allocator->GetRecorder() != VMA_NULL)
        -
        16905  {
        -
        16906  allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
        -
        16907  allocator->GetCurrentFrameIndex(),
        -
        16908  vkMemReq,
        -
        16909  requiresDedicatedAllocation,
        -
        16910  prefersDedicatedAllocation,
        -
        16911  *pCreateInfo,
        -
        16912  *pAllocation);
        -
        16913  }
        -
        16914 #endif
        -
        16915 
        -
        16916  if(pAllocationInfo && result == VK_SUCCESS)
        -
        16917  {
        -
        16918  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        -
        16919  }
        +
        16872 #if VMA_RECORDING_ENABLED
        +
        16873  if(allocator->GetRecorder() != VMA_NULL)
        +
        16874  {
        +
        16875  allocator->GetRecorder()->RecordAllocateMemory(
        +
        16876  allocator->GetCurrentFrameIndex(),
        +
        16877  *pVkMemoryRequirements,
        +
        16878  *pCreateInfo,
        +
        16879  *pAllocation);
        +
        16880  }
        +
        16881 #endif
        +
        16882 
        +
        16883  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
        +
        16884  {
        +
        16885  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        +
        16886  }
        +
        16887 
        +
        16888  return result;
        +
        16889 }
        +
        16890 
        +
        16891 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
        +
        16892  VmaAllocator allocator,
        +
        16893  const VkMemoryRequirements* pVkMemoryRequirements,
        +
        16894  const VmaAllocationCreateInfo* pCreateInfo,
        +
        16895  size_t allocationCount,
        +
        16896  VmaAllocation* pAllocations,
        +
        16897  VmaAllocationInfo* pAllocationInfo)
        +
        16898 {
        +
        16899  if(allocationCount == 0)
        +
        16900  {
        +
        16901  return VK_SUCCESS;
        +
        16902  }
        +
        16903 
        +
        16904  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocations);
        +
        16905 
        +
        16906  VMA_DEBUG_LOG("vmaAllocateMemoryPages");
        +
        16907 
        +
        16908  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16909 
        +
        16910  VkResult result = allocator->AllocateMemory(
        +
        16911  *pVkMemoryRequirements,
        +
        16912  false, // requiresDedicatedAllocation
        +
        16913  false, // prefersDedicatedAllocation
        +
        16914  VK_NULL_HANDLE, // dedicatedBuffer
        +
        16915  VK_NULL_HANDLE, // dedicatedImage
        +
        16916  *pCreateInfo,
        +
        16917  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        +
        16918  allocationCount,
        +
        16919  pAllocations);
        16920 
        -
        16921  return result;
        -
        16922 }
        -
        16923 
        -
        16924 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
        -
        16925  VmaAllocator allocator,
        -
        16926  VkImage image,
        -
        16927  const VmaAllocationCreateInfo* pCreateInfo,
        -
        16928  VmaAllocation* pAllocation,
        -
        16929  VmaAllocationInfo* pAllocationInfo)
        -
        16930 {
        -
        16931  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        -
        16932 
        -
        16933  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
        -
        16934 
        -
        16935  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16936 
        -
        16937  VkMemoryRequirements vkMemReq = {};
        -
        16938  bool requiresDedicatedAllocation = false;
        -
        16939  bool prefersDedicatedAllocation = false;
        -
        16940  allocator->GetImageMemoryRequirements(image, vkMemReq,
        -
        16941  requiresDedicatedAllocation, prefersDedicatedAllocation);
        -
        16942 
        -
        16943  VkResult result = allocator->AllocateMemory(
        -
        16944  vkMemReq,
        -
        16945  requiresDedicatedAllocation,
        -
        16946  prefersDedicatedAllocation,
        -
        16947  VK_NULL_HANDLE, // dedicatedBuffer
        -
        16948  image, // dedicatedImage
        -
        16949  *pCreateInfo,
        -
        16950  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
        -
        16951  1, // allocationCount
        -
        16952  pAllocation);
        -
        16953 
        -
        16954 #if VMA_RECORDING_ENABLED
        -
        16955  if(allocator->GetRecorder() != VMA_NULL)
        -
        16956  {
        -
        16957  allocator->GetRecorder()->RecordAllocateMemoryForImage(
        -
        16958  allocator->GetCurrentFrameIndex(),
        -
        16959  vkMemReq,
        -
        16960  requiresDedicatedAllocation,
        -
        16961  prefersDedicatedAllocation,
        -
        16962  *pCreateInfo,
        -
        16963  *pAllocation);
        -
        16964  }
        -
        16965 #endif
        -
        16966 
        -
        16967  if(pAllocationInfo && result == VK_SUCCESS)
        -
        16968  {
        -
        16969  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        -
        16970  }
        -
        16971 
        -
        16972  return result;
        -
        16973 }
        +
        16921 #if VMA_RECORDING_ENABLED
        +
        16922  if(allocator->GetRecorder() != VMA_NULL)
        +
        16923  {
        +
        16924  allocator->GetRecorder()->RecordAllocateMemoryPages(
        +
        16925  allocator->GetCurrentFrameIndex(),
        +
        16926  *pVkMemoryRequirements,
        +
        16927  *pCreateInfo,
        +
        16928  (uint64_t)allocationCount,
        +
        16929  pAllocations);
        +
        16930  }
        +
        16931 #endif
        +
        16932 
        +
        16933  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
        +
        16934  {
        +
        16935  for(size_t i = 0; i < allocationCount; ++i)
        +
        16936  {
        +
        16937  allocator->GetAllocationInfo(pAllocations[i], pAllocationInfo + i);
        +
        16938  }
        +
        16939  }
        +
        16940 
        +
        16941  return result;
        +
        16942 }
        +
        16943 
        +
        16944 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
        +
        16945  VmaAllocator allocator,
        +
        16946  VkBuffer buffer,
        +
        16947  const VmaAllocationCreateInfo* pCreateInfo,
        +
        16948  VmaAllocation* pAllocation,
        +
        16949  VmaAllocationInfo* pAllocationInfo)
        +
        16950 {
        +
        16951  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        +
        16952 
        +
        16953  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
        +
        16954 
        +
        16955  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16956 
        +
        16957  VkMemoryRequirements vkMemReq = {};
        +
        16958  bool requiresDedicatedAllocation = false;
        +
        16959  bool prefersDedicatedAllocation = false;
        +
        16960  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
        +
        16961  requiresDedicatedAllocation,
        +
        16962  prefersDedicatedAllocation);
        +
        16963 
        +
        16964  VkResult result = allocator->AllocateMemory(
        +
        16965  vkMemReq,
        +
        16966  requiresDedicatedAllocation,
        +
        16967  prefersDedicatedAllocation,
        +
        16968  buffer, // dedicatedBuffer
        +
        16969  VK_NULL_HANDLE, // dedicatedImage
        +
        16970  *pCreateInfo,
        +
        16971  VMA_SUBALLOCATION_TYPE_BUFFER,
        +
        16972  1, // allocationCount
        +
        16973  pAllocation);
        16974 
        -
        16975 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
        -
        16976  VmaAllocator allocator,
        -
        16977  VmaAllocation allocation)
        -
        16978 {
        -
        16979  VMA_ASSERT(allocator);
        -
        16980 
        -
        16981  if(allocation == VK_NULL_HANDLE)
        -
        16982  {
        -
        16983  return;
        -
        16984  }
        -
        16985 
        -
        16986  VMA_DEBUG_LOG("vmaFreeMemory");
        -
        16987 
        -
        16988  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        16989 
        -
        16990 #if VMA_RECORDING_ENABLED
        -
        16991  if(allocator->GetRecorder() != VMA_NULL)
        -
        16992  {
        -
        16993  allocator->GetRecorder()->RecordFreeMemory(
        -
        16994  allocator->GetCurrentFrameIndex(),
        -
        16995  allocation);
        -
        16996  }
        -
        16997 #endif
        -
        16998 
        -
        16999  allocator->FreeMemory(
        -
        17000  1, // allocationCount
        -
        17001  &allocation);
        -
        17002 }
        -
        17003 
        -
        17004 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
        -
        17005  VmaAllocator allocator,
        -
        17006  size_t allocationCount,
        -
        17007  VmaAllocation* pAllocations)
        -
        17008 {
        -
        17009  if(allocationCount == 0)
        -
        17010  {
        -
        17011  return;
        -
        17012  }
        -
        17013 
        -
        17014  VMA_ASSERT(allocator);
        -
        17015 
        -
        17016  VMA_DEBUG_LOG("vmaFreeMemoryPages");
        -
        17017 
        -
        17018  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17019 
        -
        17020 #if VMA_RECORDING_ENABLED
        -
        17021  if(allocator->GetRecorder() != VMA_NULL)
        -
        17022  {
        -
        17023  allocator->GetRecorder()->RecordFreeMemoryPages(
        -
        17024  allocator->GetCurrentFrameIndex(),
        -
        17025  (uint64_t)allocationCount,
        -
        17026  pAllocations);
        -
        17027  }
        -
        17028 #endif
        -
        17029 
        -
        17030  allocator->FreeMemory(allocationCount, pAllocations);
        -
        17031 }
        -
        17032 
        -
        17033 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
        -
        17034  VmaAllocator allocator,
        -
        17035  VmaAllocation allocation,
        -
        17036  VkDeviceSize newSize)
        -
        17037 {
        -
        17038  VMA_ASSERT(allocator && allocation);
        -
        17039 
        -
        17040  VMA_DEBUG_LOG("vmaResizeAllocation");
        -
        17041 
        -
        17042  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        16975 #if VMA_RECORDING_ENABLED
        +
        16976  if(allocator->GetRecorder() != VMA_NULL)
        +
        16977  {
        +
        16978  allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
        +
        16979  allocator->GetCurrentFrameIndex(),
        +
        16980  vkMemReq,
        +
        16981  requiresDedicatedAllocation,
        +
        16982  prefersDedicatedAllocation,
        +
        16983  *pCreateInfo,
        +
        16984  *pAllocation);
        +
        16985  }
        +
        16986 #endif
        +
        16987 
        +
        16988  if(pAllocationInfo && result == VK_SUCCESS)
        +
        16989  {
        +
        16990  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        +
        16991  }
        +
        16992 
        +
        16993  return result;
        +
        16994 }
        +
        16995 
        +
        16996 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
        +
        16997  VmaAllocator allocator,
        +
        16998  VkImage image,
        +
        16999  const VmaAllocationCreateInfo* pCreateInfo,
        +
        17000  VmaAllocation* pAllocation,
        +
        17001  VmaAllocationInfo* pAllocationInfo)
        +
        17002 {
        +
        17003  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        +
        17004 
        +
        17005  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
        +
        17006 
        +
        17007  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17008 
        +
        17009  VkMemoryRequirements vkMemReq = {};
        +
        17010  bool requiresDedicatedAllocation = false;
        +
        17011  bool prefersDedicatedAllocation = false;
        +
        17012  allocator->GetImageMemoryRequirements(image, vkMemReq,
        +
        17013  requiresDedicatedAllocation, prefersDedicatedAllocation);
        +
        17014 
        +
        17015  VkResult result = allocator->AllocateMemory(
        +
        17016  vkMemReq,
        +
        17017  requiresDedicatedAllocation,
        +
        17018  prefersDedicatedAllocation,
        +
        17019  VK_NULL_HANDLE, // dedicatedBuffer
        +
        17020  image, // dedicatedImage
        +
        17021  *pCreateInfo,
        +
        17022  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
        +
        17023  1, // allocationCount
        +
        17024  pAllocation);
        +
        17025 
        +
        17026 #if VMA_RECORDING_ENABLED
        +
        17027  if(allocator->GetRecorder() != VMA_NULL)
        +
        17028  {
        +
        17029  allocator->GetRecorder()->RecordAllocateMemoryForImage(
        +
        17030  allocator->GetCurrentFrameIndex(),
        +
        17031  vkMemReq,
        +
        17032  requiresDedicatedAllocation,
        +
        17033  prefersDedicatedAllocation,
        +
        17034  *pCreateInfo,
        +
        17035  *pAllocation);
        +
        17036  }
        +
        17037 #endif
        +
        17038 
        +
        17039  if(pAllocationInfo && result == VK_SUCCESS)
        +
        17040  {
        +
        17041  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        +
        17042  }
        17043 
        -
        17044  return allocator->ResizeAllocation(allocation, newSize);
        +
        17044  return result;
        17045 }
        17046 
        -
        17047 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
        +
        17047 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
        17048  VmaAllocator allocator,
        -
        17049  VmaAllocation allocation,
        -
        17050  VmaAllocationInfo* pAllocationInfo)
        -
        17051 {
        -
        17052  VMA_ASSERT(allocator && allocation && pAllocationInfo);
        -
        17053 
        -
        17054  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17055 
        -
        17056 #if VMA_RECORDING_ENABLED
        -
        17057  if(allocator->GetRecorder() != VMA_NULL)
        -
        17058  {
        -
        17059  allocator->GetRecorder()->RecordGetAllocationInfo(
        -
        17060  allocator->GetCurrentFrameIndex(),
        -
        17061  allocation);
        -
        17062  }
        -
        17063 #endif
        -
        17064 
        -
        17065  allocator->GetAllocationInfo(allocation, pAllocationInfo);
        -
        17066 }
        -
        17067 
        -
        17068 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
        -
        17069  VmaAllocator allocator,
        -
        17070  VmaAllocation allocation)
        -
        17071 {
        -
        17072  VMA_ASSERT(allocator && allocation);
        -
        17073 
        -
        17074  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17049  VmaAllocation allocation)
        +
        17050 {
        +
        17051  VMA_ASSERT(allocator);
        +
        17052 
        +
        17053  if(allocation == VK_NULL_HANDLE)
        +
        17054  {
        +
        17055  return;
        +
        17056  }
        +
        17057 
        +
        17058  VMA_DEBUG_LOG("vmaFreeMemory");
        +
        17059 
        +
        17060  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17061 
        +
        17062 #if VMA_RECORDING_ENABLED
        +
        17063  if(allocator->GetRecorder() != VMA_NULL)
        +
        17064  {
        +
        17065  allocator->GetRecorder()->RecordFreeMemory(
        +
        17066  allocator->GetCurrentFrameIndex(),
        +
        17067  allocation);
        +
        17068  }
        +
        17069 #endif
        +
        17070 
        +
        17071  allocator->FreeMemory(
        +
        17072  1, // allocationCount
        +
        17073  &allocation);
        +
        17074 }
        17075 
        -
        17076 #if VMA_RECORDING_ENABLED
        -
        17077  if(allocator->GetRecorder() != VMA_NULL)
        -
        17078  {
        -
        17079  allocator->GetRecorder()->RecordTouchAllocation(
        -
        17080  allocator->GetCurrentFrameIndex(),
        -
        17081  allocation);
        -
        17082  }
        -
        17083 #endif
        -
        17084 
        -
        17085  return allocator->TouchAllocation(allocation);
        -
        17086 }
        -
        17087 
        -
        17088 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
        -
        17089  VmaAllocator allocator,
        -
        17090  VmaAllocation allocation,
        -
        17091  void* pUserData)
        -
        17092 {
        -
        17093  VMA_ASSERT(allocator && allocation);
        -
        17094 
        -
        17095  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17096 
        -
        17097  allocation->SetUserData(allocator, pUserData);
        -
        17098 
        -
        17099 #if VMA_RECORDING_ENABLED
        -
        17100  if(allocator->GetRecorder() != VMA_NULL)
        -
        17101  {
        -
        17102  allocator->GetRecorder()->RecordSetAllocationUserData(
        -
        17103  allocator->GetCurrentFrameIndex(),
        -
        17104  allocation,
        -
        17105  pUserData);
        -
        17106  }
        -
        17107 #endif
        -
        17108 }
        -
        17109 
        -
        17110 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
        -
        17111  VmaAllocator allocator,
        -
        17112  VmaAllocation* pAllocation)
        -
        17113 {
        -
        17114  VMA_ASSERT(allocator && pAllocation);
        +
        17076 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
        +
        17077  VmaAllocator allocator,
        +
        17078  size_t allocationCount,
        +
        17079  VmaAllocation* pAllocations)
        +
        17080 {
        +
        17081  if(allocationCount == 0)
        +
        17082  {
        +
        17083  return;
        +
        17084  }
        +
        17085 
        +
        17086  VMA_ASSERT(allocator);
        +
        17087 
        +
        17088  VMA_DEBUG_LOG("vmaFreeMemoryPages");
        +
        17089 
        +
        17090  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17091 
        +
        17092 #if VMA_RECORDING_ENABLED
        +
        17093  if(allocator->GetRecorder() != VMA_NULL)
        +
        17094  {
        +
        17095  allocator->GetRecorder()->RecordFreeMemoryPages(
        +
        17096  allocator->GetCurrentFrameIndex(),
        +
        17097  (uint64_t)allocationCount,
        +
        17098  pAllocations);
        +
        17099  }
        +
        17100 #endif
        +
        17101 
        +
        17102  allocator->FreeMemory(allocationCount, pAllocations);
        +
        17103 }
        +
        17104 
        +
        17105 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
        +
        17106  VmaAllocator allocator,
        +
        17107  VmaAllocation allocation,
        +
        17108  VkDeviceSize newSize)
        +
        17109 {
        +
        17110  VMA_ASSERT(allocator && allocation);
        +
        17111 
        +
        17112  VMA_DEBUG_LOG("vmaResizeAllocation");
        +
        17113 
        +
        17114  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        17115 
        -
        17116  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        -
        17117 
        -
        17118  allocator->CreateLostAllocation(pAllocation);
        -
        17119 
        -
        17120 #if VMA_RECORDING_ENABLED
        -
        17121  if(allocator->GetRecorder() != VMA_NULL)
        -
        17122  {
        -
        17123  allocator->GetRecorder()->RecordCreateLostAllocation(
        -
        17124  allocator->GetCurrentFrameIndex(),
        -
        17125  *pAllocation);
        -
        17126  }
        -
        17127 #endif
        -
        17128 }
        -
        17129 
        -
        17130 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
        -
        17131  VmaAllocator allocator,
        -
        17132  VmaAllocation allocation,
        -
        17133  void** ppData)
        -
        17134 {
        -
        17135  VMA_ASSERT(allocator && allocation && ppData);
        +
        17116  return allocator->ResizeAllocation(allocation, newSize);
        +
        17117 }
        +
        17118 
        +
        17119 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
        +
        17120  VmaAllocator allocator,
        +
        17121  VmaAllocation allocation,
        +
        17122  VmaAllocationInfo* pAllocationInfo)
        +
        17123 {
        +
        17124  VMA_ASSERT(allocator && allocation && pAllocationInfo);
        +
        17125 
        +
        17126  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17127 
        +
        17128 #if VMA_RECORDING_ENABLED
        +
        17129  if(allocator->GetRecorder() != VMA_NULL)
        +
        17130  {
        +
        17131  allocator->GetRecorder()->RecordGetAllocationInfo(
        +
        17132  allocator->GetCurrentFrameIndex(),
        +
        17133  allocation);
        +
        17134  }
        +
        17135 #endif
        17136 
        -
        17137  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17138 
        -
        17139  VkResult res = allocator->Map(allocation, ppData);
        -
        17140 
        -
        17141 #if VMA_RECORDING_ENABLED
        -
        17142  if(allocator->GetRecorder() != VMA_NULL)
        -
        17143  {
        -
        17144  allocator->GetRecorder()->RecordMapMemory(
        -
        17145  allocator->GetCurrentFrameIndex(),
        -
        17146  allocation);
        -
        17147  }
        -
        17148 #endif
        -
        17149 
        -
        17150  return res;
        -
        17151 }
        -
        17152 
        -
        17153 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
        -
        17154  VmaAllocator allocator,
        -
        17155  VmaAllocation allocation)
        -
        17156 {
        -
        17157  VMA_ASSERT(allocator && allocation);
        -
        17158 
        -
        17159  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17160 
        -
        17161 #if VMA_RECORDING_ENABLED
        -
        17162  if(allocator->GetRecorder() != VMA_NULL)
        -
        17163  {
        -
        17164  allocator->GetRecorder()->RecordUnmapMemory(
        -
        17165  allocator->GetCurrentFrameIndex(),
        -
        17166  allocation);
        -
        17167  }
        -
        17168 #endif
        -
        17169 
        -
        17170  allocator->Unmap(allocation);
        -
        17171 }
        -
        17172 
        -
        17173 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        -
        17174 {
        -
        17175  VMA_ASSERT(allocator && allocation);
        -
        17176 
        -
        17177  VMA_DEBUG_LOG("vmaFlushAllocation");
        -
        17178 
        -
        17179  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17180 
        -
        17181  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
        -
        17182 
        -
        17183 #if VMA_RECORDING_ENABLED
        -
        17184  if(allocator->GetRecorder() != VMA_NULL)
        -
        17185  {
        -
        17186  allocator->GetRecorder()->RecordFlushAllocation(
        -
        17187  allocator->GetCurrentFrameIndex(),
        -
        17188  allocation, offset, size);
        -
        17189  }
        -
        17190 #endif
        -
        17191 }
        -
        17192 
        -
        17193 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        -
        17194 {
        -
        17195  VMA_ASSERT(allocator && allocation);
        -
        17196 
        -
        17197  VMA_DEBUG_LOG("vmaInvalidateAllocation");
        -
        17198 
        -
        17199  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17200 
        -
        17201  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
        -
        17202 
        -
        17203 #if VMA_RECORDING_ENABLED
        -
        17204  if(allocator->GetRecorder() != VMA_NULL)
        -
        17205  {
        -
        17206  allocator->GetRecorder()->RecordInvalidateAllocation(
        -
        17207  allocator->GetCurrentFrameIndex(),
        -
        17208  allocation, offset, size);
        -
        17209  }
        -
        17210 #endif
        -
        17211 }
        +
        17137  allocator->GetAllocationInfo(allocation, pAllocationInfo);
        +
        17138 }
        +
        17139 
        +
        17140 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
        +
        17141  VmaAllocator allocator,
        +
        17142  VmaAllocation allocation)
        +
        17143 {
        +
        17144  VMA_ASSERT(allocator && allocation);
        +
        17145 
        +
        17146  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17147 
        +
        17148 #if VMA_RECORDING_ENABLED
        +
        17149  if(allocator->GetRecorder() != VMA_NULL)
        +
        17150  {
        +
        17151  allocator->GetRecorder()->RecordTouchAllocation(
        +
        17152  allocator->GetCurrentFrameIndex(),
        +
        17153  allocation);
        +
        17154  }
        +
        17155 #endif
        +
        17156 
        +
        17157  return allocator->TouchAllocation(allocation);
        +
        17158 }
        +
        17159 
        +
        17160 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
        +
        17161  VmaAllocator allocator,
        +
        17162  VmaAllocation allocation,
        +
        17163  void* pUserData)
        +
        17164 {
        +
        17165  VMA_ASSERT(allocator && allocation);
        +
        17166 
        +
        17167  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17168 
        +
        17169  allocation->SetUserData(allocator, pUserData);
        +
        17170 
        +
        17171 #if VMA_RECORDING_ENABLED
        +
        17172  if(allocator->GetRecorder() != VMA_NULL)
        +
        17173  {
        +
        17174  allocator->GetRecorder()->RecordSetAllocationUserData(
        +
        17175  allocator->GetCurrentFrameIndex(),
        +
        17176  allocation,
        +
        17177  pUserData);
        +
        17178  }
        +
        17179 #endif
        +
        17180 }
        +
        17181 
        +
        17182 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
        +
        17183  VmaAllocator allocator,
        +
        17184  VmaAllocation* pAllocation)
        +
        17185 {
        +
        17186  VMA_ASSERT(allocator && pAllocation);
        +
        17187 
        +
        17188  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        +
        17189 
        +
        17190  allocator->CreateLostAllocation(pAllocation);
        +
        17191 
        +
        17192 #if VMA_RECORDING_ENABLED
        +
        17193  if(allocator->GetRecorder() != VMA_NULL)
        +
        17194  {
        +
        17195  allocator->GetRecorder()->RecordCreateLostAllocation(
        +
        17196  allocator->GetCurrentFrameIndex(),
        +
        17197  *pAllocation);
        +
        17198  }
        +
        17199 #endif
        +
        17200 }
        +
        17201 
        +
        17202 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
        +
        17203  VmaAllocator allocator,
        +
        17204  VmaAllocation allocation,
        +
        17205  void** ppData)
        +
        17206 {
        +
        17207  VMA_ASSERT(allocator && allocation && ppData);
        +
        17208 
        +
        17209  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17210 
        +
        17211  VkResult res = allocator->Map(allocation, ppData);
        17212 
        -
        17213 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
        -
        17214 {
        -
        17215  VMA_ASSERT(allocator);
        -
        17216 
        -
        17217  VMA_DEBUG_LOG("vmaCheckCorruption");
        -
        17218 
        -
        17219  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17220 
        -
        17221  return allocator->CheckCorruption(memoryTypeBits);
        -
        17222 }
        -
        17223 
        -
        17224 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
        -
        17225  VmaAllocator allocator,
        -
        17226  VmaAllocation* pAllocations,
        -
        17227  size_t allocationCount,
        -
        17228  VkBool32* pAllocationsChanged,
        -
        17229  const VmaDefragmentationInfo *pDefragmentationInfo,
        -
        17230  VmaDefragmentationStats* pDefragmentationStats)
        -
        17231 {
        -
        17232  // Deprecated interface, reimplemented using new one.
        -
        17233 
        -
        17234  VmaDefragmentationInfo2 info2 = {};
        -
        17235  info2.allocationCount = (uint32_t)allocationCount;
        -
        17236  info2.pAllocations = pAllocations;
        -
        17237  info2.pAllocationsChanged = pAllocationsChanged;
        -
        17238  if(pDefragmentationInfo != VMA_NULL)
        -
        17239  {
        -
        17240  info2.maxCpuAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
        -
        17241  info2.maxCpuBytesToMove = pDefragmentationInfo->maxBytesToMove;
        -
        17242  }
        -
        17243  else
        -
        17244  {
        -
        17245  info2.maxCpuAllocationsToMove = UINT32_MAX;
        -
        17246  info2.maxCpuBytesToMove = VK_WHOLE_SIZE;
        -
        17247  }
        -
        17248  // info2.flags, maxGpuAllocationsToMove, maxGpuBytesToMove, commandBuffer deliberately left zero.
        -
        17249 
        -
        17250  VmaDefragmentationContext ctx;
        -
        17251  VkResult res = vmaDefragmentationBegin(allocator, &info2, pDefragmentationStats, &ctx);
        -
        17252  if(res == VK_NOT_READY)
        -
        17253  {
        -
        17254  res = vmaDefragmentationEnd( allocator, ctx);
        -
        17255  }
        -
        17256  return res;
        -
        17257 }
        -
        17258 
        -
        17259 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
        -
        17260  VmaAllocator allocator,
        -
        17261  const VmaDefragmentationInfo2* pInfo,
        -
        17262  VmaDefragmentationStats* pStats,
        -
        17263  VmaDefragmentationContext *pContext)
        -
        17264 {
        -
        17265  VMA_ASSERT(allocator && pInfo && pContext);
        -
        17266 
        -
        17267  // Degenerate case: Nothing to defragment.
        -
        17268  if(pInfo->allocationCount == 0 && pInfo->poolCount == 0)
        -
        17269  {
        -
        17270  return VK_SUCCESS;
        -
        17271  }
        +
        17213 #if VMA_RECORDING_ENABLED
        +
        17214  if(allocator->GetRecorder() != VMA_NULL)
        +
        17215  {
        +
        17216  allocator->GetRecorder()->RecordMapMemory(
        +
        17217  allocator->GetCurrentFrameIndex(),
        +
        17218  allocation);
        +
        17219  }
        +
        17220 #endif
        +
        17221 
        +
        17222  return res;
        +
        17223 }
        +
        17224 
        +
        17225 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
        +
        17226  VmaAllocator allocator,
        +
        17227  VmaAllocation allocation)
        +
        17228 {
        +
        17229  VMA_ASSERT(allocator && allocation);
        +
        17230 
        +
        17231  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17232 
        +
        17233 #if VMA_RECORDING_ENABLED
        +
        17234  if(allocator->GetRecorder() != VMA_NULL)
        +
        17235  {
        +
        17236  allocator->GetRecorder()->RecordUnmapMemory(
        +
        17237  allocator->GetCurrentFrameIndex(),
        +
        17238  allocation);
        +
        17239  }
        +
        17240 #endif
        +
        17241 
        +
        17242  allocator->Unmap(allocation);
        +
        17243 }
        +
        17244 
        +
        17245 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        +
        17246 {
        +
        17247  VMA_ASSERT(allocator && allocation);
        +
        17248 
        +
        17249  VMA_DEBUG_LOG("vmaFlushAllocation");
        +
        17250 
        +
        17251  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17252 
        +
        17253  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
        +
        17254 
        +
        17255 #if VMA_RECORDING_ENABLED
        +
        17256  if(allocator->GetRecorder() != VMA_NULL)
        +
        17257  {
        +
        17258  allocator->GetRecorder()->RecordFlushAllocation(
        +
        17259  allocator->GetCurrentFrameIndex(),
        +
        17260  allocation, offset, size);
        +
        17261  }
        +
        17262 #endif
        +
        17263 }
        +
        17264 
        +
        17265 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        +
        17266 {
        +
        17267  VMA_ASSERT(allocator && allocation);
        +
        17268 
        +
        17269  VMA_DEBUG_LOG("vmaInvalidateAllocation");
        +
        17270 
        +
        17271  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        17272 
        -
        17273  VMA_ASSERT(pInfo->allocationCount == 0 || pInfo->pAllocations != VMA_NULL);
        -
        17274  VMA_ASSERT(pInfo->poolCount == 0 || pInfo->pPools != VMA_NULL);
        -
        17275  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->allocationCount, pInfo->pAllocations));
        -
        17276  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->poolCount, pInfo->pPools));
        -
        17277 
        -
        17278  VMA_DEBUG_LOG("vmaDefragmentationBegin");
        -
        17279 
        -
        17280  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17281 
        -
        17282  VkResult res = allocator->DefragmentationBegin(*pInfo, pStats, pContext);
        -
        17283 
        -
        17284 #if VMA_RECORDING_ENABLED
        -
        17285  if(allocator->GetRecorder() != VMA_NULL)
        -
        17286  {
        -
        17287  allocator->GetRecorder()->RecordDefragmentationBegin(
        -
        17288  allocator->GetCurrentFrameIndex(), *pInfo, *pContext);
        -
        17289  }
        -
        17290 #endif
        -
        17291 
        -
        17292  return res;
        -
        17293 }
        -
        17294 
        -
        17295 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
        -
        17296  VmaAllocator allocator,
        -
        17297  VmaDefragmentationContext context)
        -
        17298 {
        -
        17299  VMA_ASSERT(allocator);
        -
        17300 
        -
        17301  VMA_DEBUG_LOG("vmaDefragmentationEnd");
        -
        17302 
        -
        17303  if(context != VK_NULL_HANDLE)
        -
        17304  {
        -
        17305  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17306 
        -
        17307 #if VMA_RECORDING_ENABLED
        -
        17308  if(allocator->GetRecorder() != VMA_NULL)
        -
        17309  {
        -
        17310  allocator->GetRecorder()->RecordDefragmentationEnd(
        -
        17311  allocator->GetCurrentFrameIndex(), context);
        -
        17312  }
        -
        17313 #endif
        -
        17314 
        -
        17315  return allocator->DefragmentationEnd(context);
        -
        17316  }
        -
        17317  else
        -
        17318  {
        -
        17319  return VK_SUCCESS;
        -
        17320  }
        -
        17321 }
        -
        17322 
        -
        17323 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
        -
        17324  VmaAllocator allocator,
        -
        17325  VmaAllocation allocation,
        -
        17326  VkBuffer buffer)
        -
        17327 {
        -
        17328  VMA_ASSERT(allocator && allocation && buffer);
        -
        17329 
        -
        17330  VMA_DEBUG_LOG("vmaBindBufferMemory");
        -
        17331 
        -
        17332  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17333 
        -
        17334  return allocator->BindBufferMemory(allocation, 0, buffer, VMA_NULL);
        -
        17335 }
        -
        17336 
        -
        17337 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
        -
        17338  VmaAllocator allocator,
        -
        17339  VmaAllocation allocation,
        -
        17340  VkDeviceSize allocationLocalOffset,
        -
        17341  VkBuffer buffer,
        -
        17342  const void* pNext)
        -
        17343 {
        -
        17344  VMA_ASSERT(allocator && allocation && buffer);
        -
        17345 
        -
        17346  VMA_DEBUG_LOG("vmaBindBufferMemory2");
        -
        17347 
        -
        17348  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17273  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
        +
        17274 
        +
        17275 #if VMA_RECORDING_ENABLED
        +
        17276  if(allocator->GetRecorder() != VMA_NULL)
        +
        17277  {
        +
        17278  allocator->GetRecorder()->RecordInvalidateAllocation(
        +
        17279  allocator->GetCurrentFrameIndex(),
        +
        17280  allocation, offset, size);
        +
        17281  }
        +
        17282 #endif
        +
        17283 }
        +
        17284 
        +
        17285 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
        +
        17286 {
        +
        17287  VMA_ASSERT(allocator);
        +
        17288 
        +
        17289  VMA_DEBUG_LOG("vmaCheckCorruption");
        +
        17290 
        +
        17291  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17292 
        +
        17293  return allocator->CheckCorruption(memoryTypeBits);
        +
        17294 }
        +
        17295 
        +
        17296 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
        +
        17297  VmaAllocator allocator,
        +
        17298  VmaAllocation* pAllocations,
        +
        17299  size_t allocationCount,
        +
        17300  VkBool32* pAllocationsChanged,
        +
        17301  const VmaDefragmentationInfo *pDefragmentationInfo,
        +
        17302  VmaDefragmentationStats* pDefragmentationStats)
        +
        17303 {
        +
        17304  // Deprecated interface, reimplemented using new one.
        +
        17305 
        +
        17306  VmaDefragmentationInfo2 info2 = {};
        +
        17307  info2.allocationCount = (uint32_t)allocationCount;
        +
        17308  info2.pAllocations = pAllocations;
        +
        17309  info2.pAllocationsChanged = pAllocationsChanged;
        +
        17310  if(pDefragmentationInfo != VMA_NULL)
        +
        17311  {
        +
        17312  info2.maxCpuAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
        +
        17313  info2.maxCpuBytesToMove = pDefragmentationInfo->maxBytesToMove;
        +
        17314  }
        +
        17315  else
        +
        17316  {
        +
        17317  info2.maxCpuAllocationsToMove = UINT32_MAX;
        +
        17318  info2.maxCpuBytesToMove = VK_WHOLE_SIZE;
        +
        17319  }
        +
        17320  // info2.flags, maxGpuAllocationsToMove, maxGpuBytesToMove, commandBuffer deliberately left zero.
        +
        17321 
        +
        17322  VmaDefragmentationContext ctx;
        +
        17323  VkResult res = vmaDefragmentationBegin(allocator, &info2, pDefragmentationStats, &ctx);
        +
        17324  if(res == VK_NOT_READY)
        +
        17325  {
        +
        17326  res = vmaDefragmentationEnd( allocator, ctx);
        +
        17327  }
        +
        17328  return res;
        +
        17329 }
        +
        17330 
        +
        17331 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
        +
        17332  VmaAllocator allocator,
        +
        17333  const VmaDefragmentationInfo2* pInfo,
        +
        17334  VmaDefragmentationStats* pStats,
        +
        17335  VmaDefragmentationContext *pContext)
        +
        17336 {
        +
        17337  VMA_ASSERT(allocator && pInfo && pContext);
        +
        17338 
        +
        17339  // Degenerate case: Nothing to defragment.
        +
        17340  if(pInfo->allocationCount == 0 && pInfo->poolCount == 0)
        +
        17341  {
        +
        17342  return VK_SUCCESS;
        +
        17343  }
        +
        17344 
        +
        17345  VMA_ASSERT(pInfo->allocationCount == 0 || pInfo->pAllocations != VMA_NULL);
        +
        17346  VMA_ASSERT(pInfo->poolCount == 0 || pInfo->pPools != VMA_NULL);
        +
        17347  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->allocationCount, pInfo->pAllocations));
        +
        17348  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->poolCount, pInfo->pPools));
        17349 
        -
        17350  return allocator->BindBufferMemory(allocation, allocationLocalOffset, buffer, pNext);
        -
        17351 }
        -
        17352 
        -
        17353 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
        -
        17354  VmaAllocator allocator,
        -
        17355  VmaAllocation allocation,
        -
        17356  VkImage image)
        -
        17357 {
        -
        17358  VMA_ASSERT(allocator && allocation && image);
        -
        17359 
        -
        17360  VMA_DEBUG_LOG("vmaBindImageMemory");
        -
        17361 
        -
        17362  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17350  VMA_DEBUG_LOG("vmaDefragmentationBegin");
        +
        17351 
        +
        17352  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17353 
        +
        17354  VkResult res = allocator->DefragmentationBegin(*pInfo, pStats, pContext);
        +
        17355 
        +
        17356 #if VMA_RECORDING_ENABLED
        +
        17357  if(allocator->GetRecorder() != VMA_NULL)
        +
        17358  {
        +
        17359  allocator->GetRecorder()->RecordDefragmentationBegin(
        +
        17360  allocator->GetCurrentFrameIndex(), *pInfo, *pContext);
        +
        17361  }
        +
        17362 #endif
        17363 
        -
        17364  return allocator->BindImageMemory(allocation, 0, image, VMA_NULL);
        +
        17364  return res;
        17365 }
        17366 
        -
        17367 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
        +
        17367 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
        17368  VmaAllocator allocator,
        -
        17369  VmaAllocation allocation,
        -
        17370  VkDeviceSize allocationLocalOffset,
        -
        17371  VkImage image,
        -
        17372  const void* pNext)
        -
        17373 {
        -
        17374  VMA_ASSERT(allocator && allocation && image);
        -
        17375 
        -
        17376  VMA_DEBUG_LOG("vmaBindImageMemory2");
        -
        17377 
        -
        17378  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17379 
        -
        17380  return allocator->BindImageMemory(allocation, allocationLocalOffset, image, pNext);
        -
        17381 }
        -
        17382 
        -
        17383 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
        -
        17384  VmaAllocator allocator,
        -
        17385  const VkBufferCreateInfo* pBufferCreateInfo,
        -
        17386  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        17387  VkBuffer* pBuffer,
        -
        17388  VmaAllocation* pAllocation,
        -
        17389  VmaAllocationInfo* pAllocationInfo)
        -
        17390 {
        -
        17391  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
        -
        17392 
        -
        17393  if(pBufferCreateInfo->size == 0)
        -
        17394  {
        -
        17395  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        17396  }
        -
        17397 
        -
        17398  VMA_DEBUG_LOG("vmaCreateBuffer");
        -
        17399 
        -
        17400  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17369  VmaDefragmentationContext context)
        +
        17370 {
        +
        17371  VMA_ASSERT(allocator);
        +
        17372 
        +
        17373  VMA_DEBUG_LOG("vmaDefragmentationEnd");
        +
        17374 
        +
        17375  if(context != VK_NULL_HANDLE)
        +
        17376  {
        +
        17377  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17378 
        +
        17379 #if VMA_RECORDING_ENABLED
        +
        17380  if(allocator->GetRecorder() != VMA_NULL)
        +
        17381  {
        +
        17382  allocator->GetRecorder()->RecordDefragmentationEnd(
        +
        17383  allocator->GetCurrentFrameIndex(), context);
        +
        17384  }
        +
        17385 #endif
        +
        17386 
        +
        17387  return allocator->DefragmentationEnd(context);
        +
        17388  }
        +
        17389  else
        +
        17390  {
        +
        17391  return VK_SUCCESS;
        +
        17392  }
        +
        17393 }
        +
        17394 
        +
        17395 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
        +
        17396  VmaAllocator allocator,
        +
        17397  VmaAllocation allocation,
        +
        17398  VkBuffer buffer)
        +
        17399 {
        +
        17400  VMA_ASSERT(allocator && allocation && buffer);
        17401 
        -
        17402  *pBuffer = VK_NULL_HANDLE;
        -
        17403  *pAllocation = VK_NULL_HANDLE;
        -
        17404 
        -
        17405  // 1. Create VkBuffer.
        -
        17406  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
        -
        17407  allocator->m_hDevice,
        -
        17408  pBufferCreateInfo,
        -
        17409  allocator->GetAllocationCallbacks(),
        -
        17410  pBuffer);
        -
        17411  if(res >= 0)
        -
        17412  {
        -
        17413  // 2. vkGetBufferMemoryRequirements.
        -
        17414  VkMemoryRequirements vkMemReq = {};
        -
        17415  bool requiresDedicatedAllocation = false;
        -
        17416  bool prefersDedicatedAllocation = false;
        -
        17417  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
        -
        17418  requiresDedicatedAllocation, prefersDedicatedAllocation);
        +
        17402  VMA_DEBUG_LOG("vmaBindBufferMemory");
        +
        17403 
        +
        17404  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17405 
        +
        17406  return allocator->BindBufferMemory(allocation, 0, buffer, VMA_NULL);
        +
        17407 }
        +
        17408 
        +
        17409 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
        +
        17410  VmaAllocator allocator,
        +
        17411  VmaAllocation allocation,
        +
        17412  VkDeviceSize allocationLocalOffset,
        +
        17413  VkBuffer buffer,
        +
        17414  const void* pNext)
        +
        17415 {
        +
        17416  VMA_ASSERT(allocator && allocation && buffer);
        +
        17417 
        +
        17418  VMA_DEBUG_LOG("vmaBindBufferMemory2");
        17419 
        -
        17420  // Make sure alignment requirements for specific buffer usages reported
        -
        17421  // in Physical Device Properties are included in alignment reported by memory requirements.
        -
        17422  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
        -
        17423  {
        -
        17424  VMA_ASSERT(vkMemReq.alignment %
        -
        17425  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
        -
        17426  }
        -
        17427  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
        -
        17428  {
        -
        17429  VMA_ASSERT(vkMemReq.alignment %
        -
        17430  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
        -
        17431  }
        -
        17432  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
        -
        17433  {
        -
        17434  VMA_ASSERT(vkMemReq.alignment %
        -
        17435  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
        -
        17436  }
        -
        17437 
        -
        17438  // 3. Allocate memory using allocator.
        -
        17439  res = allocator->AllocateMemory(
        -
        17440  vkMemReq,
        -
        17441  requiresDedicatedAllocation,
        -
        17442  prefersDedicatedAllocation,
        -
        17443  *pBuffer, // dedicatedBuffer
        -
        17444  VK_NULL_HANDLE, // dedicatedImage
        -
        17445  *pAllocationCreateInfo,
        -
        17446  VMA_SUBALLOCATION_TYPE_BUFFER,
        -
        17447  1, // allocationCount
        -
        17448  pAllocation);
        +
        17420  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17421 
        +
        17422  return allocator->BindBufferMemory(allocation, allocationLocalOffset, buffer, pNext);
        +
        17423 }
        +
        17424 
        +
        17425 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
        +
        17426  VmaAllocator allocator,
        +
        17427  VmaAllocation allocation,
        +
        17428  VkImage image)
        +
        17429 {
        +
        17430  VMA_ASSERT(allocator && allocation && image);
        +
        17431 
        +
        17432  VMA_DEBUG_LOG("vmaBindImageMemory");
        +
        17433 
        +
        17434  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17435 
        +
        17436  return allocator->BindImageMemory(allocation, 0, image, VMA_NULL);
        +
        17437 }
        +
        17438 
        +
        17439 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
        +
        17440  VmaAllocator allocator,
        +
        17441  VmaAllocation allocation,
        +
        17442  VkDeviceSize allocationLocalOffset,
        +
        17443  VkImage image,
        +
        17444  const void* pNext)
        +
        17445 {
        +
        17446  VMA_ASSERT(allocator && allocation && image);
        +
        17447 
        +
        17448  VMA_DEBUG_LOG("vmaBindImageMemory2");
        17449 
        -
        17450 #if VMA_RECORDING_ENABLED
        -
        17451  if(allocator->GetRecorder() != VMA_NULL)
        -
        17452  {
        -
        17453  allocator->GetRecorder()->RecordCreateBuffer(
        -
        17454  allocator->GetCurrentFrameIndex(),
        -
        17455  *pBufferCreateInfo,
        -
        17456  *pAllocationCreateInfo,
        -
        17457  *pAllocation);
        -
        17458  }
        -
        17459 #endif
        -
        17460 
        -
        17461  if(res >= 0)
        -
        17462  {
        -
        17463  // 3. Bind buffer with memory.
        -
        17464  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
        -
        17465  {
        -
        17466  res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
        -
        17467  }
        -
        17468  if(res >= 0)
        -
        17469  {
        -
        17470  // All steps succeeded.
        -
        17471  #if VMA_STATS_STRING_ENABLED
        -
        17472  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
        -
        17473  #endif
        -
        17474  if(pAllocationInfo != VMA_NULL)
        -
        17475  {
        -
        17476  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        -
        17477  }
        -
        17478 
        -
        17479  return VK_SUCCESS;
        -
        17480  }
        -
        17481  allocator->FreeMemory(
        -
        17482  1, // allocationCount
        -
        17483  pAllocation);
        -
        17484  *pAllocation = VK_NULL_HANDLE;
        -
        17485  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        -
        17486  *pBuffer = VK_NULL_HANDLE;
        -
        17487  return res;
        -
        17488  }
        -
        17489  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        -
        17490  *pBuffer = VK_NULL_HANDLE;
        -
        17491  return res;
        -
        17492  }
        -
        17493  return res;
        -
        17494 }
        -
        17495 
        -
        17496 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
        -
        17497  VmaAllocator allocator,
        -
        17498  VkBuffer buffer,
        -
        17499  VmaAllocation allocation)
        -
        17500 {
        -
        17501  VMA_ASSERT(allocator);
        -
        17502 
        -
        17503  if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        -
        17504  {
        -
        17505  return;
        -
        17506  }
        -
        17507 
        -
        17508  VMA_DEBUG_LOG("vmaDestroyBuffer");
        +
        17450  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17451 
        +
        17452  return allocator->BindImageMemory(allocation, allocationLocalOffset, image, pNext);
        +
        17453 }
        +
        17454 
        +
        17455 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
        +
        17456  VmaAllocator allocator,
        +
        17457  const VkBufferCreateInfo* pBufferCreateInfo,
        +
        17458  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        17459  VkBuffer* pBuffer,
        +
        17460  VmaAllocation* pAllocation,
        +
        17461  VmaAllocationInfo* pAllocationInfo)
        +
        17462 {
        +
        17463  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
        +
        17464 
        +
        17465  if(pBufferCreateInfo->size == 0)
        +
        17466  {
        +
        17467  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        17468  }
        +
        17469 
        +
        17470  VMA_DEBUG_LOG("vmaCreateBuffer");
        +
        17471 
        +
        17472  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17473 
        +
        17474  *pBuffer = VK_NULL_HANDLE;
        +
        17475  *pAllocation = VK_NULL_HANDLE;
        +
        17476 
        +
        17477  // 1. Create VkBuffer.
        +
        17478  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
        +
        17479  allocator->m_hDevice,
        +
        17480  pBufferCreateInfo,
        +
        17481  allocator->GetAllocationCallbacks(),
        +
        17482  pBuffer);
        +
        17483  if(res >= 0)
        +
        17484  {
        +
        17485  // 2. vkGetBufferMemoryRequirements.
        +
        17486  VkMemoryRequirements vkMemReq = {};
        +
        17487  bool requiresDedicatedAllocation = false;
        +
        17488  bool prefersDedicatedAllocation = false;
        +
        17489  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
        +
        17490  requiresDedicatedAllocation, prefersDedicatedAllocation);
        +
        17491 
        +
        17492  // Make sure alignment requirements for specific buffer usages reported
        +
        17493  // in Physical Device Properties are included in alignment reported by memory requirements.
        +
        17494  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
        +
        17495  {
        +
        17496  VMA_ASSERT(vkMemReq.alignment %
        +
        17497  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
        +
        17498  }
        +
        17499  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
        +
        17500  {
        +
        17501  VMA_ASSERT(vkMemReq.alignment %
        +
        17502  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
        +
        17503  }
        +
        17504  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
        +
        17505  {
        +
        17506  VMA_ASSERT(vkMemReq.alignment %
        +
        17507  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
        +
        17508  }
        17509 
        -
        17510  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17511 
        -
        17512 #if VMA_RECORDING_ENABLED
        -
        17513  if(allocator->GetRecorder() != VMA_NULL)
        -
        17514  {
        -
        17515  allocator->GetRecorder()->RecordDestroyBuffer(
        -
        17516  allocator->GetCurrentFrameIndex(),
        -
        17517  allocation);
        -
        17518  }
        -
        17519 #endif
        -
        17520 
        -
        17521  if(buffer != VK_NULL_HANDLE)
        -
        17522  {
        -
        17523  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
        -
        17524  }
        -
        17525 
        -
        17526  if(allocation != VK_NULL_HANDLE)
        -
        17527  {
        -
        17528  allocator->FreeMemory(
        -
        17529  1, // allocationCount
        -
        17530  &allocation);
        -
        17531  }
        -
        17532 }
        -
        17533 
        -
        17534 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
        -
        17535  VmaAllocator allocator,
        -
        17536  const VkImageCreateInfo* pImageCreateInfo,
        -
        17537  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        -
        17538  VkImage* pImage,
        -
        17539  VmaAllocation* pAllocation,
        -
        17540  VmaAllocationInfo* pAllocationInfo)
        -
        17541 {
        -
        17542  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
        -
        17543 
        -
        17544  if(pImageCreateInfo->extent.width == 0 ||
        -
        17545  pImageCreateInfo->extent.height == 0 ||
        -
        17546  pImageCreateInfo->extent.depth == 0 ||
        -
        17547  pImageCreateInfo->mipLevels == 0 ||
        -
        17548  pImageCreateInfo->arrayLayers == 0)
        -
        17549  {
        -
        17550  return VK_ERROR_VALIDATION_FAILED_EXT;
        -
        17551  }
        -
        17552 
        -
        17553  VMA_DEBUG_LOG("vmaCreateImage");
        -
        17554 
        -
        17555  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17556 
        -
        17557  *pImage = VK_NULL_HANDLE;
        -
        17558  *pAllocation = VK_NULL_HANDLE;
        -
        17559 
        -
        17560  // 1. Create VkImage.
        -
        17561  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
        -
        17562  allocator->m_hDevice,
        -
        17563  pImageCreateInfo,
        -
        17564  allocator->GetAllocationCallbacks(),
        -
        17565  pImage);
        -
        17566  if(res >= 0)
        -
        17567  {
        -
        17568  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
        -
        17569  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
        -
        17570  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
        -
        17571 
        -
        17572  // 2. Allocate memory using allocator.
        -
        17573  VkMemoryRequirements vkMemReq = {};
        -
        17574  bool requiresDedicatedAllocation = false;
        -
        17575  bool prefersDedicatedAllocation = false;
        -
        17576  allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
        -
        17577  requiresDedicatedAllocation, prefersDedicatedAllocation);
        -
        17578 
        -
        17579  res = allocator->AllocateMemory(
        -
        17580  vkMemReq,
        -
        17581  requiresDedicatedAllocation,
        -
        17582  prefersDedicatedAllocation,
        -
        17583  VK_NULL_HANDLE, // dedicatedBuffer
        -
        17584  *pImage, // dedicatedImage
        -
        17585  *pAllocationCreateInfo,
        -
        17586  suballocType,
        -
        17587  1, // allocationCount
        -
        17588  pAllocation);
        -
        17589 
        -
        17590 #if VMA_RECORDING_ENABLED
        -
        17591  if(allocator->GetRecorder() != VMA_NULL)
        -
        17592  {
        -
        17593  allocator->GetRecorder()->RecordCreateImage(
        -
        17594  allocator->GetCurrentFrameIndex(),
        -
        17595  *pImageCreateInfo,
        -
        17596  *pAllocationCreateInfo,
        -
        17597  *pAllocation);
        -
        17598  }
        -
        17599 #endif
        -
        17600 
        -
        17601  if(res >= 0)
        -
        17602  {
        -
        17603  // 3. Bind image with memory.
        -
        17604  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
        -
        17605  {
        -
        17606  res = allocator->BindImageMemory(*pAllocation, 0, *pImage, VMA_NULL);
        -
        17607  }
        -
        17608  if(res >= 0)
        -
        17609  {
        -
        17610  // All steps succeeded.
        -
        17611  #if VMA_STATS_STRING_ENABLED
        -
        17612  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
        -
        17613  #endif
        -
        17614  if(pAllocationInfo != VMA_NULL)
        -
        17615  {
        -
        17616  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        -
        17617  }
        -
        17618 
        -
        17619  return VK_SUCCESS;
        -
        17620  }
        -
        17621  allocator->FreeMemory(
        -
        17622  1, // allocationCount
        -
        17623  pAllocation);
        -
        17624  *pAllocation = VK_NULL_HANDLE;
        -
        17625  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        -
        17626  *pImage = VK_NULL_HANDLE;
        -
        17627  return res;
        -
        17628  }
        -
        17629  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        -
        17630  *pImage = VK_NULL_HANDLE;
        -
        17631  return res;
        -
        17632  }
        -
        17633  return res;
        -
        17634 }
        -
        17635 
        -
        17636 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
        -
        17637  VmaAllocator allocator,
        -
        17638  VkImage image,
        -
        17639  VmaAllocation allocation)
        -
        17640 {
        -
        17641  VMA_ASSERT(allocator);
        -
        17642 
        -
        17643  if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        -
        17644  {
        -
        17645  return;
        -
        17646  }
        -
        17647 
        -
        17648  VMA_DEBUG_LOG("vmaDestroyImage");
        -
        17649 
        -
        17650  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        -
        17651 
        -
        17652 #if VMA_RECORDING_ENABLED
        -
        17653  if(allocator->GetRecorder() != VMA_NULL)
        -
        17654  {
        -
        17655  allocator->GetRecorder()->RecordDestroyImage(
        -
        17656  allocator->GetCurrentFrameIndex(),
        -
        17657  allocation);
        -
        17658  }
        -
        17659 #endif
        -
        17660 
        -
        17661  if(image != VK_NULL_HANDLE)
        -
        17662  {
        -
        17663  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
        -
        17664  }
        -
        17665  if(allocation != VK_NULL_HANDLE)
        -
        17666  {
        -
        17667  allocator->FreeMemory(
        -
        17668  1, // allocationCount
        -
        17669  &allocation);
        -
        17670  }
        -
        17671 }
        +
        17510  // 3. Allocate memory using allocator.
        +
        17511  res = allocator->AllocateMemory(
        +
        17512  vkMemReq,
        +
        17513  requiresDedicatedAllocation,
        +
        17514  prefersDedicatedAllocation,
        +
        17515  *pBuffer, // dedicatedBuffer
        +
        17516  VK_NULL_HANDLE, // dedicatedImage
        +
        17517  *pAllocationCreateInfo,
        +
        17518  VMA_SUBALLOCATION_TYPE_BUFFER,
        +
        17519  1, // allocationCount
        +
        17520  pAllocation);
        +
        17521 
        +
        17522 #if VMA_RECORDING_ENABLED
        +
        17523  if(allocator->GetRecorder() != VMA_NULL)
        +
        17524  {
        +
        17525  allocator->GetRecorder()->RecordCreateBuffer(
        +
        17526  allocator->GetCurrentFrameIndex(),
        +
        17527  *pBufferCreateInfo,
        +
        17528  *pAllocationCreateInfo,
        +
        17529  *pAllocation);
        +
        17530  }
        +
        17531 #endif
        +
        17532 
        +
        17533  if(res >= 0)
        +
        17534  {
        +
        17535  // 3. Bind buffer with memory.
        +
        17536  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
        +
        17537  {
        +
        17538  res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
        +
        17539  }
        +
        17540  if(res >= 0)
        +
        17541  {
        +
        17542  // All steps succeeded.
        +
        17543  #if VMA_STATS_STRING_ENABLED
        +
        17544  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
        +
        17545  #endif
        +
        17546  if(pAllocationInfo != VMA_NULL)
        +
        17547  {
        +
        17548  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        +
        17549  }
        +
        17550 
        +
        17551  return VK_SUCCESS;
        +
        17552  }
        +
        17553  allocator->FreeMemory(
        +
        17554  1, // allocationCount
        +
        17555  pAllocation);
        +
        17556  *pAllocation = VK_NULL_HANDLE;
        +
        17557  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        +
        17558  *pBuffer = VK_NULL_HANDLE;
        +
        17559  return res;
        +
        17560  }
        +
        17561  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        +
        17562  *pBuffer = VK_NULL_HANDLE;
        +
        17563  return res;
        +
        17564  }
        +
        17565  return res;
        +
        17566 }
        +
        17567 
        +
        17568 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
        +
        17569  VmaAllocator allocator,
        +
        17570  VkBuffer buffer,
        +
        17571  VmaAllocation allocation)
        +
        17572 {
        +
        17573  VMA_ASSERT(allocator);
        +
        17574 
        +
        17575  if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        +
        17576  {
        +
        17577  return;
        +
        17578  }
        +
        17579 
        +
        17580  VMA_DEBUG_LOG("vmaDestroyBuffer");
        +
        17581 
        +
        17582  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17583 
        +
        17584 #if VMA_RECORDING_ENABLED
        +
        17585  if(allocator->GetRecorder() != VMA_NULL)
        +
        17586  {
        +
        17587  allocator->GetRecorder()->RecordDestroyBuffer(
        +
        17588  allocator->GetCurrentFrameIndex(),
        +
        17589  allocation);
        +
        17590  }
        +
        17591 #endif
        +
        17592 
        +
        17593  if(buffer != VK_NULL_HANDLE)
        +
        17594  {
        +
        17595  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
        +
        17596  }
        +
        17597 
        +
        17598  if(allocation != VK_NULL_HANDLE)
        +
        17599  {
        +
        17600  allocator->FreeMemory(
        +
        17601  1, // allocationCount
        +
        17602  &allocation);
        +
        17603  }
        +
        17604 }
        +
        17605 
        +
        17606 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
        +
        17607  VmaAllocator allocator,
        +
        17608  const VkImageCreateInfo* pImageCreateInfo,
        +
        17609  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        +
        17610  VkImage* pImage,
        +
        17611  VmaAllocation* pAllocation,
        +
        17612  VmaAllocationInfo* pAllocationInfo)
        +
        17613 {
        +
        17614  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
        +
        17615 
        +
        17616  if(pImageCreateInfo->extent.width == 0 ||
        +
        17617  pImageCreateInfo->extent.height == 0 ||
        +
        17618  pImageCreateInfo->extent.depth == 0 ||
        +
        17619  pImageCreateInfo->mipLevels == 0 ||
        +
        17620  pImageCreateInfo->arrayLayers == 0)
        +
        17621  {
        +
        17622  return VK_ERROR_VALIDATION_FAILED_EXT;
        +
        17623  }
        +
        17624 
        +
        17625  VMA_DEBUG_LOG("vmaCreateImage");
        +
        17626 
        +
        17627  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17628 
        +
        17629  *pImage = VK_NULL_HANDLE;
        +
        17630  *pAllocation = VK_NULL_HANDLE;
        +
        17631 
        +
        17632  // 1. Create VkImage.
        +
        17633  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
        +
        17634  allocator->m_hDevice,
        +
        17635  pImageCreateInfo,
        +
        17636  allocator->GetAllocationCallbacks(),
        +
        17637  pImage);
        +
        17638  if(res >= 0)
        +
        17639  {
        +
        17640  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
        +
        17641  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
        +
        17642  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
        +
        17643 
        +
        17644  // 2. Allocate memory using allocator.
        +
        17645  VkMemoryRequirements vkMemReq = {};
        +
        17646  bool requiresDedicatedAllocation = false;
        +
        17647  bool prefersDedicatedAllocation = false;
        +
        17648  allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
        +
        17649  requiresDedicatedAllocation, prefersDedicatedAllocation);
        +
        17650 
        +
        17651  res = allocator->AllocateMemory(
        +
        17652  vkMemReq,
        +
        17653  requiresDedicatedAllocation,
        +
        17654  prefersDedicatedAllocation,
        +
        17655  VK_NULL_HANDLE, // dedicatedBuffer
        +
        17656  *pImage, // dedicatedImage
        +
        17657  *pAllocationCreateInfo,
        +
        17658  suballocType,
        +
        17659  1, // allocationCount
        +
        17660  pAllocation);
        +
        17661 
        +
        17662 #if VMA_RECORDING_ENABLED
        +
        17663  if(allocator->GetRecorder() != VMA_NULL)
        +
        17664  {
        +
        17665  allocator->GetRecorder()->RecordCreateImage(
        +
        17666  allocator->GetCurrentFrameIndex(),
        +
        17667  *pImageCreateInfo,
        +
        17668  *pAllocationCreateInfo,
        +
        17669  *pAllocation);
        +
        17670  }
        +
        17671 #endif
        17672 
        -
        17673 #endif // #ifdef VMA_IMPLEMENTATION
        +
        17673  if(res >= 0)
        +
        17674  {
        +
        17675  // 3. Bind image with memory.
        +
        17676  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
        +
        17677  {
        +
        17678  res = allocator->BindImageMemory(*pAllocation, 0, *pImage, VMA_NULL);
        +
        17679  }
        +
        17680  if(res >= 0)
        +
        17681  {
        +
        17682  // All steps succeeded.
        +
        17683  #if VMA_STATS_STRING_ENABLED
        +
        17684  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
        +
        17685  #endif
        +
        17686  if(pAllocationInfo != VMA_NULL)
        +
        17687  {
        +
        17688  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        +
        17689  }
        +
        17690 
        +
        17691  return VK_SUCCESS;
        +
        17692  }
        +
        17693  allocator->FreeMemory(
        +
        17694  1, // allocationCount
        +
        17695  pAllocation);
        +
        17696  *pAllocation = VK_NULL_HANDLE;
        +
        17697  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        +
        17698  *pImage = VK_NULL_HANDLE;
        +
        17699  return res;
        +
        17700  }
        +
        17701  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        +
        17702  *pImage = VK_NULL_HANDLE;
        +
        17703  return res;
        +
        17704  }
        +
        17705  return res;
        +
        17706 }
        +
        17707 
        +
        17708 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
        +
        17709  VmaAllocator allocator,
        +
        17710  VkImage image,
        +
        17711  VmaAllocation allocation)
        +
        17712 {
        +
        17713  VMA_ASSERT(allocator);
        +
        17714 
        +
        17715  if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        +
        17716  {
        +
        17717  return;
        +
        17718  }
        +
        17719 
        +
        17720  VMA_DEBUG_LOG("vmaDestroyImage");
        +
        17721 
        +
        17722  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        +
        17723 
        +
        17724 #if VMA_RECORDING_ENABLED
        +
        17725  if(allocator->GetRecorder() != VMA_NULL)
        +
        17726  {
        +
        17727  allocator->GetRecorder()->RecordDestroyImage(
        +
        17728  allocator->GetCurrentFrameIndex(),
        +
        17729  allocation);
        +
        17730  }
        +
        17731 #endif
        +
        17732 
        +
        17733  if(image != VK_NULL_HANDLE)
        +
        17734  {
        +
        17735  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
        +
        17736  }
        +
        17737  if(allocation != VK_NULL_HANDLE)
        +
        17738  {
        +
        17739  allocator->FreeMemory(
        +
        17740  1, // allocationCount
        +
        17741  &allocation);
        +
        17742  }
        +
        17743 }
        +
        17744 
        +
        17745 #endif // #ifdef VMA_IMPLEMENTATION
        -
        VmaRecordSettings
        Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSetting...
        Definition: vk_mem_alloc.h:1961
        -
        VmaVulkanFunctions::vkAllocateMemory
        PFN_vkAllocateMemory vkAllocateMemory
        Definition: vk_mem_alloc.h:1919
        -
        VmaDeviceMemoryCallbacks::pfnFree
        PFN_vmaFreeDeviceMemoryFunction pfnFree
        Optional, can be null.
        Definition: vk_mem_alloc.h:1851
        -
        VMA_RECORD_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1956
        -
        VmaVulkanFunctions::vkGetPhysicalDeviceProperties
        PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
        Definition: vk_mem_alloc.h:1917
        +
        VmaRecordSettings
        Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSetting...
        Definition: vk_mem_alloc.h:1978
        +
        VmaVulkanFunctions::vkAllocateMemory
        PFN_vkAllocateMemory vkAllocateMemory
        Definition: vk_mem_alloc.h:1936
        +
        VmaDeviceMemoryCallbacks::pfnFree
        PFN_vmaFreeDeviceMemoryFunction pfnFree
        Optional, can be null.
        Definition: vk_mem_alloc.h:1862
        +
        VMA_RECORD_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1973
        +
        VmaVulkanFunctions::vkGetPhysicalDeviceProperties
        PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
        Definition: vk_mem_alloc.h:1934
        vmaFreeMemory
        void vmaFreeMemory(VmaAllocator allocator, VmaAllocation allocation)
        Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(),...
        -
        PFN_vmaAllocateDeviceMemoryFunction
        void(VKAPI_PTR * PFN_vmaAllocateDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
        Callback function called after successful vkAllocateMemory.
        Definition: vk_mem_alloc.h:1828
        -
        VmaAllocatorCreateInfo::physicalDevice
        VkPhysicalDevice physicalDevice
        Vulkan physical device.
        Definition: vk_mem_alloc.h:1982
        +
        PFN_vmaAllocateDeviceMemoryFunction
        void(VKAPI_PTR * PFN_vmaAllocateDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
        Callback function called after successful vkAllocateMemory.
        Definition: vk_mem_alloc.h:1839
        +
        VmaAllocatorCreateInfo::physicalDevice
        VkPhysicalDevice physicalDevice
        Vulkan physical device.
        Definition: vk_mem_alloc.h:1999
        VmaAllocationInfo
        struct VmaAllocationInfo VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        -
        VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT
        Enables alternative, linear allocation algorithm in this pool.
        Definition: vk_mem_alloc.h:2548
        -
        VmaDefragmentationInfo2::allocationCount
        uint32_t allocationCount
        Number of allocations in pAllocations array.
        Definition: vk_mem_alloc.h:3085
        -
        VmaAllocatorCreateInfo::frameInUseCount
        uint32_t frameInUseCount
        Maximum number of additional frames that are in use at the same time as current frame.
        Definition: vk_mem_alloc.h:2008
        -
        VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT
        Definition: vk_mem_alloc.h:1906
        -
        VmaBudget
        Statistics of current memory usage and available budget, in bytes, for specific memory heap.
        Definition: vk_mem_alloc.h:2149
        +
        VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT
        Enables alternative, linear allocation algorithm in this pool.
        Definition: vk_mem_alloc.h:2575
        +
        VmaDefragmentationInfo2::allocationCount
        uint32_t allocationCount
        Number of allocations in pAllocations array.
        Definition: vk_mem_alloc.h:3112
        +
        VmaAllocatorCreateInfo::frameInUseCount
        uint32_t frameInUseCount
        Maximum number of additional frames that are in use at the same time as current frame.
        Definition: vk_mem_alloc.h:2025
        +
        VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT
        Definition: vk_mem_alloc.h:1923
        +
        VmaBudget
        Statistics of current memory usage and available budget, in bytes, for specific memory heap.
        Definition: vk_mem_alloc.h:2176
        vmaInvalidateAllocation
        void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        Invalidates memory of given allocation.
        -
        VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED
        Definition: vk_mem_alloc.h:2294
        +
        VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED
        Definition: vk_mem_alloc.h:2321
        VmaAllocationCreateInfo
        struct VmaAllocationCreateInfo VmaAllocationCreateInfo
        -
        VmaPoolStats
        Describes parameter of existing VmaPool.
        Definition: vk_mem_alloc.h:2620
        -
        VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT
        Definition: vk_mem_alloc.h:2377
        -
        VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
        Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
        Definition: vk_mem_alloc.h:1860
        -
        VmaPoolStats::unusedSize
        VkDeviceSize unusedSize
        Total number of bytes in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:2626
        -
        VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
        Definition: vk_mem_alloc.h:2357
        -
        VmaRecordFlagBits
        VmaRecordFlagBits
        Flags to be used in VmaRecordSettings::flags.
        Definition: vk_mem_alloc.h:1948
        +
        VmaPoolStats
        Describes parameter of existing VmaPool.
        Definition: vk_mem_alloc.h:2647
        +
        VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT
        Definition: vk_mem_alloc.h:2404
        +
        VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
        Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
        Definition: vk_mem_alloc.h:1871
        +
        VmaPoolStats::unusedSize
        VkDeviceSize unusedSize
        Total number of bytes in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:2653
        +
        VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
        Definition: vk_mem_alloc.h:2384
        +
        VmaRecordFlagBits
        VmaRecordFlagBits
        Flags to be used in VmaRecordSettings::flags.
        Definition: vk_mem_alloc.h:1965
        vmaSetPoolName
        void vmaSetPoolName(VmaAllocator allocator, VmaPool pool, const char *pName)
        Sets name of a custom pool.
        VmaAllocatorCreateInfo
        struct VmaAllocatorCreateInfo VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        -
        VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        Definition: vk_mem_alloc.h:1847
        +
        VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        Definition: vk_mem_alloc.h:1858
        vmaTouchAllocation
        VkBool32 vmaTouchAllocation(VmaAllocator allocator, VmaAllocation allocation)
        Returns VK_TRUE if allocation is not lost and atomically marks it as used in current frame.
        -
        VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
        Definition: vk_mem_alloc.h:2344
        -
        VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
        VkDeviceSize preferredLargeHeapBlockSize
        Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB....
        Definition: vk_mem_alloc.h:1988
        -
        VMA_RECORD_FLUSH_AFTER_CALL_BIT
        Enables flush after recording every function call.
        Definition: vk_mem_alloc.h:1954
        +
        VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
        Definition: vk_mem_alloc.h:2371
        +
        VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
        VkDeviceSize preferredLargeHeapBlockSize
        Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB....
        Definition: vk_mem_alloc.h:2005
        +
        VMA_RECORD_FLUSH_AFTER_CALL_BIT
        Enables flush after recording every function call.
        Definition: vk_mem_alloc.h:1971
        vmaResizeAllocation
        VkResult vmaResizeAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize newSize)
        Deprecated.
        -
        VmaVulkanFunctions::vkUnmapMemory
        PFN_vkUnmapMemory vkUnmapMemory
        Definition: vk_mem_alloc.h:1922
        -
        VmaAllocationInfo::deviceMemory
        VkDeviceMemory deviceMemory
        Handle to Vulkan memory object.
        Definition: vk_mem_alloc.h:2763
        -
        VmaStatInfo::unusedRangeCount
        uint32_t unusedRangeCount
        Number of free ranges of memory between allocations.
        Definition: vk_mem_alloc.h:2117
        -
        VmaAllocationCreateInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
        Definition: vk_mem_alloc.h:2451
        -
        VmaStatInfo::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Definition: vk_mem_alloc.h:2123
        -
        VmaVulkanFunctions::vkMapMemory
        PFN_vkMapMemory vkMapMemory
        Definition: vk_mem_alloc.h:1921
        +
        VmaVulkanFunctions::vkUnmapMemory
        PFN_vkUnmapMemory vkUnmapMemory
        Definition: vk_mem_alloc.h:1939
        +
        VmaAllocationInfo::deviceMemory
        VkDeviceMemory deviceMemory
        Handle to Vulkan memory object.
        Definition: vk_mem_alloc.h:2790
        +
        VmaStatInfo::unusedRangeCount
        uint32_t unusedRangeCount
        Number of free ranges of memory between allocations.
        Definition: vk_mem_alloc.h:2144
        +
        VmaAllocationCreateInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
        Definition: vk_mem_alloc.h:2478
        +
        VmaStatInfo::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Definition: vk_mem_alloc.h:2150
        +
        VmaVulkanFunctions::vkMapMemory
        PFN_vkMapMemory vkMapMemory
        Definition: vk_mem_alloc.h:1938
        VMA_RECORDING_ENABLED
        #define VMA_RECORDING_ENABLED
        Definition: vk_mem_alloc.h:1765
        -
        VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT
        Definition: vk_mem_alloc.h:2388
        +
        VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT
        Definition: vk_mem_alloc.h:2415
        vmaUnmapMemory
        void vmaUnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
        Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
        -
        VmaBudget::usage
        VkDeviceSize usage
        Estimated current memory usage of the program, in bytes.
        Definition: vk_mem_alloc.h:2174
        +
        VmaBudget::usage
        VkDeviceSize usage
        Estimated current memory usage of the program, in bytes.
        Definition: vk_mem_alloc.h:2201
        VmaAllocator
        Represents main object of this library initialized.
        -
        VmaVulkanFunctions::vkCmdCopyBuffer
        PFN_vkCmdCopyBuffer vkCmdCopyBuffer
        Definition: vk_mem_alloc.h:1933
        -
        VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        Definition: vk_mem_alloc.h:1976
        -
        VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT
        Set this flag to only try to allocate from existing VkDeviceMemory blocks and never create new such b...
        Definition: vk_mem_alloc.h:2318
        -
        VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:3071
        -
        VmaPoolStats::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Size of the largest continuous free memory region available for new allocation.
        Definition: vk_mem_alloc.h:2639
        -
        VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT
        Definition: vk_mem_alloc.h:2381
        -
        VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
        Enables usage of VK_KHR_dedicated_allocation extension.
        Definition: vk_mem_alloc.h:1882
        +
        VmaVulkanFunctions::vkCmdCopyBuffer
        PFN_vkCmdCopyBuffer vkCmdCopyBuffer
        Definition: vk_mem_alloc.h:1950
        +
        VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        Definition: vk_mem_alloc.h:1993
        +
        VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT
        Set this flag to only try to allocate from existing VkDeviceMemory blocks and never create new such b...
        Definition: vk_mem_alloc.h:2345
        +
        VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:3098
        +
        VmaPoolStats::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Size of the largest continuous free memory region available for new allocation.
        Definition: vk_mem_alloc.h:2666
        +
        VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT
        Definition: vk_mem_alloc.h:2408
        +
        VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
        Enables usage of VK_KHR_dedicated_allocation extension.
        Definition: vk_mem_alloc.h:1896
        vmaSetCurrentFrameIndex
        void vmaSetCurrentFrameIndex(VmaAllocator allocator, uint32_t frameIndex)
        Sets index of the current frame.
        -
        VmaDefragmentationInfo::maxAllocationsToMove
        uint32_t maxAllocationsToMove
        Maximum number of allocations that can be moved to different place.
        Definition: vk_mem_alloc.h:3165
        -
        VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT
        Definition: vk_mem_alloc.h:2372
        -
        VmaMemoryUsage
        VmaMemoryUsage
        Definition: vk_mem_alloc.h:2232
        +
        VmaDefragmentationInfo::maxAllocationsToMove
        uint32_t maxAllocationsToMove
        Maximum number of allocations that can be moved to different place.
        Definition: vk_mem_alloc.h:3192
        +
        VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT
        Definition: vk_mem_alloc.h:2399
        +
        VmaMemoryUsage
        VmaMemoryUsage
        Definition: vk_mem_alloc.h:2259
        vmaGetMemoryTypeProperties
        void vmaGetMemoryTypeProperties(VmaAllocator allocator, uint32_t memoryTypeIndex, VkMemoryPropertyFlags *pFlags)
        Given Memory Type Index, returns Property Flags of this memory type.
        -
        VmaStatInfo::blockCount
        uint32_t blockCount
        Number of VkDeviceMemory Vulkan memory blocks allocated.
        Definition: vk_mem_alloc.h:2113
        -
        VmaPoolCreateInfo::memoryTypeIndex
        uint32_t memoryTypeIndex
        Vulkan memory type index to allocate this pool from.
        Definition: vk_mem_alloc.h:2576
        -
        VmaPoolCreateInfo::blockSize
        VkDeviceSize blockSize
        Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes....
        Definition: vk_mem_alloc.h:2588
        -
        VmaDefragmentationInfo2::poolCount
        uint32_t poolCount
        Numer of pools in pPools array.
        Definition: vk_mem_alloc.h:3103
        +
        VmaStatInfo::blockCount
        uint32_t blockCount
        Number of VkDeviceMemory Vulkan memory blocks allocated.
        Definition: vk_mem_alloc.h:2140
        +
        VmaPoolCreateInfo::memoryTypeIndex
        uint32_t memoryTypeIndex
        Vulkan memory type index to allocate this pool from.
        Definition: vk_mem_alloc.h:2603
        +
        VmaPoolCreateInfo::blockSize
        VkDeviceSize blockSize
        Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes....
        Definition: vk_mem_alloc.h:2615
        +
        VmaDefragmentationInfo2::poolCount
        uint32_t poolCount
        Numer of pools in pPools array.
        Definition: vk_mem_alloc.h:3130
        vmaBuildStatsString
        void vmaBuildStatsString(VmaAllocator allocator, char **ppStatsString, VkBool32 detailedMap)
        Builds and returns statistics as string in JSON format.
        vmaGetAllocationInfo
        void vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
        Returns current information about specified allocation and atomically marks it as used in current fra...
        VmaDefragmentationStats
        struct VmaDefragmentationStats VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        -
        VmaPoolStats::allocationCount
        size_t allocationCount
        Number of VmaAllocation objects created from this pool that were not destroyed or lost.
        Definition: vk_mem_alloc.h:2629
        -
        VmaAllocatorCreateFlags
        VkFlags VmaAllocatorCreateFlags
        Definition: vk_mem_alloc.h:1910
        +
        VmaPoolStats::allocationCount
        size_t allocationCount
        Number of VmaAllocation objects created from this pool that were not destroyed or lost.
        Definition: vk_mem_alloc.h:2656
        +
        VmaAllocatorCreateFlags
        VkFlags VmaAllocatorCreateFlags
        Definition: vk_mem_alloc.h:1927
        vmaFreeStatsString
        void vmaFreeStatsString(VmaAllocator allocator, char *pStatsString)
        vmaAllocateMemoryForBuffer
        VkResult vmaAllocateMemoryForBuffer(VmaAllocator allocator, VkBuffer buffer, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        -
        VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1908
        -
        VmaDefragmentationFlagBits
        VmaDefragmentationFlagBits
        Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.
        Definition: vk_mem_alloc.h:3070
        -
        VmaAllocationInfo::offset
        VkDeviceSize offset
        Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory,...
        Definition: vk_mem_alloc.h:2768
        -
        VmaAllocationCreateFlagBits
        VmaAllocationCreateFlagBits
        Flags to be passed as VmaAllocationCreateInfo::flags.
        Definition: vk_mem_alloc.h:2300
        -
        VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
        PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
        Definition: vk_mem_alloc.h:1918
        -
        VmaPoolCreateFlags
        VkFlags VmaPoolCreateFlags
        Definition: vk_mem_alloc.h:2569
        +
        VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1925
        +
        VmaDefragmentationFlagBits
        VmaDefragmentationFlagBits
        Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.
        Definition: vk_mem_alloc.h:3097
        +
        VmaAllocationInfo::offset
        VkDeviceSize offset
        Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory,...
        Definition: vk_mem_alloc.h:2795
        +
        VmaAllocationCreateFlagBits
        VmaAllocationCreateFlagBits
        Flags to be passed as VmaAllocationCreateInfo::flags.
        Definition: vk_mem_alloc.h:2327
        +
        VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
        PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
        Definition: vk_mem_alloc.h:1935
        +
        VmaPoolCreateFlags
        VkFlags VmaPoolCreateFlags
        Definition: vk_mem_alloc.h:2596
        vmaCreateLostAllocation
        void vmaCreateLostAllocation(VmaAllocator allocator, VmaAllocation *pAllocation)
        Creates new allocation that is in lost state from the beginning.
        vmaGetPhysicalDeviceProperties
        void vmaGetPhysicalDeviceProperties(VmaAllocator allocator, const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        -
        VmaAllocationCreateInfo::pool
        VmaPool pool
        Pool that this allocation should be created in.
        Definition: vk_mem_alloc.h:2444
        +
        VmaAllocationCreateInfo::pool
        VmaPool pool
        Pool that this allocation should be created in.
        Definition: vk_mem_alloc.h:2471
        vmaGetMemoryProperties
        void vmaGetMemoryProperties(VmaAllocator allocator, const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties)
        -
        VmaStats::total
        VmaStatInfo total
        Definition: vk_mem_alloc.h:2131
        -
        VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
        Set this flag if the allocation should have its own memory block.
        Definition: vk_mem_alloc.h:2307
        +
        VmaStats::total
        VmaStatInfo total
        Definition: vk_mem_alloc.h:2158
        +
        VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
        Set this flag if the allocation should have its own memory block.
        Definition: vk_mem_alloc.h:2334
        vmaDefragmentationEnd
        VkResult vmaDefragmentationEnd(VmaAllocator allocator, VmaDefragmentationContext context)
        Ends defragmentation process.
        -
        VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT
        Definition: vk_mem_alloc.h:1894
        -
        VmaDefragmentationInfo2::flags
        VmaDefragmentationFlags flags
        Reserved for future use. Should be 0.
        Definition: vk_mem_alloc.h:3082
        -
        VmaVulkanFunctions::vkBindImageMemory
        PFN_vkBindImageMemory vkBindImageMemory
        Definition: vk_mem_alloc.h:1926
        -
        VmaDefragmentationInfo2::maxGpuBytesToMove
        VkDeviceSize maxGpuBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
        Definition: vk_mem_alloc.h:3134
        -
        VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        Definition: vk_mem_alloc.h:3169
        +
        VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT
        Definition: vk_mem_alloc.h:1911
        +
        VmaDefragmentationInfo2::flags
        VmaDefragmentationFlags flags
        Reserved for future use. Should be 0.
        Definition: vk_mem_alloc.h:3109
        +
        VmaVulkanFunctions::vkBindImageMemory
        PFN_vkBindImageMemory vkBindImageMemory
        Definition: vk_mem_alloc.h:1943
        +
        VmaDefragmentationInfo2::maxGpuBytesToMove
        VkDeviceSize maxGpuBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
        Definition: vk_mem_alloc.h:3161
        +
        VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        Definition: vk_mem_alloc.h:3196
        vmaDestroyPool
        void vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
        Destroys VmaPool object and frees Vulkan device memory.
        -
        VmaPoolStats::size
        VkDeviceSize size
        Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
        Definition: vk_mem_alloc.h:2623
        -
        VmaVulkanFunctions::vkFreeMemory
        PFN_vkFreeMemory vkFreeMemory
        Definition: vk_mem_alloc.h:1920
        -
        VmaRecordFlags
        VkFlags VmaRecordFlags
        Definition: vk_mem_alloc.h:1958
        -
        VMA_MEMORY_USAGE_CPU_ONLY
        Definition: vk_mem_alloc.h:2264
        -
        VmaDefragmentationInfo2::pPools
        VmaPool * pPools
        Either null or pointer to array of pools to be defragmented.
        Definition: vk_mem_alloc.h:3119
        +
        VmaPoolStats::size
        VkDeviceSize size
        Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
        Definition: vk_mem_alloc.h:2650
        +
        VmaVulkanFunctions::vkFreeMemory
        PFN_vkFreeMemory vkFreeMemory
        Definition: vk_mem_alloc.h:1937
        +
        VmaRecordFlags
        VkFlags VmaRecordFlags
        Definition: vk_mem_alloc.h:1975
        +
        VMA_MEMORY_USAGE_CPU_ONLY
        Definition: vk_mem_alloc.h:2291
        +
        VmaDefragmentationInfo2::pPools
        VmaPool * pPools
        Either null or pointer to array of pools to be defragmented.
        Definition: vk_mem_alloc.h:3146
        VmaAllocation
        Represents single memory allocation.
        -
        VMA_MEMORY_USAGE_CPU_COPY
        Definition: vk_mem_alloc.h:2286
        +
        VMA_MEMORY_USAGE_CPU_COPY
        Definition: vk_mem_alloc.h:2313
        vmaSetAllocationUserData
        void vmaSetAllocationUserData(VmaAllocator allocator, VmaAllocation allocation, void *pUserData)
        Sets pUserData in given allocation to new value.
        -
        VmaAllocatorCreateInfo::pRecordSettings
        const VmaRecordSettings * pRecordSettings
        Parameters for recording of VMA calls. Can be null.
        Definition: vk_mem_alloc.h:2052
        -
        VmaVulkanFunctions::vkBindBufferMemory
        PFN_vkBindBufferMemory vkBindBufferMemory
        Definition: vk_mem_alloc.h:1925
        -
        VmaVulkanFunctions::vkGetBufferMemoryRequirements
        PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
        Definition: vk_mem_alloc.h:1927
        -
        VmaDefragmentationInfo2::commandBuffer
        VkCommandBuffer commandBuffer
        Optional. Command buffer where GPU copy commands will be posted.
        Definition: vk_mem_alloc.h:3148
        -
        PFN_vmaFreeDeviceMemoryFunction
        void(VKAPI_PTR * PFN_vmaFreeDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
        Callback function called before vkFreeMemory.
        Definition: vk_mem_alloc.h:1834
        -
        VmaStats
        General statistics from current state of Allocator.
        Definition: vk_mem_alloc.h:2127
        -
        VmaPoolCreateInfo::minBlockCount
        size_t minBlockCount
        Minimum number of blocks to be always allocated in this pool, even if they stay empty.
        Definition: vk_mem_alloc.h:2593
        -
        VmaStatInfo
        Calculated statistics of memory usage in entire allocator.
        Definition: vk_mem_alloc.h:2110
        -
        VmaDefragmentationStats::bytesFreed
        VkDeviceSize bytesFreed
        Total number of bytes that have been released to the system by freeing empty VkDeviceMemory objects.
        Definition: vk_mem_alloc.h:3173
        +
        VmaAllocatorCreateInfo::pRecordSettings
        const VmaRecordSettings * pRecordSettings
        Parameters for recording of VMA calls. Can be null.
        Definition: vk_mem_alloc.h:2069
        +
        VmaVulkanFunctions::vkBindBufferMemory
        PFN_vkBindBufferMemory vkBindBufferMemory
        Definition: vk_mem_alloc.h:1942
        +
        VmaVulkanFunctions::vkGetBufferMemoryRequirements
        PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
        Definition: vk_mem_alloc.h:1944
        +
        VmaDefragmentationInfo2::commandBuffer
        VkCommandBuffer commandBuffer
        Optional. Command buffer where GPU copy commands will be posted.
        Definition: vk_mem_alloc.h:3175
        +
        PFN_vmaFreeDeviceMemoryFunction
        void(VKAPI_PTR * PFN_vmaFreeDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
        Callback function called before vkFreeMemory.
        Definition: vk_mem_alloc.h:1845
        +
        VmaStats
        General statistics from current state of Allocator.
        Definition: vk_mem_alloc.h:2154
        +
        VmaPoolCreateInfo::minBlockCount
        size_t minBlockCount
        Minimum number of blocks to be always allocated in this pool, even if they stay empty.
        Definition: vk_mem_alloc.h:2620
        +
        VmaAllocatorCreateInfo::vulkanApiVersion
        uint32_t vulkanApiVersion
        Optional. The highest version of Vulkan that the application is designed to use.
        Definition: vk_mem_alloc.h:2084
        +
        VmaStatInfo
        Calculated statistics of memory usage in entire allocator.
        Definition: vk_mem_alloc.h:2137
        +
        VmaDefragmentationStats::bytesFreed
        VkDeviceSize bytesFreed
        Total number of bytes that have been released to the system by freeing empty VkDeviceMemory objects.
        Definition: vk_mem_alloc.h:3200
        VmaStatInfo
        struct VmaStatInfo VmaStatInfo
        Calculated statistics of memory usage in entire allocator.
        VmaVulkanFunctions
        struct VmaVulkanFunctions VmaVulkanFunctions
        Pointers to some Vulkan functions - a subset used by the library.
        vmaFreeMemoryPages
        void vmaFreeMemoryPages(VmaAllocator allocator, size_t allocationCount, VmaAllocation *pAllocations)
        Frees memory and destroys multiple allocations.
        VmaDefragmentationInfo
        struct VmaDefragmentationInfo VmaDefragmentationInfo
        Deprecated. Optional configuration parameters to be passed to function vmaDefragment().
        -
        VMA_MEMORY_USAGE_GPU_ONLY
        Definition: vk_mem_alloc.h:2254
        +
        VMA_MEMORY_USAGE_GPU_ONLY
        Definition: vk_mem_alloc.h:2281
        vmaFindMemoryTypeIndex
        VkResult vmaFindMemoryTypeIndex(VmaAllocator allocator, uint32_t memoryTypeBits, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
        Helps to find memoryTypeIndex, given memoryTypeBits and VmaAllocationCreateInfo.
        vmaCreatePool
        VkResult vmaCreatePool(VmaAllocator allocator, const VmaPoolCreateInfo *pCreateInfo, VmaPool *pPool)
        Allocates Vulkan device memory and creates VmaPool object.
        -
        VmaStatInfo::unusedBytes
        VkDeviceSize unusedBytes
        Total number of bytes occupied by unused ranges.
        Definition: vk_mem_alloc.h:2121
        +
        VmaStatInfo::unusedBytes
        VkDeviceSize unusedBytes
        Total number of bytes occupied by unused ranges.
        Definition: vk_mem_alloc.h:2148
        vmaAllocateMemoryPages
        VkResult vmaAllocateMemoryPages(VmaAllocator allocator, const VkMemoryRequirements *pVkMemoryRequirements, const VmaAllocationCreateInfo *pCreateInfo, size_t allocationCount, VmaAllocation *pAllocations, VmaAllocationInfo *pAllocationInfo)
        General purpose memory allocation for multiple allocation objects at once.
        -
        VmaStatInfo::usedBytes
        VkDeviceSize usedBytes
        Total number of bytes occupied by all allocations.
        Definition: vk_mem_alloc.h:2119
        -
        VmaAllocatorCreateInfo::pAllocationCallbacks
        const VkAllocationCallbacks * pAllocationCallbacks
        Custom CPU memory allocation callbacks. Optional.
        Definition: vk_mem_alloc.h:1991
        -
        VmaAllocatorCreateFlagBits
        VmaAllocatorCreateFlagBits
        Flags for created VmaAllocator.
        Definition: vk_mem_alloc.h:1855
        +
        VmaStatInfo::usedBytes
        VkDeviceSize usedBytes
        Total number of bytes occupied by all allocations.
        Definition: vk_mem_alloc.h:2146
        +
        VmaAllocatorCreateInfo::pAllocationCallbacks
        const VkAllocationCallbacks * pAllocationCallbacks
        Custom CPU memory allocation callbacks. Optional.
        Definition: vk_mem_alloc.h:2008
        +
        VmaAllocatorCreateFlagBits
        VmaAllocatorCreateFlagBits
        Flags for created VmaAllocator.
        Definition: vk_mem_alloc.h:1866
        vmaAllocateMemoryForImage
        VkResult vmaAllocateMemoryForImage(VmaAllocator allocator, VkImage image, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        Function similar to vmaAllocateMemoryForBuffer().
        -
        VmaPoolCreateInfo::maxBlockCount
        size_t maxBlockCount
        Maximum number of blocks that can be allocated in this pool. Optional.
        Definition: vk_mem_alloc.h:2601
        -
        VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        Definition: vk_mem_alloc.h:2573
        -
        VmaDeviceMemoryCallbacks::pfnAllocate
        PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
        Optional, can be null.
        Definition: vk_mem_alloc.h:1849
        +
        VmaPoolCreateInfo::maxBlockCount
        size_t maxBlockCount
        Maximum number of blocks that can be allocated in this pool. Optional.
        Definition: vk_mem_alloc.h:2628
        +
        VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        Definition: vk_mem_alloc.h:2600
        +
        VmaDeviceMemoryCallbacks::pfnAllocate
        PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
        Optional, can be null.
        Definition: vk_mem_alloc.h:1860
        VmaRecordSettings
        struct VmaRecordSettings VmaRecordSettings
        Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSetting...
        VmaPool
        Represents custom memory pool.
        VmaBudget
        struct VmaBudget VmaBudget
        Statistics of current memory usage and available budget, in bytes, for specific memory heap.
        -
        VMA_MEMORY_USAGE_GPU_TO_CPU
        Definition: vk_mem_alloc.h:2280
        -
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
        Definition: vk_mem_alloc.h:2351
        -
        VmaPoolCreateInfo::flags
        VmaPoolCreateFlags flags
        Use combination of VmaPoolCreateFlagBits.
        Definition: vk_mem_alloc.h:2579
        -
        VMA_MEMORY_USAGE_MAX_ENUM
        Definition: vk_mem_alloc.h:2296
        -
        VmaStatInfo::allocationCount
        uint32_t allocationCount
        Number of VmaAllocation allocation objects allocated.
        Definition: vk_mem_alloc.h:2115
        -
        VmaVulkanFunctions::vkInvalidateMappedMemoryRanges
        PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
        Definition: vk_mem_alloc.h:1924
        +
        VMA_MEMORY_USAGE_GPU_TO_CPU
        Definition: vk_mem_alloc.h:2307
        +
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
        Definition: vk_mem_alloc.h:2378
        +
        VmaPoolCreateInfo::flags
        VmaPoolCreateFlags flags
        Use combination of VmaPoolCreateFlagBits.
        Definition: vk_mem_alloc.h:2606
        +
        VMA_MEMORY_USAGE_MAX_ENUM
        Definition: vk_mem_alloc.h:2323
        +
        VmaStatInfo::allocationCount
        uint32_t allocationCount
        Number of VmaAllocation allocation objects allocated.
        Definition: vk_mem_alloc.h:2142
        +
        VmaVulkanFunctions::vkInvalidateMappedMemoryRanges
        PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
        Definition: vk_mem_alloc.h:1941
        vmaAllocateMemory
        VkResult vmaAllocateMemory(VmaAllocator allocator, const VkMemoryRequirements *pVkMemoryRequirements, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        General purpose memory allocation.
        -
        VmaDefragmentationInfo2
        Parameters for defragmentation.
        Definition: vk_mem_alloc.h:3079
        -
        VmaDefragmentationInfo::maxBytesToMove
        VkDeviceSize maxBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places.
        Definition: vk_mem_alloc.h:3160
        -
        VmaBudget::blockBytes
        VkDeviceSize blockBytes
        Sum size of all VkDeviceMemory blocks allocated from particular heap, in bytes.
        Definition: vk_mem_alloc.h:2153
        -
        VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:2567
        -
        VmaAllocationCreateInfo::requiredFlags
        VkMemoryPropertyFlags requiredFlags
        Flags that must be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:2425
        -
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT
        Definition: vk_mem_alloc.h:2398
        -
        VmaStatInfo::allocationSizeAvg
        VkDeviceSize allocationSizeAvg
        Definition: vk_mem_alloc.h:2122
        +
        VmaDefragmentationInfo2
        Parameters for defragmentation.
        Definition: vk_mem_alloc.h:3106
        +
        VmaDefragmentationInfo::maxBytesToMove
        VkDeviceSize maxBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places.
        Definition: vk_mem_alloc.h:3187
        +
        VmaBudget::blockBytes
        VkDeviceSize blockBytes
        Sum size of all VkDeviceMemory blocks allocated from particular heap, in bytes.
        Definition: vk_mem_alloc.h:2180
        +
        VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:2594
        +
        VmaAllocationCreateInfo::requiredFlags
        VkMemoryPropertyFlags requiredFlags
        Flags that must be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:2452
        +
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT
        Definition: vk_mem_alloc.h:2425
        +
        VmaStatInfo::allocationSizeAvg
        VkDeviceSize allocationSizeAvg
        Definition: vk_mem_alloc.h:2149
        vmaDestroyAllocator
        void vmaDestroyAllocator(VmaAllocator allocator)
        Destroys allocator object.
        -
        VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
        const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
        Informative callbacks for vkAllocateMemory, vkFreeMemory. Optional.
        Definition: vk_mem_alloc.h:1994
        -
        VMA_ALLOCATION_CREATE_STRATEGY_MASK
        Definition: vk_mem_alloc.h:2402
        -
        VmaAllocatorCreateInfo::device
        VkDevice device
        Vulkan device.
        Definition: vk_mem_alloc.h:1985
        +
        VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
        const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
        Informative callbacks for vkAllocateMemory, vkFreeMemory. Optional.
        Definition: vk_mem_alloc.h:2011
        +
        VMA_ALLOCATION_CREATE_STRATEGY_MASK
        Definition: vk_mem_alloc.h:2429
        +
        VmaAllocatorCreateInfo::device
        VkDevice device
        Vulkan device.
        Definition: vk_mem_alloc.h:2002
        vmaFindMemoryTypeIndexForImageInfo
        VkResult vmaFindMemoryTypeIndexForImageInfo(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
        Helps to find memoryTypeIndex, given VkImageCreateInfo and VmaAllocationCreateInfo.
        VmaStats
        struct VmaStats VmaStats
        General statistics from current state of Allocator.
        vmaMapMemory
        VkResult vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
        Maps memory represented by given allocation and returns pointer to it.
        vmaBindBufferMemory
        VkResult vmaBindBufferMemory(VmaAllocator allocator, VmaAllocation allocation, VkBuffer buffer)
        Binds buffer to allocation.
        -
        VmaAllocatorCreateInfo::pHeapSizeLimit
        const VkDeviceSize * pHeapSizeLimit
        Either null or a pointer to an array of limits on maximum number of bytes that can be allocated out o...
        Definition: vk_mem_alloc.h:2033
        +
        VmaAllocatorCreateInfo::pHeapSizeLimit
        const VkDeviceSize * pHeapSizeLimit
        Either null or a pointer to an array of limits on maximum number of bytes that can be allocated out o...
        Definition: vk_mem_alloc.h:2050
        vmaCreateImage
        VkResult vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkImage *pImage, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        Function similar to vmaCreateBuffer().
        vmaFindMemoryTypeIndexForBufferInfo
        VkResult vmaFindMemoryTypeIndexForBufferInfo(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
        Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.
        -
        VmaBudget::budget
        VkDeviceSize budget
        Estimated amount of memory available to the program, in bytes.
        Definition: vk_mem_alloc.h:2185
        -
        VmaVulkanFunctions
        Pointers to some Vulkan functions - a subset used by the library.
        Definition: vk_mem_alloc.h:1916
        -
        VmaAllocationInfo::pMappedData
        void * pMappedData
        Pointer to the beginning of this allocation as mapped data.
        Definition: vk_mem_alloc.h:2782
        -
        VmaAllocatorCreateInfo::flags
        VmaAllocatorCreateFlags flags
        Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
        Definition: vk_mem_alloc.h:1979
        -
        VmaDefragmentationFlags
        VkFlags VmaDefragmentationFlags
        Definition: vk_mem_alloc.h:3073
        +
        VmaBudget::budget
        VkDeviceSize budget
        Estimated amount of memory available to the program, in bytes.
        Definition: vk_mem_alloc.h:2212
        +
        VmaVulkanFunctions
        Pointers to some Vulkan functions - a subset used by the library.
        Definition: vk_mem_alloc.h:1933
        +
        VmaAllocationInfo::pMappedData
        void * pMappedData
        Pointer to the beginning of this allocation as mapped data.
        Definition: vk_mem_alloc.h:2809
        +
        VmaAllocatorCreateInfo::flags
        VmaAllocatorCreateFlags flags
        Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
        Definition: vk_mem_alloc.h:1996
        +
        VmaDefragmentationFlags
        VkFlags VmaDefragmentationFlags
        Definition: vk_mem_alloc.h:3100
        vmaGetPoolStats
        void vmaGetPoolStats(VmaAllocator allocator, VmaPool pool, VmaPoolStats *pPoolStats)
        Retrieves statistics of existing VmaPool object.
        -
        VmaVulkanFunctions::vkCreateImage
        PFN_vkCreateImage vkCreateImage
        Definition: vk_mem_alloc.h:1931
        -
        VmaStatInfo::unusedRangeSizeAvg
        VkDeviceSize unusedRangeSizeAvg
        Definition: vk_mem_alloc.h:2123
        -
        VMA_MEMORY_USAGE_CPU_TO_GPU
        Definition: vk_mem_alloc.h:2271
        +
        VmaVulkanFunctions::vkCreateImage
        PFN_vkCreateImage vkCreateImage
        Definition: vk_mem_alloc.h:1948
        +
        VmaStatInfo::unusedRangeSizeAvg
        VkDeviceSize unusedRangeSizeAvg
        Definition: vk_mem_alloc.h:2150
        +
        VMA_MEMORY_USAGE_CPU_TO_GPU
        Definition: vk_mem_alloc.h:2298
        VmaDefragmentationInfo2
        struct VmaDefragmentationInfo2 VmaDefragmentationInfo2
        Parameters for defragmentation.
        -
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT
        Definition: vk_mem_alloc.h:2395
        -
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT
        Definition: vk_mem_alloc.h:2392
        -
        VmaAllocationCreateInfo::usage
        VmaMemoryUsage usage
        Intended usage of memory.
        Definition: vk_mem_alloc.h:2420
        -
        VmaStatInfo::allocationSizeMin
        VkDeviceSize allocationSizeMin
        Definition: vk_mem_alloc.h:2122
        +
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT
        Definition: vk_mem_alloc.h:2422
        +
        VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT
        Definition: vk_mem_alloc.h:2419
        +
        VmaAllocationCreateInfo::usage
        VmaMemoryUsage usage
        Intended usage of memory.
        Definition: vk_mem_alloc.h:2447
        +
        VmaStatInfo::allocationSizeMin
        VkDeviceSize allocationSizeMin
        Definition: vk_mem_alloc.h:2149
        vmaBindBufferMemory2
        VkResult vmaBindBufferMemory2(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize allocationLocalOffset, VkBuffer buffer, const void *pNext)
        Binds buffer to allocation with additional parameters.
        -
        VmaAllocationInfo::size
        VkDeviceSize size
        Size of this allocation, in bytes.
        Definition: vk_mem_alloc.h:2773
        -
        VmaRecordSettings::flags
        VmaRecordFlags flags
        Flags for recording. Use VmaRecordFlagBits enum.
        Definition: vk_mem_alloc.h:1964
        -
        VmaVulkanFunctions::vkFlushMappedMemoryRanges
        PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
        Definition: vk_mem_alloc.h:1923
        -
        VmaAllocationInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
        Definition: vk_mem_alloc.h:2787
        +
        VmaAllocationInfo::size
        VkDeviceSize size
        Size of this allocation, in bytes.
        Definition: vk_mem_alloc.h:2800
        +
        VmaRecordSettings::flags
        VmaRecordFlags flags
        Flags for recording. Use VmaRecordFlagBits enum.
        Definition: vk_mem_alloc.h:1981
        +
        VmaVulkanFunctions::vkFlushMappedMemoryRanges
        PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
        Definition: vk_mem_alloc.h:1940
        +
        VmaAllocationInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
        Definition: vk_mem_alloc.h:2814
        vmaMakePoolAllocationsLost
        void vmaMakePoolAllocationsLost(VmaAllocator allocator, VmaPool pool, size_t *pLostAllocationCount)
        Marks all allocations in given pool as lost if they are not used in current frame or VmaPoolCreateInf...
        -
        VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT
        Use this flag if you always allocate only buffers and linear images or only optimal images out of thi...
        Definition: vk_mem_alloc.h:2531
        +
        VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT
        Use this flag if you always allocate only buffers and linear images or only optimal images out of thi...
        Definition: vk_mem_alloc.h:2558
        vmaCreateBuffer
        VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        -
        VmaStats::memoryHeap
        VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
        Definition: vk_mem_alloc.h:2130
        -
        VmaAllocatorCreateInfo::pVulkanFunctions
        const VmaVulkanFunctions * pVulkanFunctions
        Pointers to Vulkan functions. Can be null if you leave define VMA_STATIC_VULKAN_FUNCTIONS 1.
        Definition: vk_mem_alloc.h:2045
        -
        VmaPoolStats::blockCount
        size_t blockCount
        Number of VkDeviceMemory blocks allocated for this pool.
        Definition: vk_mem_alloc.h:2642
        +
        VmaStats::memoryHeap
        VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
        Definition: vk_mem_alloc.h:2157
        +
        VmaAllocatorCreateInfo::pVulkanFunctions
        const VmaVulkanFunctions * pVulkanFunctions
        Pointers to Vulkan functions. Can be null if you leave define VMA_STATIC_VULKAN_FUNCTIONS 1.
        Definition: vk_mem_alloc.h:2062
        +
        VmaPoolStats::blockCount
        size_t blockCount
        Number of VkDeviceMemory blocks allocated for this pool.
        Definition: vk_mem_alloc.h:2669
        vmaCreateAllocator
        VkResult vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
        Creates Allocator object.
        vmaDefragment
        VkResult vmaDefragment(VmaAllocator allocator, VmaAllocation *pAllocations, size_t allocationCount, VkBool32 *pAllocationsChanged, const VmaDefragmentationInfo *pDefragmentationInfo, VmaDefragmentationStats *pDefragmentationStats)
        Deprecated. Compacts memory by moving allocations.
        vmaCheckCorruption
        VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
        Checks magic number in margins around all allocations in given memory types (in both default and cust...
        -
        VmaAllocationCreateFlags
        VkFlags VmaAllocationCreateFlags
        Definition: vk_mem_alloc.h:2409
        -
        VmaStats::memoryType
        VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
        Definition: vk_mem_alloc.h:2129
        -
        VmaAllocatorCreateInfo::instance
        VkInstance instance
        Optional handle to Vulkan instance object.
        Definition: vk_mem_alloc.h:2057
        +
        VmaAllocationCreateFlags
        VkFlags VmaAllocationCreateFlags
        Definition: vk_mem_alloc.h:2436
        +
        VmaStats::memoryType
        VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
        Definition: vk_mem_alloc.h:2156
        +
        VmaAllocatorCreateInfo::instance
        VkInstance instance
        Optional handle to Vulkan instance object.
        Definition: vk_mem_alloc.h:2075
        vmaFlushAllocation
        void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        Flushes memory of given allocation.
        VmaPoolStats
        struct VmaPoolStats VmaPoolStats
        Describes parameter of existing VmaPool.
        -
        VMA_MEMORY_USAGE_UNKNOWN
        Definition: vk_mem_alloc.h:2237
        -
        VmaDefragmentationInfo2::maxGpuAllocationsToMove
        uint32_t maxGpuAllocationsToMove
        Maximum number of allocations that can be moved to a different place using transfers on GPU side,...
        Definition: vk_mem_alloc.h:3139
        -
        VmaVulkanFunctions::vkDestroyBuffer
        PFN_vkDestroyBuffer vkDestroyBuffer
        Definition: vk_mem_alloc.h:1930
        -
        VmaPoolCreateInfo::frameInUseCount
        uint32_t frameInUseCount
        Maximum number of additional frames that are in use at the same time as current frame.
        Definition: vk_mem_alloc.h:2615
        -
        VmaVulkanFunctions::vkDestroyImage
        PFN_vkDestroyImage vkDestroyImage
        Definition: vk_mem_alloc.h:1932
        -
        VmaDefragmentationInfo2::maxCpuBytesToMove
        VkDeviceSize maxCpuBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
        Definition: vk_mem_alloc.h:3124
        +
        VMA_MEMORY_USAGE_UNKNOWN
        Definition: vk_mem_alloc.h:2264
        +
        VmaDefragmentationInfo2::maxGpuAllocationsToMove
        uint32_t maxGpuAllocationsToMove
        Maximum number of allocations that can be moved to a different place using transfers on GPU side,...
        Definition: vk_mem_alloc.h:3166
        +
        VmaVulkanFunctions::vkDestroyBuffer
        PFN_vkDestroyBuffer vkDestroyBuffer
        Definition: vk_mem_alloc.h:1947
        +
        VmaPoolCreateInfo::frameInUseCount
        uint32_t frameInUseCount
        Maximum number of additional frames that are in use at the same time as current frame.
        Definition: vk_mem_alloc.h:2642
        +
        VmaVulkanFunctions::vkDestroyImage
        PFN_vkDestroyImage vkDestroyImage
        Definition: vk_mem_alloc.h:1949
        +
        VmaDefragmentationInfo2::maxCpuBytesToMove
        VkDeviceSize maxCpuBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places using ...
        Definition: vk_mem_alloc.h:3151
        vmaGetPoolName
        void vmaGetPoolName(VmaAllocator allocator, VmaPool pool, const char **ppName)
        Retrieves name of a custom pool.
        -
        VmaAllocationInfo::memoryType
        uint32_t memoryType
        Memory type index that this allocation was allocated from.
        Definition: vk_mem_alloc.h:2754
        +
        VmaAllocationInfo::memoryType
        uint32_t memoryType
        Memory type index that this allocation was allocated from.
        Definition: vk_mem_alloc.h:2781
        vmaDestroyImage
        void vmaDestroyImage(VmaAllocator allocator, VkImage image, VmaAllocation allocation)
        Destroys Vulkan image and frees allocated memory.
        -
        VMA_ALLOCATION_CREATE_MAPPED_BIT
        Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
        Definition: vk_mem_alloc.h:2331
        +
        VMA_ALLOCATION_CREATE_MAPPED_BIT
        Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
        Definition: vk_mem_alloc.h:2358
        vmaCalculateStats
        void vmaCalculateStats(VmaAllocator allocator, VmaStats *pStats)
        Retrieves statistics from current state of the Allocator.
        vmaDestroyBuffer
        void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
        Destroys Vulkan buffer and frees allocated memory.
        -
        VmaVulkanFunctions::vkCreateBuffer
        PFN_vkCreateBuffer vkCreateBuffer
        Definition: vk_mem_alloc.h:1929
        +
        VmaVulkanFunctions::vkCreateBuffer
        PFN_vkCreateBuffer vkCreateBuffer
        Definition: vk_mem_alloc.h:1946
        VmaDeviceMemoryCallbacks
        struct VmaDeviceMemoryCallbacks VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        -
        VmaPoolStats::unusedRangeCount
        size_t unusedRangeCount
        Number of continuous memory ranges in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:2632
        -
        VmaPoolCreateFlagBits
        VmaPoolCreateFlagBits
        Flags to be passed as VmaPoolCreateInfo::flags.
        Definition: vk_mem_alloc.h:2513
        -
        VmaDefragmentationStats::bytesMoved
        VkDeviceSize bytesMoved
        Total number of bytes that have been copied while moving allocations to different places.
        Definition: vk_mem_alloc.h:3171
        -
        VmaStatInfo::unusedRangeSizeMin
        VkDeviceSize unusedRangeSizeMin
        Definition: vk_mem_alloc.h:2123
        -
        VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
        Definition: vk_mem_alloc.h:2362
        +
        VmaPoolStats::unusedRangeCount
        size_t unusedRangeCount
        Number of continuous memory ranges in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:2659
        +
        VmaPoolCreateFlagBits
        VmaPoolCreateFlagBits
        Flags to be passed as VmaPoolCreateInfo::flags.
        Definition: vk_mem_alloc.h:2540
        +
        VmaDefragmentationStats::bytesMoved
        VkDeviceSize bytesMoved
        Total number of bytes that have been copied while moving allocations to different places.
        Definition: vk_mem_alloc.h:3198
        +
        VmaStatInfo::unusedRangeSizeMin
        VkDeviceSize unusedRangeSizeMin
        Definition: vk_mem_alloc.h:2150
        +
        VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
        Definition: vk_mem_alloc.h:2389
        vmaCheckPoolCorruption
        VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
        Checks magic number in margins around all allocations in given memory pool in search for corruptions.
        vmaBindImageMemory
        VkResult vmaBindImageMemory(VmaAllocator allocator, VmaAllocation allocation, VkImage image)
        Binds image to allocation.
        -
        VmaAllocationCreateInfo::flags
        VmaAllocationCreateFlags flags
        Use VmaAllocationCreateFlagBits enum.
        Definition: vk_mem_alloc.h:2414
        -
        VmaVulkanFunctions::vkGetImageMemoryRequirements
        PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
        Definition: vk_mem_alloc.h:1928
        +
        VmaAllocationCreateInfo::flags
        VmaAllocationCreateFlags flags
        Use VmaAllocationCreateFlagBits enum.
        Definition: vk_mem_alloc.h:2441
        +
        VmaVulkanFunctions::vkGetImageMemoryRequirements
        PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
        Definition: vk_mem_alloc.h:1945
        vmaGetBudget
        void vmaGetBudget(VmaAllocator allocator, VmaBudget *pBudget)
        Retrieves information about current memory budget for all memory heaps.
        -
        VmaAllocationCreateInfo
        Definition: vk_mem_alloc.h:2411
        -
        VmaAllocationCreateInfo::preferredFlags
        VkMemoryPropertyFlags preferredFlags
        Flags that preferably should be set in a memory type chosen for an allocation.
        Definition: vk_mem_alloc.h:2430
        +
        VmaAllocationCreateInfo
        Definition: vk_mem_alloc.h:2438
        +
        VmaAllocationCreateInfo::preferredFlags
        VkMemoryPropertyFlags preferredFlags
        Flags that preferably should be set in a memory type chosen for an allocation.
        Definition: vk_mem_alloc.h:2457
        vmaDefragmentationBegin
        VkResult vmaDefragmentationBegin(VmaAllocator allocator, const VmaDefragmentationInfo2 *pInfo, VmaDefragmentationStats *pStats, VmaDefragmentationContext *pContext)
        Begins defragmentation process.
        vmaBindImageMemory2
        VkResult vmaBindImageMemory2(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize allocationLocalOffset, VkImage image, const void *pNext)
        Binds image to allocation with additional parameters.
        -
        VmaDefragmentationInfo2::pAllocationsChanged
        VkBool32 * pAllocationsChanged
        Optional, output. Pointer to array that will be filled with information whether the allocation at cer...
        Definition: vk_mem_alloc.h:3100
        -
        VmaDefragmentationStats::allocationsMoved
        uint32_t allocationsMoved
        Number of allocations that have been moved to different places.
        Definition: vk_mem_alloc.h:3175
        -
        VmaAllocationCreateInfo::memoryTypeBits
        uint32_t memoryTypeBits
        Bitmask containing one bit set for every memory type acceptable for this allocation.
        Definition: vk_mem_alloc.h:2438
        -
        VmaDefragmentationStats::deviceMemoryBlocksFreed
        uint32_t deviceMemoryBlocksFreed
        Number of empty VkDeviceMemory objects that have been released to the system.
        Definition: vk_mem_alloc.h:3177
        -
        VmaRecordSettings::pFilePath
        const char * pFilePath
        Path to the file that should be written by the recording.
        Definition: vk_mem_alloc.h:1972
        -
        VmaStatInfo::allocationSizeMax
        VkDeviceSize allocationSizeMax
        Definition: vk_mem_alloc.h:2122
        +
        VmaDefragmentationInfo2::pAllocationsChanged
        VkBool32 * pAllocationsChanged
        Optional, output. Pointer to array that will be filled with information whether the allocation at cer...
        Definition: vk_mem_alloc.h:3127
        +
        VmaDefragmentationStats::allocationsMoved
        uint32_t allocationsMoved
        Number of allocations that have been moved to different places.
        Definition: vk_mem_alloc.h:3202
        +
        VmaAllocationCreateInfo::memoryTypeBits
        uint32_t memoryTypeBits
        Bitmask containing one bit set for every memory type acceptable for this allocation.
        Definition: vk_mem_alloc.h:2465
        +
        VmaDefragmentationStats::deviceMemoryBlocksFreed
        uint32_t deviceMemoryBlocksFreed
        Number of empty VkDeviceMemory objects that have been released to the system.
        Definition: vk_mem_alloc.h:3204
        +
        VmaRecordSettings::pFilePath
        const char * pFilePath
        Path to the file that should be written by the recording.
        Definition: vk_mem_alloc.h:1989
        +
        VmaStatInfo::allocationSizeMax
        VkDeviceSize allocationSizeMax
        Definition: vk_mem_alloc.h:2149
        VmaPoolCreateInfo
        struct VmaPoolCreateInfo VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        -
        VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        Definition: vk_mem_alloc.h:2749
        -
        VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT
        Enables alternative, buddy allocation algorithm in this pool.
        Definition: vk_mem_alloc.h:2559
        -
        VmaBudget::allocationBytes
        VkDeviceSize allocationBytes
        Sum size of all allocations created in particular heap, in bytes.
        Definition: vk_mem_alloc.h:2164
        -
        VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:2407
        +
        VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        Definition: vk_mem_alloc.h:2776
        +
        VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT
        Enables alternative, buddy allocation algorithm in this pool.
        Definition: vk_mem_alloc.h:2586
        +
        VmaBudget::allocationBytes
        VkDeviceSize allocationBytes
        Sum size of all allocations created in particular heap, in bytes.
        Definition: vk_mem_alloc.h:2191
        +
        VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:2434
        VmaDefragmentationContext
        Represents Opaque object that represents started defragmentation process.
        -
        VmaDefragmentationInfo2::pAllocations
        VmaAllocation * pAllocations
        Pointer to array of allocations that can be defragmented.
        Definition: vk_mem_alloc.h:3094
        -
        VMA_POOL_CREATE_ALGORITHM_MASK
        Definition: vk_mem_alloc.h:2563
        -
        VmaDefragmentationInfo2::maxCpuAllocationsToMove
        uint32_t maxCpuAllocationsToMove
        Maximum number of allocations that can be moved to a different place using transfers on CPU side,...
        Definition: vk_mem_alloc.h:3129
        -
        VmaDefragmentationInfo
        Deprecated. Optional configuration parameters to be passed to function vmaDefragment().
        Definition: vk_mem_alloc.h:3155
        -
        VMA_ALLOCATION_CREATE_DONT_BIND_BIT
        Definition: vk_mem_alloc.h:2368
        +
        VmaDefragmentationInfo2::pAllocations
        VmaAllocation * pAllocations
        Pointer to array of allocations that can be defragmented.
        Definition: vk_mem_alloc.h:3121
        +
        VMA_POOL_CREATE_ALGORITHM_MASK
        Definition: vk_mem_alloc.h:2590
        +
        VmaDefragmentationInfo2::maxCpuAllocationsToMove
        uint32_t maxCpuAllocationsToMove
        Maximum number of allocations that can be moved to a different place using transfers on CPU side,...
        Definition: vk_mem_alloc.h:3156
        +
        VmaDefragmentationInfo
        Deprecated. Optional configuration parameters to be passed to function vmaDefragment().
        Definition: vk_mem_alloc.h:3182
        +
        VMA_ALLOCATION_CREATE_DONT_BIND_BIT
        Definition: vk_mem_alloc.h:2395
        Generated by   diff --git a/docs/html/vk_khr_dedicated_allocation.html b/docs/html/vk_khr_dedicated_allocation.html index 3b6496b..a5f25b9 100644 --- a/docs/html/vk_khr_dedicated_allocation.html +++ b/docs/html/vk_khr_dedicated_allocation.html @@ -87,8 +87,8 @@ $(function() {
      -
      VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
      Enables usage of VK_KHR_dedicated_allocation extension.
      Definition: vk_mem_alloc.h:1882
      -
      VmaAllocatorCreateInfo::flags
      VmaAllocatorCreateFlags flags
      Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
      Definition: vk_mem_alloc.h:1979
      +
      VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
      Enables usage of VK_KHR_dedicated_allocation extension.
      Definition: vk_mem_alloc.h:1896
      +
      VmaAllocatorCreateInfo::flags
      VmaAllocatorCreateFlags flags
      Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
      Definition: vk_mem_alloc.h:1996
      vmaCreateAllocator
      VkResult vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
      Creates Allocator object.
      diff --git a/src/VmaReplay/VmaReplay.cpp b/src/VmaReplay/VmaReplay.cpp index 1e50e03..a8f474c 100644 --- a/src/VmaReplay/VmaReplay.cpp +++ b/src/VmaReplay/VmaReplay.cpp @@ -2062,9 +2062,9 @@ int Player::InitVulkan() VkApplicationInfo appInfo = { VK_STRUCTURE_TYPE_APPLICATION_INFO }; appInfo.pApplicationName = "VmaReplay"; - appInfo.applicationVersion = VK_MAKE_VERSION(2, 2, 0); + appInfo.applicationVersion = VK_MAKE_VERSION(2, 3, 0); appInfo.pEngineName = "Vulkan Memory Allocator"; - appInfo.engineVersion = VK_MAKE_VERSION(2, 2, 0); + appInfo.engineVersion = VK_MAKE_VERSION(2, 3, 0); appInfo.apiVersion = VULKAN_API_VERSION; VkInstanceCreateInfo instInfo = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO }; diff --git a/src/VulkanSample.cpp b/src/VulkanSample.cpp index 7ea9fd8..ee3f8c8 100644 --- a/src/VulkanSample.cpp +++ b/src/VulkanSample.cpp @@ -32,8 +32,8 @@ static const char* const SHADER_PATH1 = "./"; static const char* const SHADER_PATH2 = "../bin/"; static const wchar_t* const WINDOW_CLASS_NAME = L"VULKAN_MEMORY_ALLOCATOR_SAMPLE"; static const char* const VALIDATION_LAYER_NAME = "VK_LAYER_LUNARG_standard_validation"; -static const char* const APP_TITLE_A = "Vulkan Memory Allocator Sample 2.3.0-development"; -static const wchar_t* const APP_TITLE_W = L"Vulkan Memory Allocator Sample 2.3.0-development"; +static const char* const APP_TITLE_A = "Vulkan Memory Allocator Sample 2.3.0-alpha.1"; +static const wchar_t* const APP_TITLE_W = L"Vulkan Memory Allocator Sample 2.3.0-alpha.1"; static const bool VSYNC = true; static const uint32_t COMMAND_BUFFER_COUNT = 2; diff --git a/src/vk_mem_alloc.h b/src/vk_mem_alloc.h index 656dc4a..19c48ff 100644 --- a/src/vk_mem_alloc.h +++ b/src/vk_mem_alloc.h @@ -29,7 +29,7 @@ extern "C" { /** \mainpage Vulkan Memory Allocator -Version 2.3.0-development (2019-11-02) +Version 2.3.0-alpha.1 (2019-11-25) Copyright (c) 2017-2019 Advanced Micro Devices, Inc. All rights reserved. \n License: MIT